summer-engine 4.0.0 → 4.2.0

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

@@ -0,0 +1,226 @@
+import { existsSync, lstatSync, readFileSync, readlinkSync, realpathSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { basename, dirname, join, parse, relative, resolve, isAbsolute } from "path";
+import { PACKAGE_ROOT } from "../core/package-root.js";
+/**
+ * AGENTS.md and CLAUDE.md in a Summer project. AGENTS.md is the one file
+ * Codex, Cursor, Copilot, Amp and other agents read in every session;
+ * Claude Code reads CLAUDE.md, which here only imports AGENTS.md.
+ * `summer create` writes both; `summer setup --yes` inside a project adds
+ * them when missing.
+ *
+ * An existing file is never overwritten: Summer adds one marked block once,
+ * and later runs replace only that block. A link is followed only to a file
+ * inside the project, and a CLAUDE.md that is the same file as AGENTS.md
+ * gets the AGENTS.md block only. The five commands are the list in the
+ * summer-cli skill (between its project-commands markers), so the two
+ * cannot drift; the skill's test runs every command both of them teach.
+ */
+export const SUMMER_BLOCK_START = "<!-- summer-engine:start. summer setup updates only this block; write your own notes outside it. -->";
+export const SUMMER_BLOCK_END = "<!-- summer-engine:end -->";
+const CLAUDE_IMPORTS = new Set(["@AGENTS.md", "@./AGENTS.md"]);
+const SKILL_PATH = ["library", "skills", "summer-cli", "SKILL.md"];
+const COMMANDS = /<!-- project-commands[^>]*-->\n([\s\S]*?)\n<!-- \/project-commands -->/;
+/** The numbered command list from the summer-cli skill. */
+export function projectCommands(skill = readFileSync(join(PACKAGE_ROOT, ...SKILL_PATH), "utf-8")) {
+    const match = COMMANDS.exec(skill);
+    if (!match)
+        throw new Error("The summer-cli skill has no project-commands list.");
+    return match[1].trim();
+}
+/** The Summer block of AGENTS.md, markers included. */
+export function renderAgentsBlock(commands = projectCommands()) {
+    return [
+        SUMMER_BLOCK_START,
+        "# Summer Engine game",
+        "",
+        "This is a game made with Summer Engine, the game engine built for AI. Game code is GDScript (`.gd`), scenes are `.tscn`, resources are `.tres`, and `project.godot` is the project file.",
+        "",
+        "## How to work on it",
+        "",
+        "- Change scenes through Summer while Summer Engine has the project open. The editor rewrites `.tscn` files when it saves, so hand edits get lost.",
+        "- With Summer's MCP server, call the `summer_*` tools and start with `summer_get_project_context`. Without it, run the same operations as `summer` commands in the shell (the `summer-cli` skill). If `summer` is missing or older than 4.0, use `npx -y summer-engine@latest` in its place.",
+        "- Summer's skills teach each part of a game. `npx -y summer-engine@latest setup <agent> --yes` installs them for your agent (add `--cli` for no MCP server). Start with `using-summer`, and find the right one with `summer docs search --query \"<the task>\"`.",
+        "- `.summer/` is the project's memory: `GameSoul.md` says what the game is, `memory/` holds the decisions to keep. Read them before you change the game's look, sound or story.",
+        "- Check your own work: script errors, a screenshot, a play run. Ask the person to play only for feel and fun.",
+        "",
+        "## The five commands",
+        "",
+        commands,
+        "",
+        "## Publishing",
+        "",
+        "The `publish-your-game` skill has the steps; `summer ops search \"publish my game\"` finds each operation. `summer store publish` sends the game to Summer's store review, and the game's owner approves it: give them the link it prints. Nothing goes live until they approve.",
+        SUMMER_BLOCK_END,
+    ].join("\n");
+}
+/** The text with `block` as its Summer block: replaced where it is, else appended. Keeps the file's line endings. */
+function withBlock(text, block) {
+    const eol = text.includes("\r\n") ? "\r\n" : "\n";
+    const ours = block.replace(/\r?\n/g, eol);
+    const start = text.indexOf(SUMMER_BLOCK_START);
+    if (start === -1) {
+        // Only trailing line breaks change outside the block; an empty file is the block alone.
+        return { text: text.trim() ? `${text.replace(/(\r?\n)*$/, eol)}${eol}${ours}${eol}` : `${ours}${eol}`, action: "added" };
+    }
+    const end = text.indexOf(SUMMER_BLOCK_END, start);
+    if (end === -1)
+        return { text, action: "skipped", reason: "its Summer block has no end marker" };
+    // Two blocks (a merge, or the markers quoted in the person's text): which
+    // one is Summer's is not knowable, so the person picks; nothing is deleted.
+    if (text.indexOf(SUMMER_BLOCK_START, end) !== -1)
+        return { text, action: "skipped", reason: "it has two Summer blocks; delete one and run setup again" };
+    const next = `${text.slice(0, start)}${ours}${text.slice(end + SUMMER_BLOCK_END.length)}`;
+    return { text: next, action: next === text ? "unchanged" : "updated" };
+}
+/** Does the text import AGENTS.md on a line of its own, outside code fences? */
+function importsAgents(text) {
+    let fence = false;
+    for (const line of text.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (/^(```|~~~)/.test(trimmed))
+            fence = !fence;
+        else if (!fence && CLAUDE_IMPORTS.has(trimmed))
+            return true;
+    }
+    return false;
+}
+function inside(root, path) {
+    const rel = relative(root, path);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+/**
+ * Where a file may be written, and `real`, the file a write lands in:
+ * "missing" (create it: here, or the missing target of a link inside the
+ * project), "file" (a file, or a link to one inside the project), or a
+ * reason to leave it alone (a link that points nowhere or out of the
+ * project). `real` is known before anything is written, so a link from one
+ * name to the other counts as one file even when its target is missing.
+ */
+function locate(path, realRoot) {
+    let isLink = false;
+    try {
+        isLink = lstatSync(path).isSymbolicLink();
+    }
+    catch {
+        return { kind: "missing", real: join(realRoot, basename(path)) };
+    }
+    let real;
+    try {
+        real = realpathSync(path);
+    }
+    catch {
+        const target = resolve(realRoot, readlinkSync(path));
+        return inside(realRoot, target) ? { kind: "missing", real: target } : { kind: "skip", reason: "it is a link to a file that does not exist" };
+    }
+    if (isLink && !inside(realRoot, real))
+        return { kind: "skip", reason: "it is a link to a file outside the project" };
+    return { kind: "file", real };
+}
+/**
+ * Write or update AGENTS.md and CLAUDE.md in the project root. A new
+ * AGENTS.md is the Summer block; a new CLAUDE.md is `@AGENTS.md` only. An
+ * existing CLAUDE.md that already imports AGENTS.md is left as it is. Each
+ * file is its own step: a file that cannot be read or written is skipped
+ * with the reason, and the other is still done.
+ */
+export function writeAgentInstructions(projectDir, options = {}) {
+    const agents = join(projectDir, "AGENTS.md");
+    const claude = join(projectDir, "CLAUDE.md");
+    let block;
+    let realRoot;
+    try {
+        block = options.block ?? renderAgentsBlock();
+        realRoot = realpathSync(projectDir);
+    }
+    catch (error) {
+        const reason = messageOf(error);
+        return [
+            { file: "AGENTS.md", path: agents, action: "skipped", reason },
+            { file: "CLAUDE.md", path: claude, action: "skipped", reason },
+        ];
+    }
+    const write = (path, text) => {
+        if (!options.dryRun)
+            writeFileSync(path, text, "utf-8");
+    };
+    const step = (file, path, run) => {
+        try {
+            return { file, path, ...run() };
+        }
+        catch (error) {
+            return { file, path, action: "skipped", reason: messageOf(error) };
+        }
+    };
+    const agentsAt = locate(agents, realRoot);
+    const agentsResult = step("AGENTS.md", agents, () => {
+        if (agentsAt.kind === "skip")
+            return { action: "skipped", reason: agentsAt.reason };
+        if (agentsAt.kind === "missing") {
+            write(agents, `${block}\n`);
+            return { action: "created" };
+        }
+        const next = withBlock(readFileSync(agents, "utf-8"), block);
+        if (next.action === "added" || next.action === "updated")
+            write(agents, next.text);
+        return { action: next.action, ...(next.reason ? { reason: next.reason } : {}) };
+    });
+    const claudeAt = locate(claude, realRoot);
+    const claudeResult = step("CLAUDE.md", claude, () => {
+        if (claudeAt.kind === "skip")
+            return { action: "skipped", reason: claudeAt.reason };
+        // CLAUDE.md -> AGENTS.md (or the reverse): one file, which already has the AGENTS.md block.
+        if (agentsAt.kind !== "skip" && claudeAt.real === agentsAt.real) {
+            return { action: "unchanged", reason: "it is the same file as AGENTS.md" };
+        }
+        if (claudeAt.kind === "missing") {
+            write(claude, "@AGENTS.md\n");
+            return { action: "created" };
+        }
+        const text = readFileSync(claude, "utf-8");
+        if (importsAgents(text) && !text.includes(SUMMER_BLOCK_START))
+            return { action: "unchanged" };
+        const next = withBlock(text, `${SUMMER_BLOCK_START}\n@AGENTS.md\n${SUMMER_BLOCK_END}`);
+        if (next.action === "added" || next.action === "updated")
+            write(claude, next.text);
+        return { action: next.action, ...(next.reason ? { reason: next.reason } : {}) };
+    });
+    return [agentsResult, claudeResult];
+}
+/**
+ * The Summer project the working directory is in, for `summer setup`: the
+ * nearest folder with project.godot, looking up no further than the git
+ * top level, and never the home folder or the filesystem root (a stray
+ * project.godot there must not put an AGENTS.md or CLAUDE.md in every
+ * session). Null when there is none.
+ */
+export function findSetupProjectRoot(cwd = process.cwd()) {
+    let current;
+    try {
+        current = realpathSync(resolve(cwd));
+    }
+    catch {
+        return null;
+    }
+    let home;
+    try {
+        home = realpathSync(homedir());
+    }
+    catch {
+        home = homedir();
+    }
+    while (current !== home && current !== parse(current).root) {
+        if (existsSync(join(current, "project.godot")))
+            return current;
+        if (existsSync(join(current, ".git")))
+            return null;
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+    return null;
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/gemini-extension.json

@@ -1,8 +1,8 @@
 {
   "_generated": "GENERATED from integrations/gemini — do not edit; npm run generate:registry",
   "name": "summer",
-  "version": "4.0.0",
-  "description": "Agent tooling for Summer Engine: MCP bridge, context primer, and game-dev skills. Use with the npm CLI for skill files on disk.",
+  "version": "4.2.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": {
     "summer-engine": {
@@ -108,6 +108,7 @@
     "./library/skills/summer-apps/",
     "./library/skills/summer-apps-design/",
     "./library/skills/summer-assets/",
+    "./library/skills/summer-cli/",
     "./library/skills/summer-friends/",
     "./library/skills/summer-leaderboards/",
     "./library/skills/summer-match-results/",

package/integrations/README.md

@@ -58,7 +58,7 @@ are listed where they differ.
 | claude-desktop | — | MCP: `~/Library/Application Support/Claude/claude_desktop_config.json`; Linux `~/.config/Claude/claude_desktop_config.json`; Windows `%APPDATA%/Claude/claude_desktop_config.json`; no skills folder (MCP only) |
 | codex | `.codex-plugin/plugin.json` | MCP: `~/.codex/config.toml`; project `.codex/config.toml`; skills: `~/.agents/skills`; project `.agents/skills` (`<skill>/SKILL.md`) |
 | cursor | `.cursor-plugin/plugin.json` | MCP: `~/.cursor/mcp.json`; project `.cursor/mcp.json`; skills: `~/.agents/skills`; project `.agents/skills` (`<skill>/SKILL.md`) |
-| windsurf | — | MCP: `~/.codeium/windsurf/mcp_config.json`; skills: `~/.agents/skills`; project `.agents/skills` (`<skill>/SKILL.md`) |
+| windsurf | — | MCP: `~/.config/devin/mcp_config.json`; Windows `%APPDATA%/devin/mcp_config.json`; skills: `~/.agents/skills`; project `.agents/skills` (`<skill>/SKILL.md`) |
 | antigravity | — | MCP: `~/.gemini/config/mcp_config.json`; project `.agents/mcp_config.json`; skills: `~/.gemini/config/skills`; project `.agents/skills` (`<skill>/SKILL.md`) |
 | gemini (legacy) | `gemini-extension.json` | MCP: `~/.gemini/extensions/summer-engine/gemini-extension.json`; skills: `~/.gemini/extensions/summer-engine/skills` (`<skill>/SKILL.md`) |
 | cline | — | MCP: `~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`; Linux `~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`; Windows `%APPDATA%/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`; skills: `~/.cline/skills`; project `.cline/skills` (`<skill>/SKILL.md`) |

package/integrations/claude/README.md

@@ -8,6 +8,12 @@ Generated by `scripts/generate-registry` from `library/**/resource.yaml`:
 - `registry/generated/marketplace.claude.json` -> `.claude-plugin/marketplace.json`
   (marketplace listing wrapper).
 
+- `registry/generated/plugin.claude-directory.json` -> `plugins/claude/.claude-plugin/plugin.json`,
+  plus the rest of `plugins/claude/` (`scripts/generate-registry/mirrors.ts`): the same
+  plugin for Anthropic's plugin directory, from a folder of its own (under 512 files,
+  no symlinks), with the server and every `summer-engine@latest` pinned to this
+  version. Submit `plugins/claude` as the plugin path.
+
 The MCP pointer `./.mcp.json` these manifests reference is generated as
 well (`registry/generated/mcp.json -> .mcp.json`, owned by the claude target).
 

package/integrations/claude/manifest-target.json

@@ -11,6 +11,10 @@
     {
       "generated": "mcp.json",
       "destination": ".mcp.json"
+    },
+    {
+      "generated": "plugin.claude-directory.json",
+      "destination": "plugins/claude/.claude-plugin/plugin.json"
     }
   ]
 }

package/integrations/gemini/README.md

@@ -21,6 +21,17 @@ Generated by `scripts/generate-registry` from `library/**/resource.yaml`:
   `skills install --all --agent gemini`); Gemini extensions are user-scoped, so
   `--scope project` falls back to user with a warning.
 
+`gemini extensions install https://github.com/SummerEngine/summer` (and the
+Gemini CLI gallery) installs a GitHub Release's only asset when it has one.
+`.github/workflows/gemini-extension.yml` attaches `summer-gemini-extension.tar.gz`
+to every release (`scripts/build-gemini-extension.ts`): the manifest without `settings` (no hooks ship) and without
+`skills`, `GEMINI.md`, `AGENTS.md` and `skills/<slug>/` for every bundled skill.
+Keep it the release's only asset, or Gemini falls back to the source tarball,
+which has no `skills/` folder: the workflow leaves a release that already has it
+alone and stops with an error on one that has other assets. Every packaged file
+comes from the tag itself (only the script comes from the workflow's commit), so
+dispatching it for an older tag packages that release as it was.
+
 Never edit the destination file by hand — edit `library/` resources or
 `scripts/generate-registry/manifests.ts`, then run
 `npm run generate:registry`. CI `--check` fails on any drift.

package/integrations/windsurf/README.md

@@ -4,7 +4,7 @@ No manifest file is generated in this repo for Devin Desktop — `manifest-targe
 is intentionally empty. Support is delivered at install time by
 `summer setup windsurf` (aliases: `devin`, `devin-desktop`, `devindesktop`), which writes:
 
-- MCP config: `~/.codeium/windsurf/mcp_config.json`; Windows `%USERPROFILE%/.codeium/windsurf/mcp_config.json` (user); user scope only (project requests fall back with a warning).
+- MCP config: `~/.config/devin/mcp_config.json` (`$XDG_CONFIG_HOME/devin` when set); Windows `%APPDATA%\devin\mcp_config.json` (user); user scope only (project requests fall back with a warning). Summer 4.1.0 and earlier wrote `~/.codeium/windsurf/mcp_config.json`; setup says when an entry is still there.
   Shape: `mcpServers.summer-engine = { command, args }`.
 - Skills: `~/.agents/skills` (user) or `.agents/skills` (project) as `<skill>/SKILL.md`.
 - After: Restart Devin Desktop and refresh MCP servers from the agent settings. Devin's docs say mcp_config.json configures the Cascade agent; for the Devin agent add the server in the app's MCP settings with the same command.

package/library/skills/3d-lighting/SKILL.md

@@ -180,3 +180,19 @@ Then create `Environment` and `Sky` resources via the inspector or load from `.t
 ## Collaborative protocol
 
 This skill mutates the scene (adds lights + WorldEnvironment + tunes Environment sub-properties). Always ask before applying: "May I add a DirectionalLight3D Sun with shadows + a WorldEnvironment with a procedural sky?".
+
+<!-- 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_add_node` | `summer engine add-node` |
+| `summer_get_project_context` | `summer engine get-project-context` |
+| `summer_run_script` | `summer engine run-script` |
+| `summer_save_scene` | `summer engine save-scene` |
+| `summer_screenshot` | `summer engine screenshot` |
+| `summer_set_prop` | `summer engine set-prop` |
+| `summer_set_resource_property` | `summer engine set-resource-property` |
+<!-- /shell-commands -->

package/library/skills/README.md

@@ -1,6 +1,6 @@
 # Summer skills
 
-> 127 skills, grouped by their primary domain. **Generated** by `npm run generate:registry` from each skill's `resource.yaml`; `--check` fails when this file and the library disagree. Do not edit by hand.
+> 128 skills, grouped by their primary domain. **Generated** by `npm run generate:registry` from each skill's `resource.yaml`; `--check` fails when this file and the library disagree. Do not edit by hand.
 
 The folder is flat on purpose (`docs/design/DECISIONS.md`, D3): a skill usually belongs to several domains, so categories live in each skill's `facets.domains` and this index is rendered from them. The first domain listed is the primary one. `summer skills list --by-domain` prints the same grouping; `summer skills info <slug>` shows one skill.
 
@@ -10,7 +10,7 @@ Status: **stable** unless marked; *preview* = not yet exercised in-engine by the
 
 - [2d](#2d) (10)
 - [3d](#3d) (6)
-- [agent-workflow](#agent-workflow) (18)
+- [agent-workflow](#agent-workflow) (19)
 - [ai](#ai) (2)
 - [animation](#animation) (7)
 - [assets](#assets) (4)
@@ -78,6 +78,7 @@ Status: **stable** unless marked; *preview* = not yet exercised in-engine by the
 | [skill-create](./skill-create/SKILL.md) (library only) | Bootstrap a new Summer library skill (library/skills/<slug>/ with resource.yaml and SKILL.md), frontmatter, and stub sections. | meta |
 | [skill-improve](./skill-improve/SKILL.md) (library only) | Upgrade an underperforming Summer skill — run it against a behavioral spec with and without changes via a parallel-eval harness; ship the winner. | meta |
 | [skill-test](./skill-test/SKILL.md) (library only) | Lint a Summer skill before commit, audit the whole library, or check a behavioral spec assertion — static structural rules plus behavioral specs. | meta |
+| [*summer-cli*](./summer-cli/SKILL.md) ★ (preview) | Summer as shell commands, no MCP: sign in, find and run operations, follow jobs, save files, drive the engine. | assets, tools |
 | [using-summer](./using-summer/SKILL.md) | Session bootstrap: how to find and use Summer skills and the summer-engine MCP before any response. | meta |
 | [verification-before-completion](./verification-before-completion/SKILL.md) ★ | Run verification and read its output before claiming work done, fixed or passing: evidence first. | verification |
 | [writing-plans](./writing-plans/SKILL.md) | Turn a spec or requirements for a multi-step task into a written implementation plan before touching code. | meta |
@@ -109,7 +110,7 @@ Status: **stable** unless marked; *preview* = not yet exercised in-engine by the
 | [asset-strategy](./asset-strategy/SKILL.md) ★ | Route any 'I need a [thing]' asset request to the right skill: 2D, 3D, audio, video, VFX or animation. | pipeline |
 | [*lumera-single-image-scene-reconstruction*](./lumera-single-image-scene-reconstruction/SKILL.md) (preview) (library only) | Lumera-style single image to editable 3D scene — VLM-parsed object boxes and parametric lights, per-object meshes, HDR probe, .tscn assembly, refinement loop. | pipeline, 3d, scenes |
 | [*skintokens-auto-rigging*](./skintokens-auto-rigging/SKILL.md) (preview) (library only) | Offline auto-rigging with skin-tokens.cpp (GGML SkinTokens/TokenRig port) — skeleton and skin weights from a static GLB mesh on CPU/Vulkan, into Summer Engine. | pipeline, 3d, animation |
-| [summer-assets](./summer-assets/SKILL.md) | Make game assets with Summer without Summer Engine: find, generate and download 3D models, images, audio and video for any engine or web app. | agent-workflow |
+| [summer-assets](./summer-assets/SKILL.md) | Make game assets with Summer, no Summer Engine: find, generate and download 3D models, images, audio and video for any engine or app. | agent-workflow |
 
 ## audio
 
@@ -173,7 +174,7 @@ Status: **stable** unless marked; *preview* = not yet exercised in-engine by the
 
 | skill | when to use | also |
 |---|---|---|
-| [*concept-to-level*](./concept-to-level/SKILL.md) (preview) | Take a 3D map from concept art to a polished, shippable level, with the questions to ask the user, owned lanes, render checks and collision kept in step. | 3d, world-building, agent-workflow |
+| [*concept-to-level*](./concept-to-level/SKILL.md) (preview) | Take a 3D map from concept art to a shippable level: questions for the user, owned lanes, render checks, collision kept in step. | 3d, world-building, agent-workflow |
 | [design-level](./design-level/SKILL.md) ★ | Design one level (layout, pacing, encounters, secrets) as a design doc plus a node-tree skeleton. | game-design |
 | [scene-to-level](./scene-to-level/SKILL.md) | Turn a reference image or concept art into a playable scene: concept, asset pack, terrain, assembly. | game-design |
 

package/library/skills/adaptive-music/SKILL.md

@@ -324,3 +324,24 @@ in Summer Engine.
 - `voice-line` — the voice bus that triggers ducking
 - `summer_docs_read` id `reference/godot-version` — Summer compatibility for AudioServer
   and Tween APIs
+
+<!-- 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_assets_generate_audio` | `summer assets generate-audio` |
+| `summer_assets_search` | `summer assets search` |
+| `summer_docs_read` | `summer docs read` |
+| `summer_add_node` | `summer engine add-node` |
+| `summer_connect_signal` | `summer engine connect-signal` |
+| `summer_get_scene_tree` | `summer engine get-scene-tree` |
+| `summer_import_from_url` | `summer engine import-from-url` |
+| `summer_inspect_node` | `summer engine inspect-node` |
+| `summer_play` | `summer engine play` |
+| `summer_project_setting` | `summer engine project-setting` |
+| `summer_run_script` | `summer engine run-script` |
+| `summer_set_prop` | `summer engine set-prop` |
+<!-- /shell-commands -->

package/library/skills/agent-playtesting/SKILL.md

@@ -146,3 +146,25 @@ Read `determinism.seed_scope` on the play result and believe it. Pinned: the glo
 - `verification-before-completion` — the code layer that must be green before any of this.
 - `debugging-game-feel` — when the feature works but feels wrong.
 - `investigating-bugs` — root-causing a reproducible bug once a recording reproduces it.
+
+<!-- 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_game_control` | `summer engine game-control` |
+| `summer_game_input` | `summer engine game-input` |
+| `summer_game_probe` | `summer engine game-probe` |
+| `summer_get_console` | `summer engine get-console` |
+| `summer_get_debugger_errors` | `summer engine get-debugger-errors` |
+| `summer_input_map_bind` | `summer engine input-map-bind` |
+| `summer_is_running` | `summer engine is-running` |
+| `summer_play` | `summer engine play` |
+| `summer_runtime_animate` | `summer engine runtime-animate` |
+| `summer_runtime_call` | `summer engine runtime-call` |
+| `summer_runtime_set` | `summer engine runtime-set` |
+| `summer_runtime_spawn` | `summer engine runtime-spawn` |
+| `summer_stop` | `summer engine stop` |
+<!-- /shell-commands -->

package/library/skills/ai-characters-in-games/SKILL.md

@@ -218,3 +218,18 @@ func _gateway() -> Object:
 - Retrying on `limit_exceeded` or `credits_exhausted`. The limit is the product working.
 - Putting a provider key in the project "until Summer is live". There is no bring-your-own-key path; keys in builds leak.
 - Letting the model decide rewards because "it only suggests". It will be talked into suggesting everything.
+
+<!-- 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_add_node` | `summer engine add-node` |
+| `summer_connect_signal` | `summer engine connect-signal` |
+| `summer_get_scene_tree` | `summer engine get-scene-tree` |
+| `summer_get_script_errors` | `summer engine get-script-errors` |
+| `summer_save_scene` | `summer engine save-scene` |
+| `summer_set_prop` | `summer engine set-prop` |
+<!-- /shell-commands -->

package/library/skills/ambient-bed/SKILL.md

@@ -291,3 +291,19 @@ Print the SFX prompt and the import dock settings. User runs via the Summer dash
 - `sound-effect` — short event SFX layered over the bed
 - `music-track` — melodic music layered over the bed
 - `adaptive-music` — state-driven crossfades use the same pattern
+
+<!-- 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_audio`, `summer_assets_generate_audio` | `summer assets generate-audio` |
+| `summer_assets_search` | `summer assets search` |
+| `summer_add_node` | `summer engine add-node` |
+| `summer_import_from_url` | `summer engine import-from-url` |
+| `summer_inspect_node` | `summer engine inspect-node` |
+| `summer_run_script` | `summer engine run-script` |
+| `summer_set_prop` | `summer engine set-prop` |
+<!-- /shell-commands -->

package/library/skills/animated-loop/SKILL.md

@@ -231,3 +231,22 @@ Once the loop is wired:
 - `ui-graphics` — logo, menu buttons, HUD that sits over the loop.
 - `concept-art` — produce the reference still that anchors the loop.
 - `summer_docs_read` id `reference/mcp-tools-reference` — how to call `assets.generate_video`; `summer_search` returns its exact input.
+
+<!-- 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_assets_generate_image` | `summer assets generate-image` |
+| `assets.generate_video`, `summer_assets_generate_video` | `summer assets generate-video` |
+| `summer_assets_search` | `summer assets search` |
+| `summer_docs_read` | `summer docs read` |
+| `summer_add_node` | `summer engine add-node` |
+| `summer_import_from_url` | `summer engine import-from-url` |
+| `summer_run_script` | `summer engine run-script` |
+| `summer_set_prop` | `summer engine set-prop` |
+| `jobs.wait`, `summer_jobs_wait` | `summer jobs wait` |
+| `summer_search` | `summer ops search "<what you want>"` |
+<!-- /shell-commands -->

package/library/skills/animation-tree/SKILL.md

@@ -299,3 +299,29 @@ the same `.tres`; it is slower but discoverable.
 - `character-animation-wiring` — the end-to-end rigged-GLB path: inspect real clip/bone names, `ctx.anim_state_machine`, method tracks, root motion, playtest verification.
 - `generate-motion` — produce the clips this tree references.
 - `retarget` — share one tree across many characters.
+
+<!-- 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_add_node` | `summer engine add-node` |
+| `summer_connect_signal` | `summer engine connect-signal` |
+| `summer_get_diagnostics` | `summer engine get-diagnostics` |
+| `summer_get_project_context` | `summer engine get-project-context` |
+| `summer_get_scene_tree` | `summer engine get-scene-tree` |
+| `summer_get_script_errors` | `summer engine get-script-errors` |
+| `summer_inspect_node` | `summer engine inspect-node` |
+| `summer_inspect_resource` | `summer engine inspect-resource` |
+| `summer_instantiate_scene` | `summer engine instantiate-scene` |
+| `summer_play` | `summer engine play` |
+| `summer_remove_node` | `summer engine remove-node` |
+| `summer_replace_node` | `summer engine replace-node` |
+| `summer_run_script` | `summer engine run-script` |
+| `summer_save_scene` | `summer engine save-scene` |
+| `summer_set_prop` | `summer engine set-prop` |
+| `summer_set_resource_property` | `summer engine set-resource-property` |
+| `summer_stop` | `summer engine stop` |
+<!-- /shell-commands -->

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

@@ -277,3 +277,17 @@ No template — this is a workflow that produces the bible the rest of the proje
 - `brainstorm-game` — produces the brief that anchors the bible
 - `audio-direction` — the sonic counterpart
 - `3d-lighting` — implements the lighting plan and the environment's glow, tonemap and SSAO settings
+
+<!-- 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` |
+| `summer_get_project_context` | `summer engine get-project-context` |
+| `summer_inspect_node` | `summer engine inspect-node` |
+| `summer_project_setting` | `summer engine project-setting` |
+| `summer_set_prop` | `summer engine set-prop` |
+<!-- /shell-commands -->

package/library/skills/asset-strategy/SKILL.md

@@ -150,3 +150,33 @@ In a session without Summer Engine tools (the assets profile; the `summer-assets
 ## Fallback (no MCP)
 
 The router still works without MCP — classification is text-only. It hands off to the specialist, which surfaces its own no-MCP fallback (typically: run the same generation in the Summer dashboard, then `summer_import_from_url` once MCP is back).
+
+<!-- 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.choices` | `summer assets choices` |
+| `assets.delete` | `summer assets delete` |
+| `assets.generate_3d` | `summer assets generate-3d` |
+| `assets.generate_audio` | `summer assets generate-audio` |
+| `assets.generate_image` | `summer assets generate-image` |
+| `assets.generate_motion` | `summer assets generate-motion` |
+| `assets.generate_sfx_choices` | `summer assets generate-sfx-choices` |
+| `assets.generate_video` | `summer assets generate-video` |
+| `assets.get`, `summer_assets_get` | `summer assets get` |
+| `assets.remove_background` | `summer assets remove-background` |
+| `assets.search`, `summer_assets_search` | `summer assets search` |
+| `assets.slice_sheet` | `summer assets slice-sheet` |
+| `assets.update` | `summer assets update` |
+| `assets.upload_begin` | `summer assets upload-begin` |
+| `assets.upload_complete` | `summer assets upload-complete` |
+| `summer_import_asset_by_id` | `summer engine import-asset-by-id` |
+| `summer_import_from_url` | `summer engine import-from-url` |
+| `jobs.wait` | `summer jobs wait` |
+| `makers.npc_voice` | `summer makers npc-voice` |
+| `makers.trailer_forge` | `summer makers trailer-forge` |
+| `summer_search` | `summer ops search "<what you want>"` |
+<!-- /shell-commands -->

package/library/skills/audio-direction/SKILL.md

@@ -259,3 +259,19 @@ No template — this is a workflow that produces the bible the rest of the proje
 - `art-direction` — the visual counterpart; audio must rhyme with it
 - `adaptive-music` — implements the dynamic music plan
 - `sound-effect`, `music-track`, `ambient-bed`, `voice-line` — generate the audio the bible describes
+
+<!-- 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_assets_generate_audio` | `summer assets generate-audio` |
+| `summer_docs_read` | `summer docs read` |
+| `summer_add_node` | `summer engine add-node` |
+| `summer_get_project_context` | `summer engine get-project-context` |
+| `summer_get_scene_tree` | `summer engine get-scene-tree` |
+| `summer_inspect_node` | `summer engine inspect-node` |
+| `summer_project_setting` | `summer engine project-setting` |
+<!-- /shell-commands -->

package/library/skills/auto-fire-targeting/SKILL.md

@@ -194,3 +194,17 @@ Do **not** reach for `SimulateInput` here. It is only reachable from the
 in-editor chat bridge; an MCP or CLI caller gets
 `{ok: false, failure_reason: "unsupported_transport"}` back. Drive input from
 inside the probe with `press()` / `key()` instead.
+
+<!-- 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_batch` | `summer engine batch` |
+| `summer_game_probe` | `summer engine game-probe` |
+| `summer_get_diagnostics` | `summer engine get-diagnostics` |
+| `summer_inspect_node` | `summer engine inspect-node` |
+| `summer_inspect_runtime_node` | `summer engine inspect-runtime-node` |
+<!-- /shell-commands -->

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

@@ -206,3 +206,16 @@ No template — this is a workflow that produces the brief that drives template
 - `art-direction` — turn the one-phrase look into a full bible
 - `audio-direction` — sonic identity
 - `make-game` — scaffold the project once the brief is locked
+
+<!-- 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_get_project_context` | `summer engine get-project-context` |
+| `summer_get_scene_tree` | `summer engine get-scene-tree` |
+| `summer_read_file` | `summer engine read-file` |
+| `summer_write_file` | `summer engine write-file` |
+<!-- /shell-commands -->