summer-engine 4.3.0 → 4.5.0

package/library/skills/launch-ready/SKILL.md

@@ -0,0 +1,351 @@
+---
+name: launch-ready
+description: "Get a game ready to launch on Summer Games and take it live: upload, real screenshots, store art and listing, gathered and filled in."
+license: MIT
+compatibility: [Cursor, Claude Code, Windsurf, Codex]
+category: deployment
+user-invocable: true
+allowed-tools: Read Grep Glob Bash summer_get_project_context summer_read_file summer_export_game summer_publish_build summer_capture_gameplay summer_play summer_game_input summer_screenshot summer_stop summer_get_diagnostics summer_store_set_details summer_go_live summer_docs_read summer_call
+---
+
+# /launch-ready: gather everything the game needs, then take it live
+
+The `release-checklist` skill checks a game before launch and reports what is
+missing. This skill makes it pass: it exports and uploads the build, captures
+real gameplay screenshots, makes the key art and icons, writes the store page
+from the project, fills in every listing detail, shows the creator the result
+and takes the game live with one confirmation.
+
+The checklist is the source of the rules. Read it first
+(`summer_docs_read` with id `skill/release-checklist`); this skill names its
+rules by number (1.1 to 4.14) and says how to make each one pass.
+
+A call written `area.action` is the tool `summer_area_action` when your client
+lists it, else `summer_call` with `op: "area.action"`. Engine tools keep their
+`summer_*` names.
+
+## Rules that never bend
+
+- **Never invent a fact.** Every feature, mode, player count, language,
+  rating answer and AI answer comes from something you saw in the project or
+  in play, or from the creator. When you can't tell, ask.
+- **Screenshots are real gameplay.** Frames from the running game, unedited:
+  no captions, no overlays, no mockups, no AI edits. The game's own HUD may
+  show.
+- **Key art may be generated, but it shows this game:** its characters, its
+  world, its art style, and nothing it doesn't have. Start from a real
+  capture.
+- **Tags, genres and features describe the game.** They are not keywords for
+  reach. Pick only what is true; never add a popular tag the game doesn't
+  earn.
+- **The content rating, the content questionnaire and the AI disclosure are
+  statements the creator makes.** Draft them from evidence, show the
+  evidence, and have the creator confirm them. Parents' controls use the
+  rating, so when in doubt pick the stricter answer.
+- **Ask the creator** for what the project can't tell you: the price, the
+  support contact, the developer name, the release stage, and anything legal
+  or factual you could not see.
+- **Say what you will generate before you spend credits.** Every generation
+  call takes `dryRun: true` for the estimate.
+- **Nothing goes live before the creator's yes** to the summary in step 6.
+
+## The flow
+
+1. Find the game and run the checklist, changing nothing.
+2. Gather the facts from the project.
+3. Ask the creator once: the questions and the plan.
+4. Fix each failure: build, screenshots, art, listing.
+5. Run the checklist again until it passes.
+6. Show the creator everything and get one confirmation.
+7. Go live, and report live or the exact blocker.
+
+## 1. Find the game and run the checklist
+
+1. `summer_get_project_context`: binds the project and returns the main
+   scene and project memory (GameSoul, decisions).
+2. `games.list` finds the store game by name. When there is none, plan
+   `games.create` with the title and targets (it makes a draft; nothing is
+   published).
+3. Read the state: `store.get_listing` with `previews: true` (text, art per
+   slot, `checklist`, `readyToPublish`, `availableTags`), `store.status`
+   (every upload, its version, state and checks, and what is live) and
+   `pricing.get`.
+4. Mark every checklist rule pass, fail, not applicable or not run. Rules 1.x
+   and 2.x stay not run until step 4 exports and uploads.
+
+## 2. Gather the facts from the project
+
+Read before you write. Keep each fact with where you found it; the summary
+in step 6 shows the source.
+
+| Fact | Where |
+| --- | --- |
+| What the game is, its genre, its core loop, its look | `.summer/GameSoul.md`, `.summer/memory/`, `.summer/build-plan.md`, `README.md`, `project.godot` (`application/config/name`, `description`) |
+| The gameplay scene and how to reach it | The main scene, the title screen's buttons, the game's command-line flags (`OS.get_cmdline_user_args`) |
+| Online play | `summer.build.json` names a server; `Summer.client` matchmaking or join code |
+| Saves that follow the player | `Summer.authority.player_data` commits |
+| Purchases | `summer.items.json`, `Summer.client.store` calls |
+| Controller support | Joypad events in the InputMap: every action (full) or some (partial) |
+| Languages | `internationalization/locale/translations`, `.po` or `.csv` files; voiced lines and their subtitles |
+| Renderer and size | `rendering/renderer/rendering_method`; the export's file size |
+| Phone orientation | `display/window/handheld/orientation` |
+| Mature content | What you see in play, the dialogue and text files, the art |
+| AI use | Assets generated with Summer (`assets.get` says `aiGenerated`), `.summer/` generation records, code an agent wrote (git history, `.summer/` records, and you if you wrote any), AI that runs inside the game |
+
+Then **play it**: `summer_play`, reach the gameplay with `summer_game_input`,
+and look with `summer_screenshot` (`target: "game"`). Note the good moments
+for screenshots (below) and the inputs that reach them, and anything a
+rating answer depends on: violence, blood, language, flashing lights, other
+players. `summer_get_diagnostics`, then `summer_stop`.
+
+## 3. Ask the creator once
+
+One message, before anything changes or anything is spent:
+
+- **What is missing:** each failed rule, one line.
+- **What you will do:** export and upload version `vX.Y.Z`; capture N
+  screenshots; generate key art, icons, tall cover and capsules (with the
+  `dryRun` credit estimate); write the store text. Their yes approves these;
+  none of it makes the game live.
+- **What only they can answer**, as choices with your recommendation first:
+  - Price: free, or a price. A paid game needs their seller account set up
+    in Studio first; until then it stays free.
+  - Support contact: an email address or an https page.
+  - Developer name, and the publisher if there is one.
+  - Release stage: released, early access, or in development (listed only on
+    the In development page).
+  - Anything the evidence did not settle: chat with strangers, content made
+    by players, flashing lights, real-world brands or people.
+
+Wait for the answers.
+
+## 4. Fix each failure
+
+### Build (rules 1.1 to 2.5)
+
+What to upload (rule 1.5): a game with a server, or one for iPhone or
+Android, needs a store bundle (format `bundle`). A game without a server
+ships web and desktop as downloads (format `download`), one per platform.
+
+An upload is missing when `store.status` has none for a target, and stale
+when the newest one is older than the project's last change (`git log -1
+--format=%cI`, or the newest file outside `.godot/` and `.summer/`), failed,
+failed a check the creator owns, or carries a Summer version line older than
+the current release (rule 1.2).
+
+1. `summer_export_game`: format `bundle` (a game with a server passes its
+   `targets` and `alignDeclaration: true`), or format `download` with one
+   target. Read rules 1.1 to 1.5 from the answer.
+2. Run the `release-readiness` checks an agent can run on a bundle `.zip`
+   (1, 6, 7, 8 steps 1 to 4, 9). A failure there is a game change: show it
+   to the creator and fix it with their OK before uploading.
+3. `summer_publish_build` with the `gameId`, the next `clientVersion` (one
+   past the newest in `store.status`), the `platform` for a download, and
+   `confirm: true` (step 3 approved it). For a bundle, read `checksState`
+   and every `checks` entry: `owner: "creator"` means fix, export again and
+   upload a new version; `owner: "summer"` means nothing to change;
+   `checking` means call again. Keep the `publicationId`. A download is
+   ready when `store.status` says so (rule 2.5).
+
+### Screenshots (rules 3.4 and 3.7)
+
+1. **Pick the moments** from your play in step 2. Good moments show the
+   core action, different places, enemies or characters, and a reward or
+   upgrade screen. Skip menus, loading, pause, empty rooms, debug text and
+   near-duplicates.
+2. **Capture them full size** with `summer_capture_gameplay`: the gameplay
+   `scene`, or the game's `args` or `steps` to get past the title, one
+   `shot` step per moment, up to 10 frames. Use `resolution` `1920x1080` for
+   desktop. Phones take the same 1920x1080 frames when the game is
+   landscape, and `1080x1920` when it is portrait.
+3. **Look at every frame** before you use it. Drop black, blurred, title,
+   paused or repeated ones. A warning that frames are not the size you asked
+   for comes from the project's stretch settings: never upscale; tell the
+   creator and ask before changing the game.
+4. **Keep the best:** 4 to 8 for desktop, 3 to 8 for phones, the strongest
+   first.
+5. **Upload each one:** `assets.upload_begin`, run its `example` command
+   with the file path, then `assets.upload_complete` with `publicId`,
+   `version` and `uploadSignature` (`public_id`, `version` and `signature` in
+   that command's answer) and `format` `png`. You get an `assetId` and a
+   `fileUrl`.
+6. `store.set_art` with slot `desktop.screenshots` or `mobile.screenshots`
+   and the asset ids. Use `mode: "append"` to keep good screenshots already
+   on the page. Read `placed` and `checklist` in the answer.
+
+### Key art, icons, tall cover and capsules (rules 3.3, 3.5, 3.6, 3.8, 3.9)
+
+Load the `store-art` skill first (`summer_docs_read` with id
+`skill/store-art`) and follow it: it has each slot's current rules. Where it
+and this table differ, it wins.
+
+Start from the strongest capture: `assets.edit_image` with its `fileUrl` as
+`imageUrl`, the size below, and a prompt that keeps the game's characters,
+world, colours and art style, recomposes the scene for the slot, removes the
+HUD and adds no text. When the edit loses the game's look,
+`assets.generate_image` with the capture as `referenceImageUrl`.
+
+| Slot | Size to ask for | Text |
+| --- | --- | --- |
+| `desktop.keyArt`, `mobile.keyArt` | 2048x1152 (16:9) | None |
+| `mobile.tallCover` | 1152x2048 (9:16) | None |
+| `desktop.icon`, `mobile.icon` | 1024x1024 | None; one clear subject that reads small |
+| `desktop.capsuleTall` | 1200x1600 (3:4) | Only the game's own logo, when the project has one |
+| `desktop.capsuleWide` | 1472x688 (460:215) | Only the game's own logo, when the project has one |
+
+Each size is a multiple of 16 (what `assets.edit_image` takes) and above the
+slot's minimum. Both key art slots may use the same image, and both icons
+too. Never invent a logo.
+
+Look at every result (`assets.get`, then open its file). It must show this
+game. Make at most two tries per slot; when neither shows the game, ask the
+creator. Put each into its slot with `store.set_art`, with a `focalPoint` on
+key art and covers so the store's crops keep the subject. A shape refusal
+names the slot's rule: make it again at the right size. The page holds at
+most 20 images and videos (rule 3.10).
+
+### Listing details (rules 4.1 to 4.13)
+
+Load the `store-listing` skill (`summer_docs_read` with id
+`skill/store-listing`) for the writing rules. Then fill:
+
+| Field | From | With |
+| --- | --- | --- |
+| Title (4.1) | The current title; else the project's name | `store.update_listing` |
+| Tagline (4.2), short descriptions (4.3), long description (4.4) | GameSoul, README, what you saw in play: what the player does, the modes, the controls | `store.update_listing` |
+| Tags (4.5) | 3 to 8 that are true, from `availableTags` only | `store.update_listing` |
+| Targets (4.7) | The platforms the build was exported for | `store.update_listing` |
+| Support (4.11), release stage (4.12) | The creator's answers | `store.update_listing` |
+| Content rating and descriptors (4.8) | The questionnaire below, confirmed by the creator | `store.update_listing` |
+| Genres, features (4.6) | Genres from `availableTags` (category genre); features only the project proves | `summer_store_set_details` |
+| Credits, languages, system requirements | The creator's names; the languages the game ships; for requirements only what you know (operating systems from the targets, graphics from the renderer, storage from the export size, network when it plays online) | `summer_store_set_details` |
+| Content questionnaire (4.9) | Below | `summer_store_set_details` |
+| AI disclosure (4.10) | Below | `summer_store_set_details` |
+| Price (4.13) | The creator's answer | `pricing.set_base`, only for a price they chose |
+
+**The content questionnaire.** Answer each question from what you saw:
+violence (none, fantasy, realistic), blood, sexual content, nudity, strong
+language, substances, gambling (simulated or real money), content players
+make that others see, playing with others online, and purchases. `none` is
+an answer only after you looked. The content rating is the lowest of
+`everyone`, `everyone10Plus` and `teen` that honestly covers those answers,
+with every descriptor that applies (`[]` when none does). If no rating on
+the list covers the content, stop and ask the creator; never pick a milder
+one to fit.
+
+**The AI disclosure.** `assets` when any image, model, sound or video in the
+game or on its store page was generated (the art step above counts), `code`
+when an AI agent wrote code for it (you count, if you wrote any),
+`generatedGameplay` when the running game generates content with AI
+(describe what it generates and its guardrails). `[]` only when the creator
+confirms no AI was used.
+
+These drafts go on the page draft, which players don't see; the creator
+confirms them in step 6, before anything goes live.
+
+`pricing.set_base` may answer `needs_approval` (give the creator the link)
+or `seller_setup_required` (the game stays free until they set up selling in
+Studio; say so). Record the creator's answers and what you made in
+`.summer/build-plan.md`.
+
+## 5. Run the checklist again
+
+Read `store.get_listing` (`checklist`, `readyToPublish`) and `store.status`,
+and go through every rule. Fix what still fails and read again. Stop after
+three rounds that change nothing: report the rule, what you saw and who must
+act. A rule only the creator can clear (a seller account, a Studio setting)
+is reported, not retried.
+
+## 6. Show the creator everything, and get one confirmation
+
+1. `summer_go_live` with the `gameId`, the bundle's `publicationId` (when
+   there is one) and no `confirm`: it answers the plan (the platforms, the
+   version, the page).
+2. `store.preview_link` with the `gameId`: a private link to the page as
+   players will see it.
+3. One message:
+   - the preview link;
+   - every image with its slot: the local file path of each capture, and the
+     preview URLs from `store.get_listing` with `previews: true`, as images
+     where the chat shows them;
+   - all text, word for word: title, tagline, descriptions, tags, genres,
+     features, languages, requirements, support, release stage, price;
+   - the content questionnaire, the rating and the AI disclosure, each answer
+     with its evidence;
+   - the build version and its checks, and the release-readiness checks only
+     a player can run, marked not run;
+   - the credits spent;
+   - the go-live plan.
+4. Ask one question: take it live? A change request: make it, run the
+   affected part of the checklist again, show what changed and ask again.
+
+## 7. Go live
+
+`summer_go_live` with the `gameId`, the bundle's `publicationId` (when there
+is one) and `confirm: true`. Report its answer:
+
+- `live`: the store URL. Ask the creator to open it as a player on
+  summer.games and in the Summer Games apps, and to run the release-readiness
+  player checks (2, 8 step 5, 9 step 3, 10).
+- `blocked`: each failure with its fix. Fix them (step 4) and go live again;
+  a fix that changes what the creator saw needs their yes again.
+- `waiting` with `waitingOn: "summer"`: every check passed and Summer holds
+  the launch on its side. Nothing to fix; it goes live by itself. Call again
+  to keep watching. Never tell the creator to wait for a review.
+- `needs_permission`: their Agent permissions have Publish off. Ask them to
+  turn it on (Studio > Agent permissions), or use `store.publish`, which
+  returns a link for them to approve.
+- `needs_changes`: Summer sent the page back; fix every line of its feedback
+  and go live again.
+
+End with one line: **Live** with the store URL, or **Not live** with the
+exact blocker, who must act, and the next step.
+
+## Checklist
+
+- [ ] Read `release-checklist`, `store-art` and `store-listing` before acting.
+- [ ] Asked the creator once, before any spend or upload: price, support, developer, release stage, open facts.
+- [ ] The build is current, uploaded and every platform check is read.
+- [ ] Screenshots are unedited frames of real play, at slot size, looked at one by one.
+- [ ] Key art, icons, cover and capsules start from a real capture, carry no text (a capsule at most the game's own logo) and show this game.
+- [ ] Every listing fact has a source; tags, genres and features are true.
+- [ ] The rating, questionnaire and AI disclosure were confirmed by the creator.
+- [ ] The checklist passes, or the remaining blocker is named.
+- [ ] The creator saw the preview link, every image and all text, and said yes.
+- [ ] `summer_go_live` with `confirm: true` ran only after that yes; reported live or the exact blocker.
+
+<!-- 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 |
+|---|---|
+| `assets.generate_image` | `summer assets generate-image` |
+| `assets.get` | `summer assets get` |
+| `assets.upload_begin` | `summer assets upload-begin` |
+| `assets.upload_complete` | `summer assets upload-complete` |
+| `summer_docs_read` | `summer docs read` |
+| `summer_capture_gameplay` | `summer engine capture-gameplay` |
+| `summer_export_game` | `summer engine export-game` |
+| `summer_game_input` | `summer engine game-input` |
+| `summer_get_diagnostics` | `summer engine get-diagnostics` |
+| `summer_get_project_context` | `summer engine get-project-context` |
+| `summer_play` | `summer engine play` |
+| `summer_read_file` | `summer engine read-file` |
+| `summer_screenshot` | `summer engine screenshot` |
+| `summer_stop` | `summer engine stop` |
+| `games.create` | `summer games create` |
+| `games.list` | `summer games list` |
+| `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.preview_link` | `summer store preview-link` |
+| `store.publish` | `summer store publish` |
+| `store.set_art` | `summer store set-art` |
+| `summer_store_set_details` | `summer store set-details` |
+| `store.status` | `summer store status` |
+| `store.update_listing` | `summer store update-listing` |
+| `summer_publish_build` | `summer store upload-file` |
+<!-- /shell-commands -->

package/library/skills/launch-ready/resource.yaml

@@ -0,0 +1,45 @@
+id: skill/launch-ready
+kind: skill
+version: 1.0.0
+summary: "Get a game ready to launch on Summer Games and take it live: upload, real screenshots, store art and listing, gathered and filled in."
+use_when:
+  - "the user says 'get my game ready to launch', 'make my store page', 'publish my game to summer.games' or 'do everything it needs to go live'"
+  - "the release checklist fails and the agent should fix it: upload the game, capture gameplay screenshots, make key art and icons, write the store text"
+  - "filling a whole store page from the project itself: GameSoul and project memory, README, real gameplay captures"
+  - "drafting the content rating, content questionnaire and AI disclosure from the project, for the creator to confirm before launch"
+do_not_use_when:
+  - "only checking what is missing, without changing anything — skill/release-checklist"
+  - "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
+    - assets
+  modalities:
+    - images
+    - docs
+    - project
+compatibility:
+  engine: ">=4.6"
+related:
+  skills:
+    - skill/release-checklist
+    - skill/store-art
+    - skill/store-listing
+    - skill/publish-your-game
+    - skill/release-readiness
+  tools:
+    - tool/export-game
+    - tool/publish-build
+    - tool/capture-gameplay
+    - tool/store-set-details
+    - tool/go-live
+    - tool/get-project-context
+source: official
+license: MIT
+status: preview
+recommended: false
+bundled: false

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

@@ -0,0 +1,202 @@
+---
+name: make-content
+description: "Make a finished, postable video of your game, cut per platform and saved for review."
+license: MIT
+compatibility: [Cursor, Claude Code, Windsurf, Codex]
+category: video
+user-invocable: true
+allowed-tools: Read Grep Glob Write Edit Bash summer_docs_read summer_call summer_jobs_wait summer_capture_gameplay summer_assets_generate_video
+paths: ["content/**"]
+---
+
+# make-content: a finished piece of content for your game
+
+The person wants their game seen, not a content job. Decide everything and hand back a finished piece they only have to approve. Never hand back a plan, a draft list or questions you can answer yourself.
+
+## The method: copy one real video, beat for beat
+
+You do not freestyle. Real creators already found what works: copy their format one to one, beat for beat, with this game in it. Every piece starts from ONE reference video: a post from `content.list_references` (its clip from `content.get_reference`), or a real creator's video the person sends you.
+
+1. **Study the reference first**, before you capture anything:
+   - a frame-exact cut list: `ffmpeg -i ref.mp4 -vf "select='gt(scene,0.3)',showinfo" -f null -` (each `pts_time` is a cut; check by eye, lower the threshold for soft cuts);
+   - a transcript of any voice, with times;
+   - the text of every beat: its wording pattern ("POV: you...", "Day 12 making..."), where it sits, its size, when it comes and goes;
+   - the sound (where the beat drops, where the voice sits) and the total length.
+2. **Write a beat map** in `work/beats.md`: one row per reference beat with start, end, what happens, the text, the voice line, and which of our shots fills it. Every beat gets a shot; no beat is added or dropped.
+3. **Cut to the same timings** (each cut within 2 frames), the same text pattern in our words, the same voice structure (as many lines, the same rhythm, the same places) and the same length.
+4. **Check side by side before saving:** the reference and your cut next to each other (ffmpeg `hstack`), cut by cut. A beat that is off, missing or extra is a rebuild.
+
+Never invent a structure. If no reference fits, pick another moment, not your own structure. Copy the shape, never the material: no reference footage (a trend swap's swapped clip is the one exception), audio or caption text in the piece.
+
+## Hard rules (break one and it does not ship)
+
+1. **Highest quality always.** Never downscale or re-encode below the master to get past an upload limit; a 4K master goes up in 4K. Use a path that carries the full file.
+2. **No AI labels.** Never say or show that anything was made with AI: not in captions, titles, descriptions, on screen or in a voice-over.
+3. **No reference audio.** Never post the sound of the clip you followed. Use the game's own audio, a score made for this piece (`makers.game_score`), or a trending sound the person adds inside the app.
+4. **No credits to inspirations.** Never write "inspired by", never tag or name the creator or the game a format came from.
+5. **Vertical is reframed, never stretched.** Crop or zoom each shot onto its subject. Never squeeze, never letterbox, never a blurred copy behind the video.
+6. **No static end card on TikTok, Reels or Shorts.** The last beat is action; the play line goes over it.
+
+Also: real game footage only for gameplay (never generated gameplay or fake UI); never claim a feature that is not live; never name other games in public copy; fresh shots for every piece (never re-cut an old piece with new text); no labels, glows, shadows or overlays the kit did not ask for.
+
+## 1. How to run it
+
+1. **Run it in a background subagent.** The coding session never waits. The main agent says one line ("Cutting a TikTok of the new boss; the review link follows.") and goes back to work.
+2. **Asked: make it. Noticed a visible change: offer once, in one line** ("Clip the new boss fight for TikTok?"). Never ask about format, length or caption: decide.
+3. **Find the game.** `team.list` gives the `teamId`. `content.list_games` gives the `contentGameId` (`content.create_game` when it has none). Then read, in this order:
+   - `content.get_kit`: characters with pictures, colours, fonts, style, voice, do and don't rules, the store slug, and the Learnings section. The kit wins over this skill.
+   - `content.list_references`: what performs now and fits this game, best fit first, each with why it works and an idea for this game. Your reference comes from here.
+   - `content.search_library`: the team's raw clips, pictures and earlier pieces.
+   - `content.list_pieces`: the last pieces, so you do not repeat them.
+4. **Feedback first, without being asked.** At session start and after every `content.save_piece`, call `content.list_pieces` with the game and status `changes_requested`. A piece with `needsWork: true` comes before anything new: `whatToChange` says what the team wants. Fix it on the same reference and beat map, then `content.update_piece` with status `in_review` and `expectedRevision`. Nobody should have to tell you twice.
+5. **Work in `content/pieces/<slug>/`** in the project. Add `content/` to `.gitignore` before the first file. Keep `raw/`, `work/` and `final/` apart.
+6. **Deliver finished:** one render per platform, a cover, captions per platform, then `content.save_piece` and one line with the `reviewUrl`. That is the whole reply.
+7. **Keep watching.** While the session lives, read each piece you saved with `content.get_piece` every few minutes. When `needsWork` turns true, act on it at once and say in one line what you changed.
+
+Reload this skill any time with `docs.read` (`skill/make-content`).
+
+## 2. Pick the moment, then the reference
+
+- **Start from the moment:** what changed or what is best in the game right now. A new boss, a rare drop, a clutch win, a funny physics bug, a new skin, a milestone.
+- **Then ONE reference** whose `howGamesCanUseIt` fits that moment. Skip expired ones. Choose by the viewer hook (why a stranger stops scrolling), not by how it is made.
+- **Vary:** never the same reference format twice in a row; each piece differs from the last 5 on at least 2 of format, hook, opening frame, sound, length. A numbered series keeps its format on purpose. Over a week, at least half the pieces are gameplay pieces.
+
+## 3. Reference shapes by viewer hook
+
+What each kind of reference looks like, to choose which one to copy. The reference's own beats win over these notes. Lengths are vertical short-form unless noted; each example is a real, measured post.
+
+**Trend swap with a gameplay payoff.** Hook: the viral shape, your hero as the surprise. 7-15 s, the source's length. Swap your hero into the trending clip (`content.make_video` for a library reference, or `makers.bankai_swap` with the source video and a picture of your character): the one shape that keeps the source picture. End on the same hero doing the matching move in real gameplay. Example: a costume walk shot feet first in one 15 s take, the camera tilting up to the faces on the drop (54M views).
+
+**The reveal (the pull).** Hook: a rarity is coming. 6-10 s, or up to 50 s as a ranking. Name the payoff in the hook ("wait for the <rarest thing>."); rarity only climbs. Example: every reward of a secret drop ranked worst to best on a ladder of question marks, 59 cuts in 49 s, word-by-word captions (649K views).
+
+**Gameplay gag or fail.** Hook: a moment every player has lived, readable muted. 5-15 s, loops; the game writes the punchline (a death screen, a banner, a stat). Example: text builds word by word over a match ("you know you're a true player when..."), then an open goal missed: 3 shots, 14 s (583K views, 3x usual).
+
+**Clutch or big moment.** Hook: tension, then release. 8-35 s: the tension point, the result, a slow-motion replay of the key half second. Example: a speedrun time promised in the header, a big timer, a face cam with real stress, only the attempts kept (5.7M views).
+
+**Devlog with the dev's voice.** Hook: a person, a stance, visible progress. 20-55 s, voice at 0 s, proof on screen every 2-6 s, gameplay not menus. Example: a weekly Short opens on gameplay with "This week I added <one behavior>", then it plays out: 6 cuts in 51 s, 1.8-3.5M views a part. Also "Day <N> making a <genre> game".
+
+**WIP devlog (scuffed is fine).** Hook: real work, happening now. 20-40 s. Copy a real devlog's beats (a "this week I added..." Short is a good one) with a screen recording of the real dev session: the agent chat and the game changing, each reference beat filled by a moment something changes. Voice-over in the reference's line structure: the developer's own voice, or one that reads the key lines of the chat. Real footage only, captions burned in, no capture mode needed; rough is fine because it is real. The chat on screen is the session, not an AI label: add no "made with AI" text.
+
+**Comment reply (viewer ideas).** Hook: the community's idea, tested, as a numbered series. Example: one viewer suggestion per episode in a single 40 s screen recording, no cuts (2M views on a 2K-follower account).
+
+**Lore short.** Hook: a fact they half know. 20-60 s (100 s for a solved mystery): the claim over the exact thing at 0 s, the stakes by 8 s, a picture change every 2-3 s, the reveal said slower, an open question at the end. Example: a mystery solved through in-game logs, 96 s, 4.2M views on a 196K channel.
+
+**Hero, class or skin showcase.** Hook: choice and identity. 12-30 s, the best ability first, one hero per 1.5-2 s on the beat, a comment prompt at the end. Example: one moment recorded twice and stacked, the new skin in first person on top, the enemy's view below (419K views, 4x usual).
+
+**Trailer cut with a hook.** Hook: a premise nobody has seen, 12 words or fewer by 3 s. 20-22 s on Reels, 40-90 s on YouTube: 2-3 clean gameplay segments on the game's audio, then the name and "Play on summer.games/<slug>" from the kit ("coming soon" if not playable). Example: one tactile action in first person, then a pull back to thousands of the same thing, 13 cuts in 40 s (1.3M views on a 638-subscriber channel).
+
+**Shots that fill a beat:** a real screenshot animated (`makers.cinematic_shot`); before and after, both real; a build in steps, each changing the silhouette; a speed build with an honest clock; a premise card over clean gameplay.
+
+## 4. Footage
+
+Real gameplay wins: on our accounts real footage got 2,500-6,200 views and memes or generated visuals 270-380. Every piece shows at least 2 s of real gameplay; trend swaps end on it.
+
+**Capture to the beat map:** each beat needs its shot, at the beat's length plus a little to trim.
+
+**Choose the look before you capture.** This is where the first pieces failed. Pick the best map, time of day, camera and skins (never the placeholder hero or a bright test level), and write that choice into the kit's style. If no scene looks good, build a filming scene from the game's own assets: a real sky, some fog, lower exposure and bloom, a rim light on the hero. Film with the HUD off whenever you will add text. Never cut menu, store or concept art next to gameplay that does not look like it.
+
+**Reject these frames:** debug screens, blown-out bloom, empty white skies, T-poses, foot sliding, placeholder animations, pop-in, stutter, clipping cameras, missing textures, usernames, notifications, a cursor. No edit saves cheap footage; re-capture.
+
+Sources, best first:
+1. **The game's capture mode**, if it has one: HUD toggle, cinematic camera (orbit, follow, low hero angle, slow motion), bots for filming, forced results (a guaranteed legendary), every skin unlocked. If you own the code and it has none, add one behind a flag first; it pays back on every piece.
+2. **A web build in headless Chrome with the GPU on** (`--ignore-gpu-blocklist`). Record the game canvas, not the page: `canvas.captureStream(60)` into a `MediaRecorder` (H.264 if offered, about 40 Mbps), with the game's audio tapped from its `AudioContext`. Set the viewport to 1080x1920 and to 1920x1080 for separate takes (device scale 2 for a 4K master), so neither orientation is a crop of the other. Drive inputs from a script and record 3-5 takes per beat. Playwright's own `recordVideo` is soft and silent: use it only to plan shots.
+3. **A desktop run in movie mode:** start the game offscreen with `--write-movie shots/frame.png --fixed-fps 60` for lossless frames plus a WAV, frame-exact.
+4. **The team's raw clips** from `content.search_library`. Upload what you capture too (`content.upload_begin`), with a one-line description of what happens in it.
+5. **Stills:** `engine.capture_gameplay` saves real frames (up to 10) for covers, thumbnails and start frames; hide the HUD first if the game can. `engine.screenshot` and `engine.frame_shot` give a composed frame from the editor.
+6. **Shots made from real game art:** `makers.cinematic_shot` (a real frame plus a prompt), `assets.generate_video`, `makers.camera_moves`, `makers.character_turnaround`, from a real screenshot or the kit's pictures, in the game's style, hero on model. At most one per piece, and end on real gameplay.
+
+Capture at 30 fps or more (60 for action you will slow down), at the final aspect. To reframe 16:9 into 9:16, capture at 1440p or higher; never upscale more than 1.35x.
+
+## 5. Edit recipes
+
+You edit with your own tools (ffmpeg, scripts, Remotion if the project has it). The reference's timings, text and voice win; these are the defaults inside each beat.
+
+- **Frame 1 moves.** No idle start, no logo, no title card, no black. Something happens by 1 s.
+- **Cut on the first changed frame.** Drop dead frames. No freeze over 0.5 s in the first 1.5 s, and none over 1 s anywhere except the held payoff.
+- **Payoff where the reference has it** (usually before 70%), then hold it; short pieces loop, so the last frame leads back into the first.
+- **One idea per piece.** Never explain the joke.
+- **Text:** big, pure white, bold sans (the kit's font, else Inter Bold), no shadow, no outline, no box behind it unless the kit says so. One text layer at a time (a fixed header, a premise card or a timer is that layer), 7 words or fewer, two sizes at most (title about 7% of the width on vertical). At least 40 px tall on a 1080-wide frame. Put it on a calm part of the frame, never over the game's HUD, a face or the action, and keep it in one place. Wrap a long line to two big lines; never shrink it.
+- **Vertical:** per shot, `scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920:X:Y` with X and Y on the subject (use 2160x3840 when the source carries it). Move the crop at most once per shot, slowly.
+- **Sound:** audio at 0 s and to the last frame; no dead air. The game's audio carries gameplay. Under a voice, music sits 18-22 LU lower or not at all. Build the audio track once for the whole cut, not per segment (per-segment audio drifts out of sync). Loudness -14 LUFS integrated, true peak -1 dBTP or lower.
+- **Generated motion in a drawn style:** step it to 12 frames a second; smooth motion reads as fake.
+- **Encode:** H.264 High, yuv420p, CRF 17, preset slow, 30 fps (keep 60 if the source has it), AAC 192k, `+faststart`. At least 4000 kbps at 1080p and about 16000 at 4K.
+
+## 6. Per platform
+
+Make a separate render when length, safe zones or aspect differ. One file copied to every platform is not a per-platform cut.
+
+| Platform | Frame | Length | Notes |
+|---|---|---|---|
+| TikTok | 1080x1920 (a full-frame 16:9 trailer also works) | 5-15 s for gags and trends, 15-35 s otherwise | No end card: the action line goes over the last action. Link in bio and in the first comment. |
+| Instagram Reels | 1080x1920 | 20-22 s, or the trend's length | No end card. The grid crops the cover to the centre 3:4 (y 240-1680): keep the cover text there. |
+| YouTube Shorts | 1080x1920 or square | 5-15 s loops, 30-58 s otherwise | Anything wider than square counts as long-form and gets no Shorts reach. Title up to 100 characters, hook in the first 40. No end card. |
+| X | 1920x1080 or 1080x1080 | 30-90 s best, 140 s at most | Vertical does badly. Burn in the captions (muted autoplay). Link in a reply, not the post. |
+| YouTube long | 1920x1080 or 3840x2160 | 4-15 min | Devlogs and trailers. Title as a search phrase. Thumbnail 1280x720 or larger, 3 words at most. Chapters from 00:00. No music under a voice; ship an SRT. |
+
+**Safe zones on vertical:** keep text and key action out of the top 14%, the bottom 25%, 7% at each side, and the right 13% between 30% and 80% of the height.
+
+## 7. Hooks, captions, sound
+
+**Hooks:** use the reference's hook pattern in our words. Shapes that work: the maker's story with a number ("<N> people. <N> years."); one mystery; one detail, magnified (a second-person premise: "You start as <something tiny>"); a personal, lowercase discovery; naming the payoff. **Weak:** "X but Y" comparisons, "from the studio behind", a logo or title first, a slow establishing shot. On-screen hook: 7 words or fewer, readable in 1.5 s. Spoken hook: 12 words or fewer, finished by 3 s. Rotate openers outside a series.
+
+**Captions:** one dry line, one question that invites an answer, and the words people search for. The game name in plain text. Use 3-5 hashtags on video platforms, the game's tag first, then 1-2 niche tags and at most one trend tag. No em dashes, no emojis, no numbers you cannot source. Avoid kill, blood, murder and death in captions, titles and tags: reach drops.
+
+**First comment:** the play link from the kit. Check it opens on a phone first. If the game is not playable yet, say "coming soon", never "play now".
+
+**Sound:** the game's own audio or a score made for the piece. For a trending sound, cut on its beat using its audio for timing only, strip it, export with game sound, and write the sound and its start time in `suggestedSound` ("<sound name>, start 0:34"); the person adds it in the app.
+
+## 8. Taste bar and self-check
+
+**Why the first pieces failed.** Summer's first game clips passed a measured critic at 7-8 of 10, and the game's maker called them very bad: a bright test map, the placeholder hero, bloom blobs, mismatched menu art, captions on the HUD. Checks catch mistakes, not a cheap look. Taste comes first.
+
+**The taste test.** Put your frame 1 and your best frame next to the game's best art (the kit's character pictures and references, the store art) and next to the reference clip, at phone size. If yours looks cheaper, emptier or smaller, re-capture before you polish. Would a stranger stop on frame 1 with the sound off? Would the team post this on their own account today? If not, it is not done.
+
+**Measured checks (script them; all must pass):**
+- Side by side with the reference: every cut within 2 frames, the same text pattern and voice structure, the same length.
+- A contact sheet every 0.5 s of every render, that you actually look at.
+- Motion in frame 1: no freeze over 0.5 s in the first 1.5 s (`freezedetect`), none over 1 s anywhere except the held payoff.
+- Text at least 40 px on a 1080-wide frame, inside the safe zones, clear of the HUD and faces.
+- Loudness -14 LUFS (plus or minus 1), true peak -1 dBTP or lower, no silence over 0.5 s (`silencedetect` at -50 dB), audio as long as the video.
+- At least 2 s of real gameplay. Short side at least 1080 px. No stretched shot.
+- Copy: no AI words, no other game named, nothing that is not live, the link works.
+- Different from the last 5 pieces on at least 2 of format, hook, opening frame, sound, length.
+
+**Fresh critic.** Spawn a new subagent with none of your context. Give it the renders, the captions, the reference clip, your beat map and the game's best art. It answers first: does any frame look cheaper than that art (test map, placeholder hero, bloom blobs, empty sky, mismatched menu art, text on the HUD, a debug screen)? Any yes is a rebuild, whatever the score. Then it plays the reference and the piece side by side, beat by beat, watches the first 1.5 s muted, and gives the one idea, whether it stops the scroll, what reads wrong, and a score from 1 to 10 with timestamps. Rebuild below 8, at most twice, and keep the better render. If it still scores under 8, save it with status `draft` and say in `notes` and in your reply line what blocks it. The final score goes in `selfScore`.
+
+## 9. Upload and save
+
+1. For each render and cover: `content.upload_begin` (`fileName`, `contentType`, `size` in bytes) gives an `uploadUrl`; PUT the file there with that content type; then `content.upload_complete` (`uploadId`, `title`, `description` of what happens in it, `tags`, `folder`) gives the item id.
+2. `content.save_piece` with `contentGameId`, `title`, `format`, and `variants` (1-5, one per platform: `platform` of `tiktok`, `instagram`, `youtube`, `youtube_long` or `x`; `itemId`; `coverItemId`; `caption`; `title` for YouTube; `hashtags`; `firstComment`; `suggestedSound`). Add `referenceId` (always: the reference you copied), `sourceItemIds`, `gameplaySeconds`, `selfScore`, `notes`, and what Today shows under the player: `why` (`referenceId`, `fitReason`: one line on why it fits today, like the commit you saw, `refStats` with `views`, `likes`, `breakoutRatio`, `postedAt`), `checks` (`hook_seconds`, `min_shot_motion`, `safe_zone`, `loudness_lufs`, `true_peak_db`, `length_seconds`, `gameplay_seconds`, each with the measured `value` and `pass`; never a predicted score), `sideBySideItemId` (a library video: the reference left, yours right, synced), `contactSheetItemId`, `learningIds` (the kit learnings you applied) and `tomorrow` (what you make next). `summer content make` does all of this and reports each stage to its make request (`content.make`, `content.claim_make`, `content.update_make`; `jobs.wait` on `make:<requestId>`). It lands on the team's Today view.
+3. Reply with one line and the `reviewUrl`.
+4. Keep watching it (section 1, step 7). Feedback arrives on the piece: `needsWork` and `whatToChange`. Revise with `content.update_piece` (pass `expectedRevision`; status `in_review` sends it back). When the team says it is posted, `content.mark_posted`.
+
+## 10. Learnings
+
+Every Change note and Skip reason becomes a learning in the kit by itself (`content.get_kit` `learnings`, with the piece it came from). Read them first on every run, follow each one, and list the ones you applied in `learningIds`. The team removes one with `content.delete_learning`. A data rule you find yourself stays a hypothesis until 3 pieces beat the account's median by 1.5x.
+
+<!-- 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 |
+|---|---|
+| `assets.generate_video`, `summer_assets_generate_video` | `summer assets generate-video` |
+| `content.get_kit` | `summer content get-kit` |
+| `content.list_games` | `summer content list-games` |
+| `content.list_references` | `summer content list-references` |
+| `content.make` | `summer content make` |
+| `content.make_video` | `summer content make-video` |
+| `content.mark_posted` | `summer content mark-posted` |
+| `docs.read`, `summer_docs_read` | `summer docs read` |
+| `engine.capture_gameplay`, `summer_capture_gameplay` | `summer engine capture-gameplay` |
+| `engine.frame_shot` | `summer engine frame-shot` |
+| `engine.screenshot` | `summer engine screenshot` |
+| `jobs.wait`, `summer_jobs_wait` | `summer jobs wait` |
+| `makers.bankai_swap` | `summer makers bankai-swap` |
+| `makers.camera_moves` | `summer makers camera-moves` |
+| `makers.character_turnaround` | `summer makers character-turnaround` |
+| `makers.cinematic_shot` | `summer makers cinematic-shot` |
+| `makers.game_score` | `summer makers game-score` |
+| `team.list` | `summer team list` |
+<!-- /shell-commands -->

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

@@ -0,0 +1,32 @@
+id: skill/make-content
+kind: skill
+version: 1.0.0
+summary: "Make a finished, postable video of your game, cut per platform and saved for review."
+use_when:
+  - "a developer asks for content for their game: a TikTok, Reels or Shorts clip, an X video, a trailer cut or a devlog"
+  - "a visible change just landed (a boss, a skin, a level, a rare drop) and a short clip of it would do well on social"
+  - "a piece of content came back with a Change note on the team's Today view"
+do_not_use_when:
+  - "one generated trailer shot with no edit around it (use trailer-shot)"
+  - "a scripted story cutscene inside the game (use cinematic-cutscene)"
+  - "store page art: key art, covers, icons, screenshots (use store-art)"
+facets:
+  lifecycle:
+    - grow
+    - launch
+  domains:
+    - creator
+    - video
+  modalities:
+    - video
+related:
+  skills:
+    - skill/trailer-shot
+    - skill/cinematic-cutscene
+    - skill/store-art
+  tools:
+    - tool/capture-gameplay
+source: official
+license: MIT
+status: stable
+recommended: false