summer-engine 4.3.0 → 4.5.0

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

@@ -0,0 +1,132 @@
+id: tool/content-make
+kind: tool
+version: 1.0.0
+summary: Make a piece of content for a game. Copies a library reference beat for beat with footage on this computer, checks it, saves it to Review.
+use_when:
+  - '"make a piece of content for this"'
+  - '"clip what we just built"'
+  - '"make today''s TikTok for my game"'
+  - '"copy this reference with our footage"'
+  - a daily run that puts one finished piece per game in Review (claim the queued make request)
+  - a Change the team pressed on Today (claim; it answers needs_changes)
+  - revising a piece after the team asked for changes (same workDir)
+do_not_use_when:
+  - posting - the team posts from Review; nothing is posted from here
+  - generating video or pictures - it cuts the game's real footage
+  - the game has no footage on this computer - record some first (capture mode, a screen recording)
+  - writing the words - the caller writes our lines; it never invents them and never reuses the reference's
+facets:
+  lifecycle:
+    - launch
+  domains:
+    - creator
+    - video
+compatibility:
+  engine: ">=4.6"
+source: official
+license: MIT
+status: preview
+aliases:
+  - summer_content_make
+implementation:
+  module: src/core/capabilities/content-make/index.ts
+  export: contentMake
+surfaces:
+  mcp:
+    tool_name: summer_content_make
+    remote: true
+input_schema:
+  type: object
+  properties:
+    contentGameId:
+      type: string
+      description: The game's Content id, from content.list_games. Not needed with workDir.
+    teamId:
+      type: string
+      description: From team.list, when the person has more than one team.
+    referenceId:
+      type: string
+      description: The reference to copy, from content.list_references. Without it the best fit for today is picked (a format the game has not posted, what changed in the repo, its breakout).
+    footage:
+      type: array
+      items:
+        type: string
+      description: Folders (or files) of the game's footage on this computer - clips, stills, and the game's own music. Notes in a folder's shots.json or a clip's <clip>.json help match shots. Default ./content/footage.
+    lines:
+      type: array
+      items:
+        type: string
+      description: Our words, one per reference beat ("" for a beat without words), from the needs_words answer - the reference's pattern, true to the game, never its own words.
+    voiceFile:
+      type: string
+      description: The lines recorded in the team's own voice (wav, mp3, m4a), when the reference speaks (needs_voice).
+    title:
+      type: string
+      description: The piece's title in Review (also the YouTube title).
+    caption:
+      type: string
+      description: The post caption - one dry line and a question, no hashtags.
+    hashtags:
+      type: array
+      items:
+        type: string
+      description: 3-5 tags, the game's tag first. Default the kit's core tags.
+    note:
+      type: string
+      description: 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:
+      type: boolean
+      description: 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; nothing_queued when none, needs_changes for a revision.
+    requestId:
+      type: string
+      description: The make request to claim, from content.make.
+    learningIds:
+      type: array
+      items:
+        type: string
+      description: The kit learnings (content.get_kit learnings, listed in needs_words) the words and choices applied.
+    workDir:
+      type: string
+      description: The work folder an earlier call answered - continues that piece where it stopped.
+    out:
+      type: string
+      description: Where the work goes (pieces, the reference videos and footage measurements). Default ~/.summer/content.
+    music:
+      type: string
+      description: 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:
+      type: string
+      description: The game's caption font file (.ttf or .otf).
+    referenceFile:
+      type: string
+      description: The reference video, when it cannot be fetched (yt-dlp).
+    repo:
+      type: string
+      description: The game's repo, for what changed today. Default the working directory.
+    stage:
+      type: string
+      enum:
+        - plan
+        - all
+      description: plan stops after the plan, to change shots in plan.json first.
+    upload:
+      type: boolean
+      description: false renders and checks only; nothing is uploaded.
+    replan:
+      type: boolean
+      description: Throw away the plan and map the shots again.
+    status:
+      type: string
+      enum:
+        - draft
+        - in_review
+      description: Override where it lands - in_review even with failed checks, or draft.
+  additionalProperties: false
+authority:
+  filesystem: true
+  editor_mutation: false
+  network: true
+  credentials: false
+  publish: false
+evidence_checks:
+  - none

package/library/tools/frame-shot/GUIDE.md

@@ -1,6 +1,6 @@
 # summer_frame_shot
 
-Smart framing: find good camera poses for a shot type automatically, measured in-engine against the real geometry.
+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/library/tools/go-live/resource.yaml

@@ -0,0 +1,67 @@
+id: tool/go-live
+kind: tool
+version: 1.0.0
+summary: "Take a store game live: release its checked Build, publish its page, watch until players get it or name the failing check and fix. Confirm-gated."
+use_when:
+  - '"make my game live"'
+  - '"publish my game to players now"'
+  - '"is my game live yet"'
+  - '"release the build I uploaded"'
+  - after summer_publish_build reports every automated check passed
+  - watching a game until players get it, or finding which automated check failed
+do_not_use_when:
+  - the user has not approved taking this exact store page and Build live
+  - the game is not uploaded yet - summer_export_game, then summer_publish_build
+  - store page text, art or price - store.update_listing, store.set_art, pricing.set_base
+  - the release checklist before going live - skill/release-checklist
+facets:
+  lifecycle:
+    - launch
+  domains:
+    - creator
+    - deployment
+compatibility:
+  engine: ">=4.6"
+related:
+  skills:
+    - skill/release-checklist
+    - skill/publish-your-game
+source: official
+license: MIT
+status: preview
+aliases:
+  - summer_go_live
+implementation:
+  module: src/core/capabilities/go-live.ts
+  export: goLive
+surfaces:
+  mcp:
+    tool_name: summer_go_live
+    remote: true
+input_schema:
+  type: object
+  properties:
+    gameId:
+      type: string
+      description: The store game id (from games.list). Without it the call fails with game_required and lists your store games.
+    publicationId:
+      type: string
+      description: "The bundle Build to release: publicationId from summer_publish_build. Default: the newest uploaded export."
+    confirm:
+      type: boolean
+      default: false
+      description: Set true only after the user approves taking this exact page and Build live.
+    waitSeconds:
+      type: integer
+      minimum: 0
+      maximum: 1800
+      description: How long to watch before answering (default 600). On waiting, call again to keep watching.
+  additionalProperties: false
+authority:
+  filesystem: false
+  editor_mutation: false
+  network: true
+  credentials: false
+  publish: true
+evidence_checks:
+  - none

package/library/tools/import-from-url/GUIDE.md

@@ -6,5 +6,6 @@ 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.

package/library/tools/import-from-url-batch/GUIDE.md

@@ -1,3 +1,3 @@
 # 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.
+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.

package/library/tools/play/GUIDE.md

@@ -2,6 +2,8 @@
 
 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/library/tools/projects-create-local/resource.yaml

@@ -0,0 +1,55 @@
+id: tool/projects-create-local
+kind: tool
+version: 1.0.0
+summary: 'Create a project on this computer. Writes a template (3d-basic by default) to a folder, no shell needed. Returns projectPath. Next: projects.open_local.'
+use_when:
+  - '"make me a game"'
+  - '"start a new Summer project"'
+  - '"create a 3d project on my computer"'
+  - no editor is open and this session has no project (engine_not_running says so)
+  - an agent with no shell (Claude Desktop, a chat app) starts a game
+do_not_use_when:
+  - a plan of concept art on Summer's server - projects.create
+  - the folder already holds the project - projects.open_local opens it
+  - an agent with a shell - npx -y summer-engine@latest dev installs, creates and opens in one step
+facets:
+  lifecycle:
+    - build
+  domains:
+    - project
+    - editor
+compatibility:
+  engine: ">=4.6"
+source: official
+license: MIT
+status: stable
+aliases:
+  - summer_projects_create_local
+implementation:
+  module: src/core/capabilities/projects-local.ts
+  export: createLocalProject
+surfaces:
+  mcp:
+    tool_name: summer_projects_create_local
+    remote: false
+input_schema:
+  type: object
+  properties:
+    template:
+      type: string
+      description: Template slug (docs.search finds them) - 3d-basic (default), empty, 3d-third-person-controller, 2d-platformer, ...
+    name:
+      type: string
+      description: The project's name and folder name. Default my-game (or the template's name).
+    dir:
+      type: string
+      description: 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.
+  additionalProperties: false
+authority:
+  filesystem: true
+  editor_mutation: false
+  network: true
+  credentials: false
+  publish: false
+evidence_checks:
+  - none

package/library/tools/projects-open-local/resource.yaml

@@ -0,0 +1,51 @@
+id: tool/projects-open-local
+kind: tool
+version: 1.0.0
+summary: 'Open a project in Summer Engine. Waits until it connects; installs the engine only with install: true (the person''s yes). Next: engine.get_project_context.'
+use_when:
+  - '"open my game in Summer"'
+  - '"open the editor"'
+  - engine_not_running and the session has a project, or after projects.create_local
+  - an agent with no shell (Claude Desktop, a chat app) needs the editor
+do_not_use_when:
+  - the person has not said yes to installing Summer Engine (about 660 MB) - call it without install; it says when the engine is missing
+  - another project is open in Summer Engine - it names it; switch the editor first
+  - download links for the person to install by hand - projects.open_in_engine
+facets:
+  lifecycle:
+    - build
+  domains:
+    - project
+    - editor
+compatibility:
+  engine: ">=4.6"
+source: official
+license: MIT
+status: stable
+aliases:
+  - summer_projects_open_local
+implementation:
+  module: src/core/capabilities/projects-local.ts
+  export: openLocalProject
+surfaces:
+  mcp:
+    tool_name: summer_projects_open_local
+    remote: false
+input_schema:
+  type: object
+  properties:
+    path:
+      type: string
+      description: The project folder (holds project.godot), e.g. projectPath from summer_projects_create_local. Default this session's project.
+    install:
+      type: boolean
+      description: Install Summer Engine first when it is missing. Set true only after the person said yes.
+  additionalProperties: false
+authority:
+  filesystem: true
+  editor_mutation: false
+  network: true
+  credentials: false
+  publish: false
+evidence_checks:
+  - none

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

@@ -1,7 +1,7 @@
 id: tool/publish-build
 kind: tool
 version: 1.0.1
-summary: Upload an export from summer_export_game to the creator's store game, confirm-gated - a store bundle as a Build, or a web or native download as a store version.
+summary: "Upload an export to the creator's store game, confirm-gated: a bundle as a Build with its per-platform checks, or a web or native download."
 use_when:
   - '"upload my game to summer.games"'
   - '"publish this build to my store page"'
@@ -14,7 +14,7 @@ do_not_use_when:
   - the user has not approved the exact game, file, digest, version and publish choice
   - the game is not exported yet — summer_export_game first
   - store page text, art or price — store.update_listing, store.set_art (hosted, after summer login --store)
-  - making the build live — store.publish (the owner approves publishing), then store.release
+  - making the build live — summer_go_live
   - what players get now — store.status
 facets:
   lifecycle:
@@ -51,7 +51,7 @@ input_schema:
     publish:
       type: boolean
       default: false
-      description: "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."
+      description: "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:
       type: string
       enum:

package/library/tools/screenshot/GUIDE.md

@@ -2,7 +2,7 @@
 
 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/library/tools/store-set-details/resource.yaml

@@ -0,0 +1,114 @@
+id: tool/store-set-details
+kind: tool
+version: 1.0.0
+summary: "Fill store page sections update_listing lacks: genres, features, credits, languages, requirements, content survey, AI disclosure. Never publishes."
+use_when:
+  - '"fill in the age rating questionnaire"'
+  - '"add the AI disclosure to my store page"'
+  - '"set my game''s genres and features"'
+  - '"list the languages my game supports"'
+  - '"add system requirements to the store page"'
+  - store.get_listing shows contentSurvey, aiDisclosure, genres or credits empty
+do_not_use_when:
+  - title, tagline, descriptions, tags, platforms, content rating, release stage or support link - store.update_listing
+  - store art, trailer or sound - store.set_art, store.set_trailer, store.set_sound
+  - taking the page live - summer_go_live
+facets:
+  lifecycle:
+    - launch
+  domains:
+    - creator
+    - deployment
+compatibility:
+  engine: ">=4.6"
+related:
+  skills:
+    - skill/release-checklist
+    - skill/store-listing
+source: official
+license: MIT
+status: preview
+aliases:
+  - summer_store_set_details
+implementation:
+  module: src/core/capabilities/store-details.ts
+  export: setStoreDetails
+surfaces:
+  mcp:
+    tool_name: summer_store_set_details
+    remote: true
+input_schema:
+  type: object
+  properties:
+    gameId:
+      type: string
+      description: The store game id (from games.list).
+    genres:
+      type: array
+      items:
+        type: string
+      description: Genre tag ids (category genre in store.get_listing tags), 1 to 5, in the creator's order; null clears them.
+    features:
+      type: array
+      items:
+        type: string
+        enum: [single_player, online_multiplayer, local_multiplayer, online_coop, local_coop, cross_platform, controller_full, controller_partial, cloud_saves, plays_in_browser, level_editor, achievements, in_game_purchases]
+      description: What the game offers, from the store's closed list; null clears them.
+    credits:
+      type: object
+      properties:
+        developer: {type: string}
+        publisher: {type: string}
+        franchise: {type: string}
+      required: [developer]
+      description: Who made and published it, each 1 to 120 characters; omit publisher or franchise when there is none.
+    languageSupport:
+      type: array
+      items:
+        type: object
+        properties:
+          code: {type: string}
+          interface: {type: boolean}
+          fullAudio: {type: boolean}
+          subtitles: {type: boolean}
+        required: [code, interface, fullAudio, subtitles]
+      description: One entry per language (BCP 47 code such as en, pt-br, zh-hans), up to 30, each with at least one kind of support.
+    systemRequirements:
+      type: object
+      description: "Desktop hardware: { windows | macos | linux: { minimum: { os, processor, memory, graphics, storage, network, notes }, recommended? } }."
+    contentSurvey:
+      type: object
+      properties:
+        violence: {type: string, enum: [none, fantasy, realistic]}
+        bloodGore: {type: string, enum: [none, mild, intense]}
+        sexualContent: {type: string, enum: [none, suggestive, explicit]}
+        nudity: {type: string, enum: [none, partial, full]}
+        language: {type: string, enum: [none, mild, strong]}
+        substances: {type: string, enum: [none, referenced, used]}
+        gambling: {type: string, enum: [none, simulated, realMoney]}
+        userGeneratedContent: {type: boolean}
+        onlineInteraction: {type: boolean}
+        inGamePurchases: {type: boolean}
+        notes: {type: string}
+      required: [violence, bloodGore, sexualContent, nudity, language, substances, gambling, userGeneratedContent, onlineInteraction, inGamePurchases]
+      description: The mature-content questionnaire; every answer is required and none is an answer.
+    aiDisclosure:
+      type: object
+      properties:
+        uses:
+          type: array
+          items:
+            type: string
+            enum: [assets, code, generatedGameplay]
+        description: {type: string}
+      required: [uses]
+      description: How AI was used to make the game; uses [] means no AI. generatedGameplay needs a description of what is generated and its guardrails.
+  additionalProperties: false
+authority:
+  filesystem: false
+  editor_mutation: false
+  network: true
+  credentials: false
+  publish: false
+evidence_checks:
+  - none

package/library/tools/sync-items/resource.yaml

@@ -0,0 +1,72 @@
+id: tool/sync-items
+kind: tool
+version: 1.0.0
+summary: Sync summer.items.json to the store game by item slug - a plan, then the owner's approval in Studio. Needs the store sign-in (summer login --store).
+use_when:
+  - '"add these items to my game"'
+  - '"sync my items to staging"'
+  - '"put the same items in production"'
+  - '"change the price of emote_ponder"'
+  - creating or revising store items from summer.items.json, matched by slug
+  - making the staging game and the production game carry the same items
+do_not_use_when:
+  - the user has not approved the exact plan for this gateway and game
+  - more than 50 items change at once - one approval takes 50; confirm each listed batch with slugs
+  - the store sign-in is for the other environment - after changing SUMMER_GATEWAY_URL and SUMMER_MCP_RESOURCE_URL, run summer login --store --force first
+  - releasing or activating an item for players - after Summer approves it, the owner activates each item in Studio (Review activation); players can buy it only while the game is live
+  - Passport collectibles (stamps, pins, badges) - a Passport item with the same slug is blocked, never synced
+  - retiring or deleting an item - items the file does not name are listed, never changed
+  - the game's own price or store page - store.update_listing, pricing.set_base
+facets:
+  lifecycle:
+    - launch
+  domains:
+    - creator
+    - deployment
+compatibility:
+  engine: ">=4.6"
+related:
+  skills:
+    - skill/summer-store
+source: official
+license: MIT
+status: preview
+aliases:
+  - summer_sync_items
+implementation:
+  module: src/core/capabilities/sync-items.ts
+  export: syncItems
+surfaces:
+  mcp:
+    tool_name: summer_sync_items
+    remote: true
+input_schema:
+  type: object
+  properties:
+    gameId:
+      type: string
+      description: 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. Switching between staging and production takes SUMMER_GATEWAY_URL and SUMMER_MCP_RESOURCE_URL, then "summer login --store --force" (one store sign-in per machine).
+    project:
+      type: string
+      description: Project folder with project.godot and summer.items.json. Defaults to the MCP's bound project, then the working directory.
+    file:
+      type: string
+      description: The items file, relative to the project. Default summer.items.json.
+    slugs:
+      type: array
+      items:
+        type: string
+      description: 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:
+      type: boolean
+      default: false
+      description: Set true only after the user approves the plan.
+  additionalProperties: false
+authority:
+  filesystem: true
+  editor_mutation: false
+  network: true
+  credentials: false
+  publish: true
+evidence_checks:
+  - none

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "summer-engine",
-  "version": "4.3.0",
+  "version": "4.5.0",
   "description": "MCP server, CLI and skills for Summer Engine, the game engine built for AI. Connect Claude Code, Cursor, Codex and other agents to build, test and publish full games to summer.games.",
   "mcpName": "io.github.SummerEngine/summer",
   "keywords": [

package/registry/generated/aliases.json

@@ -122,6 +122,7 @@
     "summer_clear_console": "tool/clear-console",
     "summer_connect_ports": "tool/connect-ports",
     "summer_connect_signal": "tool/connect-signal",
+    "summer_content_make": "tool/content-make",
     "summer_create_debug_report": "tool/create-debug-report",
     "summer_create_scene": "tool/create-scene",
     "summer_debug_views": "tool/debug-views",
@@ -154,6 +155,7 @@
     "summer_get_scene_tree": "tool/get-scene-tree",
     "summer_get_script_errors": "tool/get-script-errors",
     "summer_get_studio_workflow": "tool/get-studio-workflow",
+    "summer_go_live": "tool/go-live",
     "summer_grep": "tool/grep",
     "summer_import_asset": "tool/import-asset",
     "summer_import_asset_by_id": "tool/import-asset-by-id",
@@ -177,6 +179,8 @@
     "summer_place_adjacent": "tool/place-adjacent",
     "summer_play": "tool/play",
     "summer_project_setting": "tool/project-setting",
+    "summer_projects_create_local": "tool/projects-create-local",
+    "summer_projects_open_local": "tool/projects-open-local",
     "summer_publish_build": "tool/publish-build",
     "summer_raycast": "tool/raycast",
     "summer_read_file": "tool/read-file",
@@ -207,6 +211,8 @@
     "summer_starcast": "tool/starcast",
     "summer_start_game_task": "tool/start-game-task",
     "summer_stop": "tool/stop",
+    "summer_store_set_details": "tool/store-set-details",
+    "summer_sync_items": "tool/sync-items",
     "summer_test_placement": "tool/test-placement",
     "summer_ui_actions": "tool/ui-actions",
     "summer_ui_activate": "tool/ui-activate",

package/registry/generated/counts.json

@@ -4,9 +4,9 @@
     "collection": 0,
     "example": 0,
     "reference": 9,
-    "skill": 128,
+    "skill": 132,
     "template": 19,
-    "tool": 119
+    "tool": 125
   },
-  "total": 275
+  "total": 285
 }

package/registry/generated/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.5.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/",