# Summer Engine (npm · summer-engine)

The game engine built for AI. Any agent makes a multiplayer game and publishes it.

- Trust score: 75/100 (medium)
- Change this week: +4
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- remote · `mcp.summerengine.com`: 38/100, [markdown](https://verifymcp.io/servers/summerengine-summer/mcp.md), [page](https://verifymcp.io/servers/summerengine-summer/mcp)
- npm · `summer-engine`: 75/100 (this document), [markdown](https://verifymcp.io/servers/summerengine-summer/summer-engine.md), [page](https://verifymcp.io/servers/summerengine-summer/summer-engine)

## Channel facts

- Registry: `npm`
- Package: `summer-engine`
- Version: `4.5.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 81/100
  - No malware found by supply-chain analysis.
  - CVE check failed: a known high-severity CVE affects zod 3.25.76, a direct dependency. A fixed version is available.
  - No install/post-install scripts declared.
  - 32 of 105 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 48/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 7 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 75/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 21329 tokens (~229/item across 93 items; 93 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 67/100
  - Stability observed for 20 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 3 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 94 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the Summer Engine MCP server?

Summer Engine runs locally as an npm package, launched with npx -y summer-engine. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add summerengine-summer -- npx -y summer-engine
```

### Cursor

```json
{
  "mcpServers": {
    "summerengine-summer": {
      "command": "npx",
      "args": [
        "-y",
        "summer-engine"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "summerengine-summer": {
      "command": "npx",
      "args": [
        "-y",
        "summer-engine"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add summerengine-summer -- npx -y summer-engine
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "summerengine-summer": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "summer-engine"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add summerengine-summer --command npx --arg -y --arg summer-engine
```

### Hermes

```yaml
mcp_servers:
  summerengine-summer:
    command: "npx"
    args: ["-y", "summer-engine"]
```

### Netclaw

```json
{
  "McpServers": {
    "summerengine-summer": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "summer-engine"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add summerengine-summer -t stdio -c npx -a -y summer-engine
```

### Other

```json
{
  "mcpServers": {
    "summerengine-summer": {
      "command": "npx",
      "args": [
        "-y",
        "summer-engine"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-05 (score 75, +1)

No change was recorded against any check on this day. Stability & Change Management went from 63 to 67. That category is still filling its 30-day observation window: 19 days of observed history at the previous scan, 20 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-03 (score 74, +1)

No change was recorded against any check on this day. Stability & Change Management went from 57 to 60. That category is still filling its 30-day observation window: 17 days of observed history at the previous scan, 18 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-01 (score 73, +1)

No change was recorded against any check on this day. Stability & Change Management went from 50 to 53. That category is still filling its 30-day observation window: 15 days of observed history at the previous scan, 16 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-30 (score 72, +1)

No change was recorded against any check on this day. Stability & Change Management went from 43 to 47. That category is still filling its 30-day observation window: 13 days of observed history at the previous scan, 14 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-27 (score 71, +1)

No change was recorded against any check on this day. Stability & Change Management went from 33 to 37. That category is still filling its 30-day observation window: 10 days of observed history at the previous scan, 11 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-25 (score 70, +1)

No change was recorded against any check on this day. Stability & Change Management went from 27 to 30. That category is still filling its 30-day observation window: 8 days of observed history at the previous scan, 9 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-24 (score 69, −5)

- [security regression] CVE-2023-54404 affects this package: high
- [security regression] Known CVEs: pass → fail

### 2026-10-23 (score 74, +1)

No change was recorded against any check on this day. Stability & Change Management went from 20 to 23. That category is still filling its 30-day observation window: 6 days of observed history at the previous scan, 7 at this one. The score rises as the window fills, whether or not the server changes.

## MCP tools (93)

### `summer_create_scene` (~186 tokens)

Create a scene file

Create a new, minimal .tscn file with the root type you name. It fails when the file exists and never touches the open scene. Build it out with summer_run_script and that scenePath.
Guide: summer_docs_read {"id":"tool/create-scene"}

Input parameters:

- `allow_temporary_scene_mutation` (boolean): DEPRECATED, ignored. Scene creation no longer mutates any open scene; kept only so older callers don't break.
- `path` (string, required): New scene path, e.g. 'res://scenes/empty_level.tscn'
- `rootName` (string): Root node name for the new scene
- `rootType` (string): Root node type. Default 'Node3D' (3D scenes); common alternatives: 'Node2D' (2D scenes), 'Control' (UI scenes), 'Node' (logic-only).

### `summer_add_node` (~158 tokens)

Add a node

Add one node of any type to the scene at scenePath (it need not be the open tab) and save it. For 3 or more edits, write one summer_run_script instead. Next: summer_set_prop.
Guide: summer_docs_read {"id":"tool/add-node"}

Input parameters:

- `name` (string, required): Name for the new node, e.g. 'Player', 'MainCamera'
- `parent` (string, required): Parent node path, e.g. './World' or './World/Enemies'
- `scenePath` (string, required): Target scene path, e.g. 'res://main.tscn'
- `type` (string, required): Summer Engine node type, e.g. 'MeshInstance3D', 'CharacterBody3D'

### `summer_set_prop` (~173 tokens)

Set a node property

Set one property of a node in the scene at scenePath and save it. Values use Godot syntax: "Vector3(0, 1, 0)", "Color(1, 0, 0, 1)", or a resource class such as "BoxMesh". For 3 or more edits, write one summer_run_script.
Guide: summer_docs_read {"id":"tool/set-prop"}

Input parameters:

- `key` (string, required): Property name, e.g. 'position', 'mesh', 'visible'
- `path` (string, required): Node path, e.g. './World/Player'
- `scenePath` (string, required): Target scene path, e.g. 'res://main.tscn'
- `value` (required): Value in Summer Engine variant-string format for complex types, native JSON for primitives

### `summer_set_resource_property` (~173 tokens)

Set a property of a node's resource

Set a property inside a resource a node holds, such as a collision shape's size or a material's albedo_color, and save the scene. The resource must exist first: assign it with summer_set_prop.
Guide: summer_docs_read {"id":"tool/set-resource-property"}

Input parameters:

- `nodePath` (string, required): Node path, e.g. './Player/CollisionShape3D'
- `resourceProperty` (string, required): Resource property on the node, e.g. 'shape', 'mesh', 'material_override'
- `scenePath` (string, required): Target scene path, e.g. 'res://main.tscn'
- `subProperty` (string, required): Property on the resource, e.g. 'size', 'radius', 'albedo_color'
- `value` (required): Value in Summer Engine variant-string format

### `summer_remove_node` (~102 tokens)

Remove a node

Remove a node and all its children from the scene at scenePath and save it. The root cannot be removed. One undo step. Remove top-level nodes only when the person asked for it.
Guide: summer_docs_read {"id":"tool/remove-node"}

Input parameters:

- `path` (string, required): Node path to remove, e.g. './World/OldEnemy'
- `scenePath` (string, required): Target scene path, e.g. 'res://main.tscn'

### `summer_save_scene` (~101 tokens)

Save a scene

Save the scene at scenePath, or save it under a new path. Scene edits already save once; use this for a standalone save or a save-as.
Guide: summer_docs_read {"id":"tool/save-scene"}

Input parameters:

- `path` (string): Optional save-as path, e.g. 'res://levels/level2.tscn'
- `scenePath` (string, required): Scene to save, e.g. 'res://main.tscn'

### `summer_open_scene` (~97 tokens)

Open a scene in the editor

Open a scene file in the editor and show its tab. A visible tab change for the person, not a target for edits: edits take scenePath. Take paths from summer_get_project_context; never guess them.
Guide: summer_docs_read {"id":"tool/open-scene"}

Input parameters:

- `path` (string, required): Scene path, e.g. 'res://main.tscn' or 'res://levels/level1.tscn'

### `summer_instantiate_scene` (~342 tokens)

Add a scene or model as a node

Add an existing .tscn, .glb or .gltf as a child node in the scene at scenePath, placed in the same call (position, rotation_degrees, scale or transform). Pass target_size for imported models. Next: summer_screenshot.
Guide: summer_docs_read {"id":"tool/instantiate-scene"}

Input parameters:

- `name` (string): Override the instance name
- `parent` (string, required): Parent node path, e.g. './World'
- `position` (array): Parent-local position [x, y, z] set right after the instance is created.
- `rotation_degrees` (array): Parent-local rotation in degrees [x, y, z] (Godot rotation_degrees).
- `scale` (array): Local scale [x, y, z]. Not with target_size.
- `scene` (string, required): Scene/model path, e.g. 'res://player.tscn' or 'res://models/tree.glb'
- `scenePath` (string, required): Target scene to receive the instance, e.g. 'res://main.tscn'
- `target_size` (number): Normalize the instance's physical size: uniformly scale it so its largest world-AABB dimension equals this many units (chair 1.0, car 4.5, person 1.7).
- `transform` (string): Full local transform as "Transform3D(xx, xy, xz, yx, yy, yz, zx, zy, zz, ox, oy, oz)" (Godot row-major basis, then origin). Not with position/rotation_degrees/scale/target_size.

### `summer_connect_signal` (~165 tokens)

Connect a signal

Connect a signal of one node to a method of another so the saved scene keeps it, verified from the saved .tscn. The receiver should define the method. Then test it with summer_play.
Guide: summer_docs_read {"id":"tool/connect-signal"}

Input parameters:

- `emitter` (string, required): Node that fires the signal, e.g. './Player/HitArea'
- `method` (string, required): Method name in the receiver's script, e.g. '_on_hit_area_body_entered'
- `receiver` (string, required): Node with the handler script, e.g. './Player'
- `scenePath` (string, required): Target scene path, e.g. 'res://main.tscn'
- `signal` (string, required): Signal name, e.g. 'body_entered'

### `summer_select_node` (~78 tokens)

Select a node in the editor

Select a node in the editor's scene tree and show it in the inspector, so the person sees it. The scene does not change.
Guide: summer_docs_read {"id":"tool/select-node"}

Input parameters:

- `nodePath` (string, required): Node path to select
- `scenePath` (string): Open this scene first, then select the node

### `summer_replace_node` (~173 tokens)

Replace a node

Replace a node with another scene or node type, keeping its parent, index, name, transform and children; the saved file is read back to prove it. Next: summer_get_scene_tree.
Guide: summer_docs_read {"id":"tool/replace-node"}

Input parameters:

- `path` (string, required): Node path to replace, e.g. './House3/Front/G_f2_door'
- `scene` (string): Scene or model to replace with, e.g. 'res://kit/wall_door_02.tscn'. Give exactly one of type or scene.
- `scenePath` (string, required): Target scene path, e.g. 'res://main.tscn'
- `type` (string): New node type, e.g. 'RigidBody3D'. Give exactly one of type or scene.

### `summer_inspect_node` (~170 tokens)

Read a node's properties

Read one node of the open scene: every editable property with its value and type, or only the fields you name (transform, global_transform, scene_file_path, aabb). Next: summer_set_prop.
Guide: summer_docs_read {"id":"tool/inspect-node"}

Input parameters:

- `fields` (array): Only these fields: property names or globs (e.g. 'position', 'surface_material_override/*') and the derived fields transform, global_transform, scene_file_path, aabb, warnings.
- `maxCharacters` (integer): Most characters of text to return (default 4000). A longer result is cut and says so.
- `path` (string, required): Node path from scene tree, e.g. 'Player', 'World/Enemies/Boss', 'DirectionalLight3D'

### `summer_inspect_resource` (~220 tokens)

Read a resource

Read a resource file (a mesh's bounds and surfaces, a scene's nodes, any resource's non-default properties) or a resource a node holds (nodePath and property). Next: summer_set_resource_property.
Guide: summer_docs_read {"id":"tool/inspect-resource"}

Input parameters:

- `maxCharacters` (integer): Most characters of text to return (default 4000). A longer result is cut and says so.
- `nodePath` (string): With property: a node of the ACTIVE scene tab whose resource to read, e.g. 'Floor'. Do not combine with path.
- `path` (string): A resource FILE: 'res://materials/ground.tres', a mesh 'res://kit/meshes/wall_01.res', a texture, a shape, or a scene/model 'res://models/player.glb'. Loaded read-only in the editor.
- `property` (string): With nodePath: the node property holding the resource, e.g. 'mesh', 'material_override', 'shape', 'environment'.

### `summer_batch` (~150 tokens)

Run engine ops in one call

Send a list of raw engine ops (AddNode, SetProp, RunVerification...) in one call: one undo step unless an op must travel alone, and one save at the end. Ask for receipt summary on long lists. For computed edits, summer_run_script is simpler.
Guide: summer_docs_read {"id":"tool/batch"}

Input parameters:

- `ops` (array, required): Array of operation objects, each with 'op' plus its parameters
- `receipt` (string): full (default): every engine receipt. summary: counts, failures with op index, created node paths only (under 5 KB).
- `scenePath` (string): Required when ops contains scene mutations; exact res:// target scene path

### `summer_get_diagnostics` (~96 tokens)

Read errors and warnings

Read the editor console, the runtime debugger and script errors together, with complete counts and errors first. The first read after a change and after play. Next: summer_get_debugger_errors or summer_get_console for the details.
Guide: summer_docs_read {"id":"tool/get-diagnostics"}

Input parameters:

- `includeAll` (boolean): Return the full engine diagnostics payload untrimmed (no severity reordering, no info-noise cap).

### `summer_get_console` (~190 tokens)

Read the editor console

Read recent editor Output messages, collapsed and filtered (errors and warnings by default; errors_only false for print output). A played game's runtime errors are not here: read summer_get_diagnostics first.
Guide: summer_docs_read {"id":"tool/get-console"}

Input parameters:

- `errors_only` (boolean): Drop info/std noise, keep errors and warnings (default true)
- `filter` (string): Only return lines containing this string
- `maxCharacters` (integer): Most characters of text to return (default 4000). A longer result is cut and says so.
- `max_lines` (number): Max lines to return after dedupe (default 100)
- `raw` (boolean): Bypass dedupe and level filtering — return engine output verbatim
- `strict_errors` (boolean): Drop warnings too — return errors only
- `type` (string): Filter by message type at the engine level

### `summer_clear_console` (~38 tokens)

Clear the editor console

Clear the editor's Output panel, for a clean slate before the game runs.
Guide: summer_docs_read {"id":"tool/clear-console"}

### `summer_get_debugger_errors` (~178 tokens)

Read runtime errors

Read the played game's runtime errors from the debugger (null references, missing nodes, physics errors), collapsed, with call stacks on request. After a fix, read summer_get_diagnostics again.
Guide: summer_docs_read {"id":"tool/get-debugger-errors"}

Input parameters:

- `include_stack` (boolean): Include stack traces for each error
- `include_warnings` (boolean): Forward-compat flag — when engine supports it, returns warning bodies in the same call. Today the engine ignores it; use summer_get_debugger_warnings instead.
- `maxCharacters` (integer): Most characters of text to return (default 4000). A longer result is cut and says so.
- `max_errors` (number): Max errors to return after dedupe
- `raw` (boolean): Bypass dedupe — return engine output verbatim

### `summer_get_debugger_warnings` (~111 tokens)

Read runtime warnings

Read the played game's runtime warnings from the debugger, with file, line and call stack.
Guide: summer_docs_read {"id":"tool/get-debugger-warnings"}

Input parameters:

- `include_stack` (boolean): Include stack traces
- `maxCharacters` (integer): Most characters of text to return (default 4000). A longer result is cut and says so.
- `max_warnings` (number): Max warnings to return after dedupe
- `raw` (boolean): Bypass dedupe

### `summer_play` (~527 tokens)

Play the game

Play the game in the editor's real window (agents may; quiet: the editor keeps its tab and focus): main scene or a given one, embedded or a hidden offscreen instance, optional seed and fixed frame rate, or local multiplayer (players). Next: summer_is_running, summer_get_diagnostics.
Guide: summer_docs_read {"id":"tool/play"}

Input parameters:

- `deterministic` (boolean): Offscreen only: launch with --fixed-fps 60 --summer-seed <seed> --audio-driver Dummy so the run is reproducible and input replays with seed are accepted.
- `fixed_fps` (integer): Fixed timestep for this launch (child gets --fixed-fps <n>): scene time decouples from the wall clock, the game runs as fast as it renders, frame-count-derived state repeats run to run, and at_ms…
- `focus` (boolean): Default false = QUIET play (PlayGame agent:true): the editor does not switch to the Game tab or grab focus for the embedded game, so the user keeps working.
- `instance` (string): Name a game instance. 'main' (default) = the editor's embedded game. Any other name with mode:'offscreen' spawns a disposable parallel instance (at most 3) that the runtime tools address by this name.
- `mode` (string): 'embedded' (default) plays in the editor; 'offscreen' spawns a hidden child process (requires instance != 'main').
- `players` (integer): Local Play for a Summer multiplayer game (engine with Local Play): start the game's authority headless plus this many clients on this machine, each joining through the game's own Summer.client.join.
- `queue` (string): Local Play: the summer.build.json queue the local World stands in for (default: the first declared queue).
- `scene` (string): Scene to run instead of main scene, e.g. 'res://levels/test_level.tscn'
- `seed` (integer): Pin the game's GLOBAL RNG for this launch (child gets --summer-seed <seed>; default 20260725 when deterministic:true and seed is omitted).
- `spectators` (integer): Local Play: also start this many spectator clients (only with players).
- `speed` (number): User time scale applied on session start, (0, 100] — e.g. 0.5 for half speed.
- `time_scale` (number): Engine time scale for this launch (child gets --time-scale <f>). Not a determinism pin on its own.

### `summer_stop` (~72 tokens)

Stop the game

Stop the running game, or one offscreen instance by name. Scene edits stay as they are; nothing is undone or saved.
Guide: summer_docs_read {"id":"tool/stop"}

Input parameters:

- `instance` (string): Offscreen instance name to stop (from summer_play {instance}); omit for the main embedded game.

### `summer_is_running` (~34 tokens)

Check whether the game runs

Check whether the game is running, and which scene it runs.
Guide: summer_docs_read {"id":"tool/is-running"}

### `summer_get_script_errors` (~84 tokens)

Check a script for errors

Check one GDScript file for parse and compile errors without running the game: line, message and severity of each. The first check after writing a script.
Guide: summer_docs_read {"id":"tool/get-script-errors"}

Input parameters:

- `path` (string, required): Script path, e.g. 'res://scripts/player.gd' or 'res://player_controller.gd'

### `summer_create_debug_report` (~210 tokens)

Write a debug report

Write a support-ready Markdown report: doctor checks, engine health, diagnostics, console and debugger output, and a hand-off prompt. No tokens or file contents; the person should still read it before sending it.
Guide: summer_docs_read {"id":"tool/create-debug-report"}

Input parameters:

- `include_doctor` (boolean): Include summer doctor checks in the report.
- `include_play_session` (boolean): Launch the game briefly and collect post-play diagnostics.
- `issue` (string): User-visible issue or repro summary.
- `max_console_lines` (number): Console lines to include after filtering/deduping.
- `max_debugger_entries` (number): Debugger error/warning entries to include after filtering/deduping.
- `output_path` (string): Where to write the Markdown report. Defaults to the open project root, or the current working directory if no project is open.
- `play_wait_ms` (number): Milliseconds to wait after launching the game when include_play_session is true.

### `summer_screenshot` (~718 tokens)

Take a screenshot

Return a frame as an image you see, to check your work by eye: the editor viewport, an offscreen render of a scene (preset, camera, bookmark or free pose, numbered marks) or the running game. A blank viewport frame means no redraw yet: capture again.
Guide: summer_docs_read {"id":"tool/screenshot"}

Input parameters:

- `bookmark_name` (string): framing:"bookmark" only (implies it when framing is omitted). Name of a bookmark saved with summer_engine_save_camera_bookmark (list: summer_engine_list_camera_bookmarks).
- `camera_look_at` (string): framing:"free" only. Point the camera looks at, e.g. "Vector3(0, 1, 0)". Must differ from camera_position.
- `camera_path` (string): framing:"camera" only. Path of the Camera3D to render through (relative to the scene root) when the scene has several cameras or none marked current. Omit to use the scene's current/first Camera3D.
- `camera_position` (string): framing:"free" only (implies it when framing is omitted). Camera position as a Godot literal, e.g. "Vector3(0, 5, 12)". Goes together with camera_look_at.
- `compare_previous` (boolean): framing:"bookmark" only. Return ONE image of [previous render | now | difference map] for the bookmark, with the share of changed pixels (summer_shot_sheet compare_previous with this one bookmark);…
- `fov` (number): framing:"free" / "bookmark" only. Vertical field of view in degrees (1..179; default 60 for "free", the bookmark's own for "bookmark").
- `framing` (string): target:"scene" only, 3D scenes. Camera direction preset: "iso" = 3/4 diagonal view, "top" = straight down, "front" = camera at +Z, "back" = camera at -Z, "left" = camera at -X, "right" = camera at +X.
- `marks` (boolean): target:"scene" only, 3D scenes. Draw a Set-of-Mark overlay: numbered tags + box outlines over the largest visible VisualInstance3D nodes (lights excluded), ranked by projected screen area.
- `max_marks` (integer): marks:true only. Cap on numbered labels (engine default 32, at most 128). The caption says when the cap truncated the list.
- `nodePath` (string): target:"scene" only. Node path relative to the scene root (e.g. "Player/Mesh") to frame INSTEAD of the whole scene — the camera fits that node's combined bounds (3D visual AABBs or 2D rects, children…
- `scenePath` (string): target:"scene" only. Full scene path, e.g. "res://main.tscn". Omit to render the currently-open scene.
- `size` (array): target:"scene" only. Output image [width, height] in pixels.
- `target` (string): "viewport" = editor current view (default), "scene" = offscreen render of a scene file, "game" = running game frame
- `update_previous` (boolean): framing:"bookmark" only. Replace the bookmark's previous image (its compare baseline) with this clean render. Default false: an existing baseline is kept.

### `summer_frame_nodes` (~456 tokens)

Frame nodes and render them

Fit a camera to the world bounds of some nodes and render them with the scene's real environment and lights; bookmark_name also saves the pose. Returns the image and a caption with the pose and bounds.
Guide: summer_docs_read {"id":"tool/frame-nodes"}

Input parameters:

- `aspect` (number): Frame width/height (default 1.7778 = 16:9). Every tile uses it.
- `bookmark_name` (string): Also save the fitted pose as this camera bookmark (1-64 of A-Z a-z 0-9 _ -), so later renders line up with it.
- `direction` (string): Side the camera sits on: "front" (+Z), "back" (-Z), "left" (-X), "right" (+X), "top", "iso" (default, 3/4 from -X,+Y,-Z like summer_screenshot). Use from for anything else.
- `fill` (number): Share of the frame the nodes span along their limiting dimension (0.1..1.5, default 0.8).
- `fov` (number): Vertical field of view in degrees (default 50).
- `from` (string): Explicit direction FROM the nodes TOWARD the camera, "Vector3(1, 0.4, 2)". Replaces direction.
- `marks` (boolean): Numbered Set-of-Mark labels over the largest visible nodes; the caption maps label -> node path (feed a label to summer_zoom mark).
- `max_marks` (integer): marks only: cap on labels (engine default 32).
- `max_size` (integer): Longest edge of the returned JPEG in pixels (default 1024). Bigger costs more context; up to 4096 for detail work on a PC.
- `nodes` (array, required): Node paths relative to the scene root ("House1", "Props/Crate_02"). The camera fits their combined WORLD bounds (visible meshes, children included).
- `scenePath` (string): Scene to look at, e.g. "res://levels/town.tscn" (the SAVED file). Omit for the scene open in the editor.

### `summer_shot_sheet` (~387 tokens)

Render a sheet of views

Render several bookmarks or poses into one labelled grid with real lighting, and compare each bookmark with its last render (difference map). The quick look at every hero view after a change.
Guide: summer_docs_read {"id":"tool/shot-sheet"}

Input parameters:

- `aspect` (number): Frame width/height (default 1.7778 = 16:9). Every tile uses it.
- `compare_previous` (boolean): For bookmark shots: one row per bookmark of [previous render | now | difference map], with the share of changed pixels in the caption.
- `max_size` (integer): Longest edge of the returned JPEG in pixels (default 1536). Bigger costs more context; up to 4096 for detail work on a PC.
- `save_to` (string): Also write the returned image to res://.summer/shots/saved/<name>.jpg (1-64 of A-Z a-z 0-9 _ -; needs max_size <= 1024).
- `scenePath` (string): Scene to look at, e.g. "res://levels/town.tscn" (the SAVED file). Omit for the scene open in the editor.
- `shots` (array, required): 1-12 shots, each a bookmark_name OR camera_position + camera_look_at (+ fov), with an optional label. Rendered in this order, left to right, top to bottom.
- `update_previous` (boolean): Replace each bookmark's previous image (its compare baseline) with this render without comparing.
- `view` (string): "beauty" (default: real environment, lights, fog, tonemap), "lighting" (light only), "unshaded" (albedo/texture only), "normals" (world normals, x red y green z blue), "overdraw", "wireframe".

### `summer_debug_views` (~414 tokens)

Render debug views of a pose

Render one pose as a grid of debug views next to the beauty pass: lighting only, albedo, world normals, overdraw and wireframe. Shows why a shot looks wrong.
Guide: summer_docs_read {"id":"tool/debug-views"}

Input parameters:

- `aspect` (number): Frame width/height (default 1.7778 = 16:9). Every tile uses it.
- `bookmark_name` (string): Pose from a camera bookmark (summer_engine_save_camera_bookmark (list: summer_engine_list_camera_bookmarks)). Use INSTEAD of camera_position/camera_look_at.
- `camera_look_at` (string): Explicit pose: point the camera looks at, "Vector3(x, y, z)".
- `camera_position` (string): Explicit pose: camera position, "Vector3(x, y, z)". Goes with camera_look_at.
- `fov` (number): Vertical field of view in degrees (1..179). Default: the bookmark's own, or 60.
- `max_size` (integer): Longest edge of the returned JPEG in pixels (default 1536). Bigger costs more context; up to 4096 for detail work on a PC.
- `save_to` (string): Also write the returned image to res://.summer/shots/saved/<name>.jpg (1-64 of A-Z a-z 0-9 _ -; needs max_size <= 1024).
- `scenePath` (string): Scene to look at, e.g. "res://levels/town.tscn" (the SAVED file). Omit for the scene open in the editor.
- `update_previous` (boolean): bookmark_name only: replace the bookmark's previous image (compare baseline) with this beauty tile. Default false: only a missing slot is created.
- `views` (array): Which views, in grid order (default all six: beauty, lighting, unshaded, normals, overdraw, wireframe).

### `summer_zoom` (~550 tokens)

Zoom into part of a frame

Render a close-up of part of a frame (a region, or mark N of a marks render) at full resolution: real detail, seams and gaps, not enlarged pixels.
Guide: summer_docs_read {"id":"tool/zoom"}

Input parameters:

- `bookmark_name` (string): Pose from a camera bookmark (summer_engine_save_camera_bookmark (list: summer_engine_list_camera_bookmarks)). Use INSTEAD of camera_position/camera_look_at.
- `camera_look_at` (string): Explicit pose: point the camera looks at, "Vector3(x, y, z)".
- `camera_position` (string): Explicit pose: camera position, "Vector3(x, y, z)". Goes with camera_look_at.
- `fov` (number): Vertical field of view in degrees (1..179). Default: the bookmark's own, or 60.
- `mark` (integer): A label number from a marks:true render of the SAME pose and reference_size (summer_frame_nodes, or summer_screenshot framing free/bookmark at that size).
- `max_size` (integer): Longest edge of the returned JPEG in pixels (default 1024). Bigger costs more context; up to 4096 for detail work on a PC.
- `pad` (number): Margin added around the region on each side, as a fraction of its size (0..1; default 0 for region, 0.15 for mark). The caption's widened_because says when the rendered window is larger than asked.
- `reference_size` (array): [width, height] of the frame region/mark refer to (default [1024, 576]). Sets the zoom's aspect.
- `region` (array): [x, y, w, h] as fractions (0..1) of the frame from the same pose, x/y from the TOP-LEFT. Use this OR mark.
- `save_to` (string): Also write the returned image to res://.summer/shots/saved/<name>.jpg (1-64 of A-Z a-z 0-9 _ -; needs max_size <= 1024).
- `scenePath` (string): Scene to look at, e.g. "res://levels/town.tscn" (the SAVED file). Omit for the scene open in the editor.
- `view` (string): "beauty" (default: real environment, lights, fog, tonemap), "lighting" (light only), "unshaded" (albedo/texture only), "normals" (world normals, x red y green z blue), "overdraw", "wireframe".

### `summer_frame_shot` (~586 tokens)

Find camera poses for a shot

Find, score and save camera poses for a shot type (establishing, eye level, low angle, detail, corridor), tested against the real geometry in the open editor. Returns the best 3 poses and a sheet to look at, and saves the best as a bookmark.
Guide: summer_docs_read {"id":"tool/frame-shot"}

Input parameters:

- `aspect` (number): Frame width/height (default 1.7778 = 16:9). Every tile uses it.
- `bookmark_name` (string): Name for the saved best pose (default <shot>_<subject leaf>).
- `eye_height` (number): eye_level/corridor: exact camera height in metres above the walkable surface under the camera (default: 1.6; an eye_level spawn's own Camera3D keeps its height clamped into 1.5-1.8).
- `fov` (number): Override the shot type's field of view (establishing 55, eye_level 60/75, low_angle 60 then widened, detail 40, corridor 60/75).
- `max_size` (integer): Longest edge of the returned JPEG in pixels (default 1536). Bigger costs more context; up to 4096 for detail work on a PC.
- `max_soft_fraction` (number): Most of the subject that soft geometry may cover before a pose is rejected (0..1, default 0.67).
- `occluders` (object): Override the occluder classification. Default: path names (wall/house/terrain... = hard; tree/fence/lamp/prop/pipe... = soft), MultiMesh = soft, else size (<= 2.5 m = soft).
- `render` (string): "sheet" (default): the top 3 in one labelled grid with real lighting; "best": the winner only; "none": scores only.
- `save_bookmark` (boolean): Save the best pose as a camera bookmark (default true).
- `scenePath` (string): Scene to look at, e.g. "res://levels/town.tscn" (the SAVED file). Omit for the scene open in the editor.
- `shot` (string, required): "establishing" (wide, whole subject, 12-40 deg up; a pose showing more than 15% empty ground or world edge ranks below every pose showing less), "eye_level" (player eye at spawn: its Camera3D kept…
- `spawn` (string): eye_level only: node the player stands at, e.g. the player or a spawn marker. Its own geometry never counts as an occluder.
- `subject` (array): Node paths to frame (required except for eye_level, where it is what the player looks at).

### `summer_scene_audit` (~452 tokens)

Audit a 3D scene

Check a saved 3D scene for visual and placement problems: holes, exposed edges, floor gaps, floating or sunken props, overlaps, z-fighting, light limits. Returns issues by severity, each with the next tool. Changes nothing.
Guide: summer_docs_read {"id":"tool/scene-audit"}

Input parameters:

- `accept` (array): Accept look or warn items you judged fine (up to 50 per call): [{key, reason}] with keys from this scene's issues.
- `budget_ms` (integer): Editor time for the whole audit (default 3000 ms, 250-60000).
- `checks` (array): Only these checks (default: all 15). through_hole, floor_gap, floating, sunken, interpenetration, exposed_edge, open_fixture_end, orientation, uv_stretch, duplicate, z_fight, depth_step, lights,…
- `limit` (integer): Issues per page (default 15, max 50). The result is capped at 5 KB; a page that does not fit is cut and says so.
- `min_severity` (string): "error" (only errors), "warn" (errors and warnings) or "look" (default: everything, including look items that only ask you to look).
- `offset` (integer): Skip this many issues of the sorted, filtered list (paging; the result names the next offset).
- `render` (string): "sheet": also return ONE inline image of the first 6 issues of this page framed up close from their open side, each tile labelled with its issue number. Default "none" (no image).
- `root` (string): Report only issues under this node (subtree), e.g. "Block3". The whole scene is still loaded so walls and floors outside it count as surroundings.
- `scenePath` (string): Scene to audit, e.g. "res://levels/town.tscn" (the SAVED file). Omit for the scene open in the editor.
- `show_accepted` (boolean): List accepted items too (each with its accepted reason). Default false: hidden, only counted.

### `summer_get_project_context` (~218 tokens)

Read the project context

Bind this session to the project open in Summer Engine and read it: project, current and main scene, engine health, project memory and warnings. Call it first in every chat; the scene tree and settings come on request (include). Next: summer_get_scene_tree.
Guide: summer_docs_read {"id":"tool/get-project-context"}

Input parameters:

- `include` (array): Heavy blocks to add to the compact default: 'scene_tree' (the open scene's node tree, up to 200 nodes), 'capabilities' (the engine's full op/capability lists), 'settings' (project settings, curated…
- `settingsPrefix` (string): Only return project settings whose key starts with this prefix, e.g. 'audio/' or 'application/config/'. Omit for the curated default set.
- `settingsPrefixes` (array): Several settings groups at once, e.g. ['audio/', 'layer_names/2d_physics/', 'input/ui_']. Merged with settingsPrefix. Omit for the curated default set.

### `summer_open_main_scene` (~46 tokens)

Open the main scene

Open the project's main scene (from project settings) in the editor, instead of guessing a scene file name.
Guide: summer_docs_read {"id":"tool/open-main-scene"}

### `summer_project_setting` (~72 tokens)

Set a project setting

Set one project.godot setting, such as application/run/main_scene, the window size, the renderer or the default gravity.
Guide: summer_docs_read {"id":"tool/project-setting"}

Input parameters:

- `key` (string, required): Setting key path, e.g. 'application/config/name'
- `value` (required): Setting value

### `summer_input_map_bind` (~88 tokens)

Bind input to an action

Create an input action when it is missing and bind keys or mouse buttons to it, for example jump to Space. Then try it with summer_play.
Guide: summer_docs_read {"id":"tool/input-map-bind"}

Input parameters:

- `events` (array, required): Array of input event objects
- `name` (string, required): Action name, e.g. 'jump', 'move_forward', 'interact'

### `summer_get_scene_tree` (~165 tokens)

Read a scene's node tree

Read the node tree of a scene: names, types and paths. Pass scenePath for an exact scene and depth for deep trees; the engine stops at depth 2 and 200 nodes by default and says truncated. Next: summer_inspect_node.
Guide: summer_docs_read {"id":"tool/get-scene-tree"}

Input parameters:

- `depth` (integer): Maximum tree depth to walk. Engine default is 2 — pass a larger value for deep hierarchies.
- `limit` (integer): Maximum number of nodes to return. Engine default is 200.
- `maxCharacters` (integer): Most characters of text to return (default 8000). A longer result is cut and says so.
- `scenePath` (string): Exact res:// scene path to inspect

### `summer_import_from_url` (~107 tokens)

Import a file from a URL

Download one file (model, texture, audio) from a URL into the project and run the import, so it is ready to use. For a model, next: summer_instantiate_scene.
Guide: summer_docs_read {"id":"tool/import-from-url"}

Input parameters:

- `path` (string): Target path in project, e.g. 'res://assets/player.glb'. Auto-inferred from URL if omitted.
- `url` (string, required): HTTP(S) URL to download from

### `summer_import_from_url_batch` (~61 tokens)

Import files from URLs

Download several files from URLs into the project in one call, with one import scan at the end.
Guide: summer_docs_read {"id":"tool/import-from-url-batch"}

Input parameters:

- `imports` (array, required): Array of {url, path} objects

### `summer_projects_create_local` (~155 tokens)

Create a project on this computer

Create a project on this computer. Writes a template (3d-basic by default) to a folder, no shell needed. Returns projectPath. Next: summer_projects_open_local.

Input parameters:

- `dir` (string): 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.
- `name` (string): The project's name and folder name. Default my-game (or the template's name).
- `template` (string): Template slug (docs.search finds them): 3d-basic (default), empty, 3d-third-person-controller, 2d-platformer, ...

### `summer_projects_open_local` (~100 tokens)

Open a project in Summer Engine

Open a project in Summer Engine. Waits until it connects; installs the engine only with install: true (the person's yes). Next: summer_get_project_context.

Input parameters:

- `install` (boolean): Install Summer Engine first when it is missing. Set true only after the person said yes.
- `path` (string): The project folder (holds project.godot), e.g. projectPath from summer_projects_create_local. Default this session's project.

### `summer_read_file` (~326 tokens)

Read a project file

Read a text file of the project (res://), a line or byte window of it, or parts of a .json, with the whole file's sha256. Pass that sha256 to summer_write_file or summer_replace_text to change the file safely.
Guide: summer_docs_read {"id":"tool/read-file"}

Input parameters:

- `json_path` (string): For a JSON file: return only this value, e.g. 'pieces.wall_a', 'pieces["a b"]', 'items[3].size_m'.
- `keys` (array): For a JSON object (the file root or the json_path value): keep only these keys; * and ? wildcards, e.g. ['wall_*'].
- `keys_only` (boolean): For a JSON object: return only its key names (after the keys filter), not the values — a cheap table of contents.
- `limit` (integer): Return at most this many units (lines by default). The result's window.next_offset continues the read.
- `max_bytes` (integer): Most bytes of content to return (UTF-8). Default 200000. A window or JSON selection is cut at this size too.
- `offset` (integer): Skip this many units (lines by default, see unit) before returning content. 0 = from the start.
- `path` (string, required): Project path, e.g. res://scripts/player.gd
- `unit` (string): What offset/limit count: 'lines' (default) or 'bytes' (cut on UTF-8 character boundaries).

### `summer_grep` (~278 tokens)

Search project files

Search project files with a regular expression: file, line and text of each match, with optional context lines and a result cap. Then read the part you need with summer_read_file.
Guide: summer_docs_read {"id":"tool/grep"}

Input parameters:

- `case_sensitive` (boolean): Match case exactly (default false: case-insensitive).
- `context_lines` (integer): Lines of context before and after each match (0-10, default 0).
- `glob` (string): File filter passed to ripgrep --glob, e.g. '*.gd', '**/*.json', '!addons/**'. A glob also reaches files .gitignore would skip.
- `max_line_chars` (integer): Clip every returned line to this many characters (default 240).
- `max_results` (integer): Most matches to return (default 50, max 500). truncated:true means there were more.
- `multiline` (boolean): Let the pattern span lines (ripgrep -U --multiline-dotall).
- `path` (string): Search scope: a res:// directory or file, e.g. 'res://kit/' or 'res://kit/kit_manifest.json'. Default: the whole project.
- `pattern` (string, required): Ripgrep regular expression, e.g. '"fits_into"' or 'func _on_.*_pressed'

### `summer_write_file` (~148 tokens)

Write a project file

Create a text file (create_only true) or overwrite one (expected_sha256 from summer_read_file); exactly one guard is required, so a stale write fails. Scripts, scenes, resources, JSON. Then check scripts with summer_get_script_errors.
Guide: summer_docs_read {"id":"tool/write-file"}

Input parameters:

- `content` (string, required): Complete new UTF-8 file content.
- `create_only` (boolean): Required for a new file; refuses if the path already exists.
- `expected_sha256` (string): Required for overwriting an existing file; obtain from summer_read_file.
- `path` (string, required): Project path, e.g. res://scenes/player.tscn

### `summer_replace_text` (~125 tokens)

Replace text in a project file

Replace text in an existing project file. The text must match exactly once unless replace_all is set; the write is guarded by the file's sha256. Then check scripts with summer_get_script_errors.
Guide: summer_docs_read {"id":"tool/replace-text"}

Input parameters:

- `new_text` (string, required): Replacement text; may be empty.
- `old_text` (string, required): Exact text to replace.
- `path` (string, required): Project path, e.g. res://scripts/player.gd
- `replace_all` (boolean): Replace every exact occurrence instead of requiring one unique match.

### `summer_import_asset_by_id` (~171 tokens)

Import a Summer asset by id

Import one Summer asset by its id (from a search, the person's assets or a generation) into the project; a 3D model can go straight into the scene at scenePath. Needs the Summer sign-in.
Guide: summer_docs_read {"id":"tool/import-asset-by-id"}

Input parameters:

- `assetId` (string, required): Summer ArtAssets id
- `name` (string): Optional scene node name when parent is provided.
- `parent` (string): Optional parent node path. For 3D models only; imports and instantiates under this node.
- `path` (string): Optional target res:// path. If omitted, a path is inferred from asset type and filename.
- `scenePath` (string): Required with parent. Exact res:// scene that receives the 3D model.

### `summer_import_asset` (~162 tokens)

Find and import a Summer asset

Search the Summer asset library, import the best match into the project and, for a 3D model, add it to a scene. Needs the Summer sign-in. For an exact asset use summer_import_asset_by_id.
Guide: summer_docs_read {"id":"tool/import-asset"}

Input parameters:

- `assetType` (string): Preferred asset type
- `parent` (string): Parent node path to add the asset under, e.g. './World'. If omitted, only imports (no scene placement)
- `query` (string, required): What to find, e.g. 'low-poly tree', 'wooden crate'
- `scenePath` (string): Required with parent. Exact res:// target scene path.
- `source` (string): Where to search before importing

### `summer_import_hdri` (~173 tokens)

Import an HDRI sky

Find a CC0 HDRI sky on Poly Haven (or take an exact id) and import it into res://sky/ for environment light. Returns a ready summer_run_script snippet that wires it into the WorldEnvironment.
Guide: summer_docs_read {"id":"tool/import-hdri"}

Input parameters:

- `assetId` (string): Exact Poly Haven asset id (lowercase slug, e.g. 'kloppenheim_02'). Skips the search.
- `query` (string): What kind of sky/environment, e.g. 'sunset beach', 'overcast field', 'studio'. Omit when assetId is given.
- `resolution` (string): HDRI resolution. 2k (default) is right for most games; 4k for hero skies; 1k for quick blockouts.

### `summer_export_game` (~260 tokens)

Export the game

Export the game headless as the file the Summer Games store takes: a bundle for iPhone, Android, macOS and Windows, a web build or a desktop download. Returns path, sha256 and size. Upload it with store.upload_file.
Guide: summer_docs_read {"id":"tool/export-game"}

Input parameters:

- `alignDeclaration` (boolean): A game with a server: set summer.build.json targetPlatforms to targets before exporting.
- `debug` (boolean): Export a debug build (--export-debug).
- `format` (string): bundle (default): the summer.games store build. download: a web build or native download; the default when targets is ["web"].
- `out` (string): Output .zip path. Defaults to <project>/.summer/exports/.
- `project` (string): Project folder with project.godot. Defaults to the MCP's bound project, then the working directory.
- `targets` (array): Store platforms. Bundle: any of macos, windows, ios, android (omit to use every platform the project declares). Download: exactly one of web, macos, windows.
- `timeoutSeconds` (integer): Stop the engine after this many seconds (default 900; a first export imports every asset).

### `summer_export_templates` (~151 tokens)

List or install export templates

List or install Summer Engine export templates (web, macOS, Windows) from Summer's CDN, each sha256-checked. Needed only for summer_export_game with format download.
Guide: summer_docs_read {"id":"tool/export-templates"}

Input parameters:

- `action` (string, required): list: installed and published templates. install: download and install.
- `includeDebug` (boolean): Also install the debug templates (for exports with debug true).
- `platforms` (array): Template platforms to install (default ["web"]).
- `summerVersion` (string): The installed Summer Engine version (Help > About, e.g. 0.7.1). Read automatically on macOS; needed on Windows and Linux.

### `summer_capture_gameplay` (~316 tokens)

Capture gameplay screenshots

Capture real gameplay frames (HUD included) from a hidden game window, no editor needed; game flags and player steps get past the title screen. Returns each frame's path and size: look at them before use.
Guide: summer_docs_read {"id":"tool/capture-gameplay"}

Input parameters:

- `args` (array): The game's own command-line flags, passed after "--" (OS.get_cmdline_user_args()), e.g. ["--autostart", "--solo"] to skip the title screen.
- `frames` (integer): Frames to save (default 1).
- `intervalSeconds` (number): Seconds between frames (default 1).
- `out` (string): Output folder. Defaults to <project>/.summer/captures/<time>/ (ignored by git).
- `project` (string): Project folder with project.godot. Defaults to the MCP's bound project, then the working directory.
- `resolution` (string): Window size WIDTHxHEIGHT (default 1920x1080; 1080x1920 for portrait).
- `scene` (string): Scene to start (res://... or uid://...). Default: the project's main scene, which is often a title menu; pass the gameplay scene for gameplay frames.
- `steps` (array): What to do after waitSeconds, in order; exactly one of press, key, action, click, drag, wait, shot per step.
- `waitSeconds` (number): Seconds the game runs before the first frame (default 3).

### `summer_run_script` (~285 tokens)

Run a script on a scene

Run one GDScript func run(ctx) in the live editor on the scene at scenePath: the way to make 3 or more scene edits, loops, grids and procedural meshes. Returns reports, output and errors. Loop: summer_world_snapshot, this, summer_snapshot_diff, summer_screenshot.
Guide: summer_docs_read {"id":"tool/run-script"}

Input parameters:

- `checkpoint` (boolean): Take a SummerGit checkpoint before running (default true). The result confesses (no_rewind_point) when no checkpoint could be taken.
- `max_seconds` (number): Time budget in seconds (default 20, clamped 5-120). The script blocks the editor while it runs — keep it short.
- `scenePath` (string): The scene to run against, e.g. 'res://main.tscn'. Opened first when it is not the edited scene, then the person's tab is restored. Omit only to run against whatever scene is open.
- `source` (string, required): GDScript source containing `func run(ctx):`. No extends/@tool line — just the function (plus any helpers).
- `undo` (string): Transaction mode (newer engines). 'action' (engine default): the whole run is ONE named undo action, and a mid-script runtime error rolls it back before returning (result rolled_back:true) — no…

### `summer_run_editor_script` (~189 tokens)

Run a script in a headless editor

Run an EditorScript func _run() in a fresh headless editor against the project on disk: batch and project-wide jobs such as re-saving many scenes. It cannot see unsaved edits. For the open scene use summer_run_script.
Guide: summer_docs_read {"id":"tool/run-editor-script"}

Input parameters:

- `checkpoint` (boolean): Take a SummerGit checkpoint before the child editor runs. The result confesses (no_rewind_point) when none could be taken.
- `max_seconds` (number): Time budget in seconds for the child editor (default 120, clamped 15-600). Include boot time — large projects can take 30s+ just to start.
- `source` (string, required): EditorScript GDScript source with `func _run():`. '@tool' / 'extends EditorScript' are optional — missing lines are prepended and reported in normalizations.

### `summer_api_docs` (~122 tokens)

Look up an engine class

Look up an engine class offline before writing script code: inherits, properties, methods, signals and constants, or one member. Lists only members declared on that class (walk inherits). No engine needed. Next: summer_run_script.

Input parameters:

- `class_name` (string, required): Engine class name, e.g. 'BoxShape3D', 'CharacterBody3D', 'SurfaceTool'. Case-insensitive.
- `member` (string): Optional property/method/signal/constant name to fetch just that member, e.g. 'size' or 'move_and_slide'.

### `summer_world_snapshot` (~294 tokens)

Take a scene snapshot

Take a structured snapshot of the edited scene: node paths, transforms, world bounds, fingerprints and counts, filtered by subtree, class or field. Returns snapshot_id, the baseline to diff after a change. Next: summer_snapshot_diff.
Guide: summer_docs_read {"id":"tool/world-snapshot"}

Input parameters:

- `classes` (array): Only nodes of these classes, e.g. ['MeshInstance3D', 'OmniLight3D'] (* wildcards allowed).
- `fields` (array): Only these per-node fields (path is always kept): class, name, pos, rot_deg, scale, visible, aabb, scene_file, script_fp, material_fps, z_index, rect, view_rect, limit_rect.
- `max_nodes` (integer): Most node entries to return (default 200). The engine still snapshots the whole scene for the diff baseline; the result says when the list is cut (truncated, next_offset).
- `offset` (integer): Skip this many matching nodes (path-sorted) before listing — page with the result's next_offset.
- `path_prefix` (string): Only this subtree: the node at this scene-relative path and everything below it, e.g. 'House3' or 'Lane2/Props'.
- `scene_path` (string): Scene to snapshot, e.g. 'res://main.tscn'. Omit for the currently edited scene.

### `summer_snapshot_diff` (~112 tokens)

Compare two scene snapshots

Compare two scene snapshots: added, removed and changed nodes and count changes. The proof that a change did what you meant; an empty diff after a change means it did not land. Next: summer_screenshot.
Guide: summer_docs_read {"id":"tool/snapshot-diff"}

Input parameters:

- `from_id` (string, required): snapshot_id of the BEFORE snapshot (from summer_world_snapshot).
- `to_id` (string): snapshot_id of the AFTER snapshot. Omit to snapshot the current state now and diff against that.

### `summer_get_runtime_tree` (~150 tokens)

Read the running game's tree

Read the node tree of the RUNNING game: spawned enemies, autoloads and pooled nodes that editor reads never show. Needs a running game. Next: summer_inspect_runtime_node.
Guide: summer_docs_read {"id":"tool/get-runtime-tree"}

Input parameters:

- `depth` (integer): Maximum depth to walk (engine default 3).
- `limit` (integer): Maximum nodes to return (engine default 500).
- `maxCharacters` (integer): Most characters of text to return (default 4000). A longer result is cut and says so.
- `path` (string): Subtree root to read, e.g. '/root/Main/Enemies'. Omit for the scene tree root.

### `summer_inspect_runtime_node` (~116 tokens)

Read a node in the running game

Read the live properties of one node in the RUNNING game (transform, visibility, physics state...) without stopping it. Paths are absolute; take them from summer_get_runtime_tree.
Guide: summer_docs_read {"id":"tool/inspect-runtime-node"}

Input parameters:

- `maxCharacters` (integer): Most characters of text to return (default 4000). A longer result is cut and says so.
- `path` (string, required): Runtime node path, e.g. '/root/Main/Player'. Get it from summer_get_runtime_tree.

### `summer_test_placement` (~278 tokens)

Test a placement without moving

Test one 3D node at a candidate world position and rotation without moving it: overlaps, grounded state and the gap to the floor. Changes nothing. Then place it with summer_set_prop or summer_snap_to_surface.
Guide: summer_docs_read {"id":"tool/test-placement"}

Input parameters:

- `candidateGlobalPosition` (array, required): Candidate global/world position as [x, y, z].
- `candidateGlobalRotationDegrees` (array, required): Candidate global/world Euler rotation in degrees as [x, y, z]; current global scale is preserved.
- `collideWithAreas` (boolean): Include Area3D objects as placement obstacles/support candidates.
- `collisionMask` (integer): Godot 3D physics layers included in overlap and floor queries.
- `groundTolerance` (number): Absolute floor-gap tolerance used to classify grounded support.
- `margin` (number): Physics shape-intersection margin; only an exact physics support collider+shape contact is excluded from overlaps.
- `maxFloorDistance` (number): Maximum world-space distance searched below the candidate footprint; range 0.001..1000.
- `scenePath` (string, required): Exact scene path containing the subject, e.g. 'res://levels/workshop.tscn'.
- `subjectPath` (string, required): Exact node path relative to the scene root, e.g. './World/Crate'.

### `summer_snap_to_surface` (~212 tokens)

Snap a node onto a surface

Move one 3D node along a ray until it sits at the given gap on the first surface (floor, ramp, shelf, table), then save the scene. Returns before and after transforms and the evidence.
Guide: summer_docs_read {"id":"tool/snap-to-surface"}

Input parameters:

- `alignUp` (boolean): Rotate the subject's current world up toward an exact physics contact normal before seating it.
- `direction` (array): Finite world-space cast direction [x,y,z] whose squared length exceeds 0.00001. Defaults downward.
- `gap` (number): Requested separation from the support surface; must not exceed maxDistance.
- `maxDistance` (number): Maximum cast and overlap-recovery distance in scene units.
- `scenePath` (string, required): Exact scene containing the subject, e.g. 'res://levels/market.tscn'
- `subjectPath` (string, required): Exact Node3D path relative to the scene root, e.g. './Props/Crate'

### `summer_align_distribute_3d` (~159 tokens)

Align or space 3D nodes

Align 2 to 16 3D nodes on one world axis (min, center, max) or space them equally (centers or gaps) from their visible bounds, then save the scene. One undo step.
Guide: summer_docs_read {"id":"tool/align-distribute-3d"}

Input parameters:

- `axis` (array, required): Finite, non-zero world axis [x,y,z]; normalization is automatic.
- `mode` (string, required): Alignment anchor or equal-spacing policy.
- `scenePath` (string, required): Exact target scene, e.g. 'res://levels/market.tscn'.
- `subjectPaths` (array, required): Two to sixteen exact nonduplicate Node3D paths in the order to align or distribute.

### `summer_navigation_probe` (~156 tokens)

Check a navigation route

Check whether two world points are connected on the scene's navigation map: readiness, snapped end points, route length and route points. ready false means no evidence, not no route.
Guide: summer_docs_read {"id":"tool/navigation-probe"}

Input parameters:

- `end` (array, required): Requested world-space route destination [x,y,z].
- `navigationLayers` (integer): Godot navigation-layer bitmask; only enabled matching regions are used.
- `optimize` (boolean): Use Godot's corridor-funnel path post-processing; false uses edge-centered points.
- `scenePath` (string, required): Exact 3D scene whose World3D navigation map should be queried.
- `start` (array, required): Requested world-space route start [x,y,z].

### `summer_starcast` (~365 tokens)

Read the space around a node

Read the clearance around one 3D node in 26 directions: what blocks each side and how far, contact, grounding and nearby objects. Changes nothing. Use it before and after placing.
Guide: summer_docs_read {"id":"tool/starcast"}

Input parameters:

- `collideWithAreas` (boolean): Include Area3D objects as well as physics bodies.
- `collisionMask` (integer): Godot 3D physics layer mask queried by rays, shape contacts/overlaps, and nearby-collider scans.
- `detail` (string): summary: compact placement report (at most 5 KB). full: adds bounded hit geometry, an objects table, and nearby lists (at most 12 KB; the engine downgrades to summary rather than exceed it).
- `directionSpace` (string): Cast along world axes, or along the subject's orthonormalized local axes when 'front', 'side', or 'up' mean the rotated subject's own orientation.
- `margin` (number): Tolerance for exact-geometry physics shape intersection queries; touching and candidates within this margin are reported as contact_or_overlap.
- `maxDistance` (number): Maximum outward cast distance in scene units.
- `maxHitsPerDirection` (integer): Maximum physics hits and visual AABB hits retained for each direction.
- `maxResults` (integer): Maximum retained contact/overlap and nearby entries per evidence channel.
- `nearbyRadius` (number): Maximum gap from the subject bounds for the nearby-object lists (full detail).
- `path` (string, required): Exact Node3D path relative to the scene root, e.g. './World/Crate'.
- `scenePath` (string, required): Exact scene containing the subject, e.g. 'res://levels/level1.tscn'.

### `summer_inspect_asset` (~251 tokens)

Measure a 3D asset file

Measure a 3D asset file without placing it: bounds, origin, meshes, largest flat faces, open pipe ends, Marker3D anchors and collision shapes. Measure each kit piece once before placing it. Next: summer_instantiate_scene.
Guide: summer_docs_read {"id":"tool/inspect-asset"}

Input parameters:

- `detail` (string): summary (default): open_loops lists only port-like loops (radius over 2 cm with a partner loop facing another way, or the one opening of an end piece on its bounding-box face), or none. full: every…
- `maxCharacters` (integer): Most characters of text to return (default 4000). A longer result is cut and says so.
- `maxTriangles` (integer): Triangle budget (100-300000) for the face and open-loop analysis (AABBs and counts are always complete). summary.warnings says when the budget cut the analysis and which budget covers the whole mesh.
- `path` (string, required): Asset to measure, e.g. 'res://kit/facade/wall_single_01.tscn'. It is loaded and instanced off-scene, never added to an open scene.

### `summer_place_adjacent` (~323 tokens)

Place a node against another

Move one node so its bounds face sits against another node's, lining up the other axes: modules edge to edge, storeys stacked. Saves the scene and verifies the gap.
Guide: summer_docs_read {"id":"tool/place-adjacent"}

Input parameters:

- `alignOtherAxes`: How to line up the other two axes: min, center, max or none (keep). One mode for both, or per axis, e.g. {y: 'min', z: 'max'} for same base height and one front plane.
- `axis` (string, required): Axis along which the two pieces meet (x, y or z of the chosen space).
- `gap` (number): Distance between the two faces along axis. 0 = flush; negative = overlap (inset).
- `reference` (string, required): Node that stays put: exact node path relative to the scene root, e.g. './Facade/Wall_01'.
- `scenePath` (string, required): Exact scene to read or change, e.g. 'res://levels/street.tscn'. It must be open in the editor (any tab).
- `side` (string, required): max: subject goes on the reference's +axis side (its min face against the reference's max face). min: the -axis side.
- `space` (string): world: world axes. local: the reference's own axes, for a rotated facade.
- `subject` (string, required): Node to move: exact node path relative to the scene root, e.g. './Facade/Wall_01'.

### `summer_attach_to_surface` (~456 tokens)

Mount a piece on a surface

Turn a piece so its measured back faces a wall, ceiling or floor found by a ray, keep it upright and seat it at a standoff: pipes, lamps, signs. Saves the scene; a refused seat puts the piece back.
Guide: summer_docs_read {"id":"tool/attach-to-surface"}

Input parameters:

- `backAxis` (string): The subject's LOCAL axis that must face into the surface, e.g. '-z' for a piece whose back is -Z. Measure it first with summer_inspect_asset.
- `collisionMask` (integer): Godot 3D physics layer mask for physics queries.
- `maxDistance` (number): Maximum ray length when looking for the surface.
- `maxMove` (number): Refuse, changing nothing, when the piece would end farther than this from where it starts (scene units). Place the piece near its mount first; raise this only for a deliberate long move.
- `placeAt` (string): current (default): the piece keeps its height and its place along the surface and only moves along the surface normal, so its measured back face ends at standoff from the surface. hit: it also slides…
- `ray` (object): Explicit ray that finds the surface plane and its normal. Pass this or surface (or both).
- `scenePath` (string, required): Exact scene to read or change, e.g. 'res://levels/street.tscn'. It must be open in the editor (any tab).
- `standoff` (number): Gap between the subject's back face and the surface, in scene units.
- `subject` (string, required): Piece to mount: exact node path relative to the scene root, e.g. './Facade/Wall_01'.
- `surface` (string): Surface node (wall, ceiling, floor). Without ray, the ray runs from the subject's origin to the nearest point of this node's bounds; with ray, hits on other nodes are skipped.
- `upAxis` (string): The subject's LOCAL axis kept closest to worldUp. Must not be on the same line as backAxis.
- `worldUp` (array): World direction the upAxis should follow (projected onto the surface).

### `summer_repeat_along` (~353 tokens)

Repeat a scene along a line

Place copies of one scene along a line in one call: fence posts, clamps, a row of windows (at most 64). Returns the created node paths and saves the scene once.
Guide: summer_docs_read {"id":"tool/repeat-along"}

Input parameters:

- `align` (string): With end + spacing: where the leftover length goes. start = first copy at start; center = leftover split; end = last copy at end.
- `count` (integer): Number of copies (1-64).
- `direction` (array): Instead of end: direction of the row; needs count and spacing.
- `end` (array): Line end. With spacing: as many copies as fit; with count: count copies spread from start to end.
- `namePrefix` (string): Copies are named <namePrefix>_<n> (default: the template file name).
- `parent` (string, required): Parent for the copies; start/end/direction are in this parent's local space (same as position).
- `rotationDegrees` (array): rotation_degrees for every copy [x, y, z].
- `scale` (array): scale for every copy [x, y, z].
- `scenePath` (string, required): Exact scene to read or change, e.g. 'res://levels/street.tscn'. It must be open in the editor (any tab).
- `spacing` (number): Distance between neighbouring copies' origins.
- `start` (array, required): First copy's position [x, y, z] in the parent's space.
- `template` (string, required): Scene to instance for every copy, e.g. 'res://kit/pipes/wall_clamp_a.tscn'.

### `summer_connect_ports` (~473 tokens)

Join two pieces at their ports

Move and turn one piece so its port (a Marker3D, or an open pipe end such as +Y) meets another piece's port: pipe to pipe, duct to duct. Refuses joins that tilt the piece. Saves the scene.
Guide: summer_docs_read {"id":"tool/connect-ports"}

Input parameters:

- `allowTilt` (boolean): true: join even when the subject tilts more than maxTiltDegrees (a bend laid on its side, a sloped run). The receipt still reports tilt_degrees.
- `gap` (number): Distance between the two ports along the target port's direction. 0 = touching.
- `maxTiltDegrees` (number): Refuse the join, changing nothing, when it would tilt the subject's up axis (its local +Y) more than this many degrees from where it points now (default 5). Turning about the up axis is never tilt.
- `maxTriangles` (integer): Triangle budget (100-300000) per node when ports are open-loop ids or indices.
- `rollDegrees` (number): Extra turn of the subject, in degrees, about the joined port axis, applied after the ports are lined up.
- `scenePath` (string, required): Exact scene to read or change, e.g. 'res://levels/street.tscn'. It must be open in the editor (any tab).
- `subject` (string, required): Piece to move: exact node path relative to the scene root, e.g. './Facade/Wall_01'.
- `subjectPort` (required): Port on the subject: an open-loop id from summer_inspect_asset on that node's scene, e.g. '+Y' (the outermost open loop facing +Y in the piece's own axes) or '+Y#2' (the next one facing +Y); or a…
- `target` (string, required): Piece that stays put: exact node path relative to the scene root, e.g. './Facade/Wall_01'.
- `targetPort` (required): Port on the target: an open-loop id from summer_inspect_asset on that node's scene, e.g. '+Y' (the outermost open loop facing +Y in the piece's own axes) or '+Y#2' (the next one facing +Y); or a…

### `summer_raycast` (~251 tokens)

Cast a ray in a scene

Cast one ray from any point in a scene: the node it hits, the point and the normal. Physics first, visible bounds as a declared fallback. Changes nothing.
Guide: summer_docs_read {"id":"tool/raycast"}

Input parameters:

- `collideWithAreas` (boolean): Also hit Area3D volumes (physics only).
- `collisionMask` (integer): Godot 3D physics layer mask for physics queries.
- `direction` (array, required): Ray direction [x, y, z]; normalized for you.
- `evidence` (string): auto: physics first, visual AABB fallback when physics finds nothing (declared). physics or visual_aabb: that channel only.
- `exclude` (array): Nodes (with their descendants) the ray ignores, e.g. the piece you are about to move.
- `maxDistance` (number): Maximum ray length in scene units.
- `origin` (array, required): Ray start in scene (world) space [x, y, z]. Nothing needs to be placed there.
- `scenePath` (string, required): Exact scene to read or change, e.g. 'res://levels/street.tscn'. It must be open in the editor (any tab).

### `summer_measure` (~343 tokens)

Measure between nodes

Measure the gap or overlap on each axis between two placed nodes, or check that one face of many nodes lies on one plane. Finds facade gaps and modules that stand out. Changes nothing.
Guide: summer_docs_read {"id":"tool/measure"}

Input parameters:

- `a` (string): pair mode, first node: exact node path relative to the scene root, e.g. './Facade/Wall_01'.
- `axis` (string): pair mode: report only this axis (x, y or z of the chosen space).
- `b` (string): pair mode, second node: exact node path relative to the scene root, e.g. './Facade/Wall_01'.
- `face` (string): plane mode: which face, e.g. '+z' for the face pointing along +z (a facade front that looks toward +z).
- `mode` (string): pair: gap or overlap per axis between nodes a and b. plane: whether one face of every node in `nodes` lies on one plane.
- `nodes` (array): plane mode: 2-32 nodes whose face is checked, e.g. every module of one facade line.
- `scenePath` (string, required): Exact scene to read or change, e.g. 'res://levels/street.tscn'. It must be open in the editor (any tab).
- `space` (string): world: world axes. local: the axes of a (pair) or nodes[0] (plane), for rotated facades.
- `tolerance` (number): Distance in scene units treated as touching (pair) or coplanar (plane). Default 5 mm.

### `summer_wait_for_event` (~239 tokens)

Wait for an engine event

Wait for an engine event (game started, op applied or failed, script error, scene saved) instead of sleeping; it says so honestly at the timeout. Take a cursor with summer_recent_events first.
Guide: summer_docs_read {"id":"tool/wait-for-event"}

Input parameters:

- `kinds` (array): Event kinds to deliver (default: all). v1 kinds: op.applied, op.failed, script.error, play.started, play.stopped, scene.saved, scene.opened, import.completed, selection.changed, snapshot.published.
- `match` (object): Extra client-side filters applied after the kinds filter.
- `max_events` (integer): Maximum matched events to return (default 20, cap 500).
- `since` (integer): Deliver events with seq > since. Omit = live from now (an event that already fired is NOT delivered — take a cursor with summer_recent_events first and pass its next_seq here).
- `timeout_seconds` (number): How long to wait for a match (default 30, clamped 1-120). The call long-polls in slices of at most 25 s.

### `summer_recent_events` (~176 tokens)

Read recent engine events

Read the newest engine events (saves, plays, op results, script errors, imports) at once, and next_seq, the cursor to pass to summer_wait_for_event.
Guide: summer_docs_read {"id":"tool/recent-events"}

Input parameters:

- `kinds` (array): Event kinds to deliver (default: all). v1 kinds: op.applied, op.failed, script.error, play.started, play.stopped, scene.saved, scene.opened, import.completed, selection.changed, snapshot.published.
- `limit` (integer): Maximum events to return (default 50, cap 200).
- `since` (integer): Deliver events with seq > since. Omit = the newest `limit` sequence numbers. 0 = the whole retained ring from the oldest (paged: pass next_seq back while truncated is true).

### `summer_fabricate_3d` (~436 tokens)

Make a mesh with Blender

Make a mesh with a bpy script in the person's own Blender (4.2 or newer, headless), import the .glb into the project and optionally place it. For exact modular kits and effect meshes, not characters or props.
Guide: summer_docs_read {"id":"tool/fabricate-3d"}

Input parameters:

- `blender_path` (string): Explicit Blender executable. Pass only when the user named one; otherwise the engine resolves SUMMER_BLENDER_BIN, the editor setting filesystem/import/blender/blender_path, then PATH and well-known…
- `checkpoint` (boolean): Take a SummerGit checkpoint before the child runs (default false). The result confesses (no_rewind_point) when none could be taken.
- `import_to_scene` (object): Instantiate the imported .glb into the currently open scene after import (one undo action). Omit to only write and import the file.
- `max_seconds` (number): Child budget in seconds (default 120, clamped 15-600): Blender boot + script + procedural-colour bakes + export. Raise it for heavy booleans or bakes; the client waits max_seconds + 60 s.
- `name` (string, required): Asset name — used for the default out_path (res://assets/fabricated/<name>.glb) and for the instantiated node. Sanitized by the engine to [A-Za-z0-9_-].
- `out_path` (string): Destination res:// path ending in .glb (default res://assets/fabricated/<name>.glb). An existing file is overwritten; '..' and hidden directories are refused.
- `source` (string, required): Blender Python (bpy) code that CREATES mesh objects and leaves them linked in the scene. Do not export — the engine exports the .glb for you.
- `target_size` (number): Largest world-AABB dimension in units after instantiation — uniform scale, same rule as summer_instantiate_scene target_size (chair 1.0, car 4.5). Only used together with import_to_scene.

### `summer_ui_tree` (~206 tokens)

Read the editor UI

Read the live editor UI as a tree (controls, paths, text, state), or every visible dialog and whether one blocks input. Its paths are what summer_ui_activate takes.
Guide: summer_docs_read {"id":"tool/ui-tree"}

Input parameters:

- `depth` (integer): Tree depth (engine default 4, max 32). Plain Nodes between Controls do not consume depth.
- `limit` (integer): Maximum Control nodes emitted (engine default 500, max 5000). The result carries truncated + child_count so a cut is visible.
- `root` (string): Where to start. 'main' (default) = the whole editor chrome; 'window' = the SceneTree root incl. every sub-window; 'dock:<title|id>' = one dock (ids file_system | scene_tree | inspector, or any dock…
- `visible_only` (boolean): Default true. false also emits hidden controls — readable, but summer_ui_activate refuses them with not_visible.

### `summer_ui_activate` (~347 tokens)

Use an editor control

Use one editor control by its tree path (press, toggle, focus, select a tab, type text, set a value) or dismiss a dialog; the control's state is read back. Only when no named action fits.
Guide: summer_docs_read {"id":"tool/ui-activate"}

Input parameters:

- `action` (string): Default 'press'. press = synthetic left click on a button / ItemList item / PopupMenu item (index); toggle = flip a toggle-mode button; focus = grab_focus on any control; select_tab =…
- `button` (string): dismiss_dialog only. 'cancel' (default — the safe close: cancel button / hide / OS close request), 'ok', or the exact text of a button in the dialog's row.
- `index` (integer): select_tab: tab index; press on an ItemList / PopupMenu: item index.
- `path` (string): A control `path` from summer_ui_tree (required for every action except dismiss_dialog, which may use title instead), or 'main_screen' with action:'select_tab'.
- `submit` (boolean): set_text on a LineEdit only: also emit text_submitted (the Enter key), e.g. to run a search box.
- `title` (string): dismiss_dialog only: a visible window title (case-insensitive; exact wins, one substring match accepted, otherwise ambiguous_dialog) — from summer_ui_tree root:'dialogs'.
- `value`: select_tab: tab title (or the main-screen editor name: '2D', '3D', 'Script', 'Game', 'AssetLib'); set_text: the text; set_value: the number.

### `summer_ui_screenshot` (~151 tokens)

Screenshot the editor UI

Return an image of the editor window, or of one dock, dialog or control: the last resort to look at the UI, never to pick click points. For scene views use summer_screenshot.
Guide: summer_docs_read {"id":"tool/ui-screenshot"}

Input parameters:

- `max_size` (integer): Longest edge in pixels after downscale (engine default 1024, clamped 16-4096). Smaller is cheaper to look at; the result reports scale.
- `root` (string): Same grammar as summer_ui_tree root — 'window' (default; the whole editor window), 'main', 'dock:<title|id>', 'dialog:<title>', 'path:<node path>'.

### `summer_runtime_set` (~234 tokens)

Set a property in the running game

Set one property on a node in the RUNNING game (the live object, never the scene file) and read back whether it applied: move the player, set health, flip a flag. Then check with summer_game_probe.
Guide: summer_docs_read {"id":"tool/runtime-set"}

Input parameters:

- `field` (string): Optional sub-field to set instead of the whole value, e.g. 'x' on a Vector3 property.
- `instance` (string): Game instance to address (default 'main' = the editor's embedded game).
- `path` (string, required): ABSOLUTE runtime node path, e.g. '/root/Main/Player' (from summer_game_probe tree).
- `property` (string, required): Property name, e.g. 'position', 'health', 'visible'. 'script' and 'owner' are refused.
- `value` (required): New value. JSON scalars for primitives; Godot literal strings for math types ('Vector3(1, 2, 3)', 'Color(1, 0, 0, 1)', 'Vector2(10, 0)').

### `summer_runtime_call` (~180 tokens)

Call a method in the running game

Call one method on a node in the RUNNING game and return its result, to trigger gameplay code directly. A call is an action, not proof: check what it did with summer_game_probe.
Guide: summer_docs_read {"id":"tool/runtime-call"}

Input parameters:

- `args` (array): Positional arguments. JSON scalars, arrays and objects pass as-is; math values as Godot literal strings ('Vector3(0, 1, 0)'). Object and RID arguments are refused (bad_args).
- `instance` (string): Game instance to address (default 'main' = the editor's embedded game).
- `method` (string, required): Method name to call on the node, e.g. 'take_damage', 'get_velocity'.
- `path` (string, required): ABSOLUTE runtime node path, e.g. '/root/Main/Player'.

### `summer_runtime_spawn` (~315 tokens)

Spawn or free in the running game

Spawn a scene into the RUNNING game (action spawn) or free a live node (action free) to set up a test. The scene file is not touched. Then check with summer_game_probe.
Guide: summer_docs_read {"id":"tool/runtime-spawn"}

Input parameters:

- `action` (string, required): 'spawn' instantiates a PackedScene under parent (SpawnRuntimeScene); 'free' removes a node (FreeRuntimeNode).
- `instance` (string): Game instance to address (default 'main' = the editor's embedded game).
- `mode` (string): action:'free' — 'queue_free' (default, safe: frees at the end of the frame) or 'free' (immediate).
- `name` (string): action:'spawn' — node name; the engine renames on collision and reports renamed_to.
- `parent` (string): action:'spawn' — ABSOLUTE runtime path of the parent, e.g. '/root/Main/Enemies'.
- `path` (string): action:'free' — ABSOLUTE runtime path of the node to free.
- `props` (object): action:'spawn' — properties set on the new node before it enters the tree ({position: 'Vector3(0, 1, 0)', health: 50}). Unknown ones land in prop_warnings, never fail the spawn.
- `scene` (string): action:'spawn' — PackedScene to instantiate, e.g. 'res://enemies/goblin.tscn'.

### `summer_runtime_animate` (~539 tokens)

Drive animation in the running game

Read and drive animation in the RUNNING game: AnimationPlayer clips, AnimationTree states and Skeleton3D bone poses. cmd state only reads. Prove motion with two reads around summer_game_control step.
Guide: summer_docs_read {"id":"tool/runtime-animate"}

Input parameters:

- `blend` (number): target:'player' play — custom blend time in seconds.
- `bones` (array): target:'bones' — bone names to read (omit for the first 256; page larger rigs with this filter).
- `cmd` (string): Default 'state' (read-only). target:'player': state|play|pause|stop|seek|speed. target:'tree': state|travel|start|stop|set_param|get_param. Ignored for target:'bones'.
- `from_end` (boolean): target:'player' play — start from the end (backwards).
- `include_rest` (boolean): target:'bones' — also return each bone's rest Transform3D.
- `instance` (string): Game instance to address (default 'main' = the editor's embedded game).
- `name` (string): target:'player' play — clip name (unknown_animation lists the clips).
- `param` (string): target:'tree' set_param/get_param — parameter path, e.g. 'parameters/Blend/blend_amount'.
- `path` (string, required): ABSOLUTE runtime path of the AnimationPlayer / AnimationTree / Skeleton3D.
- `playback_path` (string): target:'tree' — state machine playback parameter (default 'parameters/playback'; nested machines use 'parameters/<Node>/playback').
- `position` (number): target:'player' seek — position in seconds.
- `reset` (boolean): target:'tree' travel/start — reset the destination clip (default true).
- `space` (string): target:'bones' — 'global' (default, skeleton-space global_pose), 'local' (pose), or 'both'.
- `speed` (number): target:'player' speed — speed_scale (1.0 = normal, negative plays backwards).
- `state` (string): target:'tree' travel/start — state machine node name (unknown_state lists them).
- `target` (string, required): 'player' = AnimationPlayer (RuntimeAnimation), 'tree' = AnimationTree state machine (RuntimeAnimationTree), 'bones' = Skeleton3D poses (GetRuntimeBones).
- `update` (boolean): target:'player' seek — apply the pose immediately (default true).
- `value`: target:'tree' set_param — new value (JSON scalar or Godot literal string).

### `summer_game_control` (~229 tokens)

Control the game clock

Pause or resume the RUNNING game, step exactly N frames, set the time scale, or list the live game instances. Step between two summer_game_probe reads for exact checks.
Guide: summer_docs_read {"id":"tool/game-control"}

Input parameters:

- `action` (string, required): 'pause' suspends the game (Engine time frozen, physics inactive); 'resume' lifts the suspension; 'step' advances exactly N frames and leaves the game suspended; 'speed' sets the user time scale;…
- `frames` (integer): action:'step' — frames to advance, 1..600 (default 1).
- `instance` (string): Game instance to address (default 'main' = the editor's embedded game).
- `kind` (string): action:'step' — 'physics' (default: exact physics ticks, max_physics_steps_per_frame pinned to 1) or 'process' (rendered frames).
- `speed` (number): action:'speed' — user time scale in (0, 100]: 0.25 = quarter speed, 2 = double.

### `summer_game_input` (~396 tokens)

Send input to the running game

Drive the RUNNING game's input: a script of timed actions, keys and clicks, or record real input and replay it on a seeded instance. Input is an action: prove its effect with summer_game_probe.
Guide: summer_docs_read {"id":"tool/game-input"}

Input parameters:

- `action` (string, required): 'script' schedules a timed sequence of synthetic inputs (SimulateInputScript); 'record_start'/'record_stop' capture the game's real input into res://.summer/replays/<id>.json; 'replay' plays a…
- `clock` (string): action:'script' — whether at_frame ('frame', default, exact) or at_ms ('ms') schedules the events.
- `events` (array): action:'script' (required) or 'replay' (instead of recording) — up to 1000 timed events; last event within 36000 frames / 600 s.
- `include_motion` (boolean): action:'record_start' — also record mouse/joypad motion events (default false; large).
- `instance` (string): Game instance to address (default 'main' = the editor's embedded game).
- `recording` (string): action:'replay' — the res://.summer/replays/<id>.json path returned by record_stop.
- `save_as` (string): action:'record_stop' — res://.summer/replays/<name>.json to write instead of a generated id.
- `seed` (integer): action:'replay' — assert the replay is reproducible; only accepted on an instance started with summer_play {mode:'offscreen', deterministic:true} (else nondeterministic_instance).
- `wait` (boolean): action:'script'|'replay' — wait for the last event to fire (default true; the engine caps a waited script at 20 s). Scripts longer than that: wait:false and observe with summer_game_probe.

### `summer_game_probe` (~230 tokens)

Probe the running game

Read state and pixels of one frame of the RUNNING game together: the live tree, property values and a screenshot stamped with the same frame numbers. The evidence read of a playtest.
Guide: summer_docs_read {"id":"tool/game-probe"}

Input parameters:

- `instance` (string): Game instance to address (default 'main' = the editor's embedded game).
- `max_dim` (integer): Longest image side in pixels, 16..4096 (default 1280); the frame is downscaled to fit.
- `props` (array): Up to 64 '<absolute path>:<property>' keys read on the same frame, e.g. '/root/Main/Player:position'. Values come back as Godot literal strings; misses land in `missing`.
- `screenshot` (boolean): Capture the game viewport (default true). false = state only, cheaper and works when the window draws nothing.
- `tree` (object): Include the live scene tree ({name, class, path, children}) built game-side on the SAME frame as the pixels. Omit for no tree.

### `summer_enable_plugin` (~125 tokens)

Enable an editor plugin

Enable an editor plugin in res://addons/<name>/ and return the real result: enabled with its autoloads, or why it failed. Older engines only queue it (queued true); then check summer_get_debugger_errors.
Guide: summer_docs_read {"id":"tool/enable-plugin"}

Input parameters:

- `plugin` (string, required): The plugin folder under res://addons/ (e.g. 'quest_tools') or its 'res://addons/<name>/plugin.cfg'
- `timeoutMs` (integer): How long the engine waits for the plugin to load (default 30000)

### `summer_docs_search` (~413 tokens)

Search the Summer library — skills, tools, templates, references, examples, collections — by describing the task in plain words ('make stylized water', 'the player falls through the floor', 'which tool reads script errors'). This is the FIRST MOVE for any task: even a 1% chance the library covers it means you search, then read the entry you pick with summer_docs_read before acting — never act on a summary alone. Ranking: BM25 over ids, summaries, use_when lines and facets with kind-aware priors and related-entry boosts (the same ranker the routing eval gates). When this install ships registry/generated/embeddings.json and the embedding endpoint answers within 1.5s, lexical and semantic rankings are fused (reciprocal rank fusion) and each hit's matched_by says which side found it; offline or without embeddings it is lexical only and never fails for that reason. Returns {query, semantic, count, results: [{id, kind, status, summary, use_when, score, matched_by, mcp_tool_name?}], hint}. Scores compare only within one response. kinds narrows to some of the six kinds; include_preview:false hides preview entries; deprecated entries never surface. No engine needed. Privacy: only when semantic search is active is the query text sent to the Summer gateway to be embedded; nothing else leaves the machine.

Input parameters:

- `include_preview` (boolean): Include status: preview entries — not yet exercised in-engine by the Summer team (default true). false = stable only.
- `kinds` (array): Restrict to these kinds (tool, skill, example, template, collection, reference). Omit for all kinds.
- `limit` (integer): Maximum results, 1-20 (default 8).
- `query` (string, required): The task in plain words — what you are building, fixing, or looking for (e.g. 'make stylized water', 'the player falls through the floor', 'which tool reads script errors').

### `summer_docs_read` (~539 tokens)

Load one library entry by id (<kind>/<slug>, as returned by summer_docs_search). Skills: the SKILL.md body plus metadata (status, use_when, related) and how to invoke the skill in your host (bare slug). Tools: how to call it (MCP name, `summer tool <slug> --args`, engine requirement, authority) plus the descriptor. Templates: the pinned repo @ commit and tree digest (or built-in) and the `summer create <slug>` command. References: the markdown body. Hosted skills (publish-your-game, store-listing, store-art, grow-analytics; also by their summer://skills/<slug> URI): the current text from the hosted Summer Engine MCP with the store sign-in, else the local summary plus why and how to load the rest. Linked files: a body ends with its relative links and the id that loads each; a file an entry links loads by <entry id>/<link as written> (e.g. skill/spatial-placement/references/kit-placement-tools.md), by the relative path alone when one entry ships it, inside library/ only. part: 'skill' = body only, 'resource' = the resource.yaml descriptor only, 'all' (default) = both. The LAST line of every load is the feedback footer `— entry_id: <id>@<content-hash>. If this entry is wrong, stale, or you deviate from it, report via summer_call {"op":"docs.feedback"}.` — copy that entry_id verbatim into summer_call {"op":"docs.feedback"} once you have verified the outcome in-engine. Unknown id -> {ok:false, error:'not_found', nearest:[up to 3 ids]}. No engine needed; reads the library shipped with this package.

Input parameters:

- `id` (string, required): The entry id as returned by summer_docs_search: <kind>/<slug>, e.g. skill/vfx-water-ripple or tool/screenshot. A file an entry links loads by <entry id>/<link as written>, e.g. skill/spatial-placemen…
- `maxCharacters` (integer): Most characters of text to return (default 24000). A longer result is cut and says so.
- `part` (string): 'skill' = the body only (SKILL.md for skills; the markdown body for references; how-to-call for tools; the pin for templates). 'resource' = the resource.yaml descriptor only. 'all' (default) = both.

### `summer_engine_list_camera_bookmarks` (~61 tokens)

List camera bookmarks

List the camera viewpoints saved in this project: names, poses and dates. A bookmark gives screenshots that line up before and after a change: summer_screenshot with framing bookmark.
Guide: summer_docs_read {"id":"tool/camera-bookmark"}

### `summer_engine_save_camera_bookmark` (~243 tokens)

Save a camera bookmark

Save a named camera viewpoint in the project (res://.summer/camera_bookmarks.json): position and look_at as Vector3 literals, or neither to take the editor's 3D camera. The scene file is not touched. Next: summer_screenshot.
Guide: summer_docs_read {"id":"tool/camera-bookmark"}

Input parameters:

- `fov` (number): save only. Vertical field of view in degrees (1..179, default 60). With a captured viewport pose the viewport camera's fov wins.
- `look_at` (string): save only. Point the camera looks at, e.g. "Vector3(0, 1, 0)". Must differ from position.
- `name` (string, required): Bookmark name for save/delete: 1-64 characters from A-Z a-z 0-9 _ - (e.g. "hero_closeup").
- `position` (string): save only. Camera position as a Godot literal, e.g. "Vector3(0, 5, 12)". Goes together with look_at; omit BOTH to capture the current editor 3D viewport camera.

### `summer_engine_delete_camera_bookmark` (~77 tokens)

Delete a camera bookmark

Delete one saved camera viewpoint by name. Returns the names that remain.
Guide: summer_docs_read {"id":"tool/camera-bookmark"}

Input parameters:

- `name` (string, required): Bookmark name for save/delete: 1-64 characters from A-Z a-z 0-9 _ - (e.g. "hero_closeup").

### `summer_engine_list_ui_actions` (~141 tokens)

List editor actions

List the editor's named actions (menu items and shortcuts) with labels and shortcuts, filtered by text. Actions marked denied are refused. Next: summer_engine_invoke_ui_action.
Guide: summer_docs_read {"id":"tool/ui-actions"}

Input parameters:

- `filter` (string): mode:'list' only. Case-insensitive substring over action name and label, e.g. 'project_settings', 'save', 'spatial_editor', 'bottom_panel'.
- `limit` (integer): mode:'list' only. Maximum actions returned (engine default 200, max 2000). The result carries total + truncated — never assume a capped list is complete.

### `summer_engine_invoke_ui_action` (~122 tokens)

Run an editor action

Run one named editor action exactly as its menu item or shortcut would: open Project Settings, switch the main screen, toggle a panel. Editor work only; scene work is summer_run_script. Read the effect back with summer_ui_tree.
Guide: summer_docs_read {"id":"tool/ui-actions"}

Input parameters:

- `action_name` (string, required): mode:'invoke' only (required there). The exact action name from a 'list' result — the stable shortcut path such as 'editor/project_settings', 'editor/save_scene', 'spatial_editor/focus_selection'.

### `summer_search` (~114 tokens)

Find any Summer operation by describing the job in plain words: engine, assets, store, pricing, analytics and the rest. Returns the best matches with their exact input schema, effect and approval. Next: summer_call with the name.

Input parameters:

- `area` (string): Only this area: engine, assets, store, pricing, analytics...
- `limit` (integer): Most results (default 5).
- `query` (string, required): The job in plain words: "lower my game's price", "add a light to the scene".

### `summer_call` (~158 tokens)

Run any Summer operation by name (from summer_search) with its input. Engine operations run here; cloud ones run on Summer's server with the same approvals: money, publishing and live changes answer needs_approval with a link. 3.x tool names work too.

Input parameters:

- `dryRun` (boolean): Check and describe the call without doing it.
- `idempotencyKey` (string): Retry key for writes; reuse it only to retry the identical call.
- `input` (object): The operation's input, matching the schema summer_search returned.
- `name` (string): Same as op.
- `op` (string): The operation name, e.g. engine.add_node or pricing.set_base (or a 3.x tool name).

### `summer_store_tools` (~64 tokens)

Load the hosted Summer tools

The Summer store, publishing, board and Grow tools come from the hosted Summer Engine MCP and are not loaded. Call this to see why and how to fix it (usually: run "summer login --store" in a terminal); it loads them when the sign-in works.

## Diagnostics

Captured diagnostic sections: Provenance, Vulnerabilities, Dependencies. The full working is on the page: https://verifymcp.io/servers/summerengine-summer/summer-engine#diagnostics

## Score history

- 2026-11-05: 75
- 2026-11-04: 74
- 2026-11-03: 74
- 2026-11-02: 73
- 2026-11-01: 73
- 2026-10-31: 72
- 2026-10-30: 72
- 2026-10-29: 71
- 2026-10-28: 71
- 2026-10-27: 71
- 2026-10-26: 70
- 2026-10-25: 70
- 2026-10-24: 69
- 2026-10-23: 74
- 2026-10-22: 73
- 2026-10-21: 73
- 2026-10-20: 57
- 2026-10-19: 70
- 2026-10-18: 70
- 2026-10-17: 70
- 2026-10-16: 60

## Common questions

### What is the Summer Engine MCP server?

Summer Engine is an MCP server listed in the public MCP registry as io.github.SummerEngine/summer. The game engine built for AI. Any agent makes a multiplayer game and publishes it. This page covers its npm package (summer-engine).

### Is the Summer Engine MCP server safe to use?

Summer Engine scores 75 out of 100 on VerifyMCP. We recorded 1 known advisory against it as of 5 November 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Summer Engine MCP server expose?

Summer Engine exposes 93 tools: summer_create_scene, summer_add_node, summer_set_prop, summer_set_resource_property, summer_remove_node, and 88 more. Their descriptions and schemas cost roughly 21,136 tokens of context every time the server is loaded.

### Is the Summer Engine MCP server still maintained?

Summer Engine is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Summer Engine MCP server under?

Summer Engine declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/summer-engine
- Socket report: https://socket.dev/npm/package/summer-engine
- Repository: https://github.com/summerengine/summer
- Website: https://summerengine.com/
- Changelog RSS feed: https://verifymcp.io/servers/summerengine-summer/summer-engine.xml
- Changelog JSON feed: https://verifymcp.io/servers/summerengine-summer/summer-engine.json
- HTML version of this page: https://verifymcp.io/servers/summerengine-summer/summer-engine