summer-engine 2.6.1 → 2.6.5

package/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "summer",
   "version": "2.5.1",
-  "description": "Agent tooling for Summer Engine: game-dev skills, lifecycle hooks, and a 44-tool MCP bridge to the local desktop app.",
+  "description": "Agent tooling for Summer Engine: game-dev skills, lifecycle hooks, and a 52-tool MCP bridge to the local desktop app.",
   "author": {
     "name": "Summer Engine",
     "email": "founders@summerengine.com",

package/.codex-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "summer",
   "version": "2.5.1",
-  "description": "Agent tooling for Summer Engine: game-dev skills, lifecycle hooks, and a 44-tool MCP bridge. Build games by talking.",
+  "description": "Agent tooling for Summer Engine: game-dev skills, lifecycle hooks, and a 52-tool MCP bridge. Build games by talking.",
   "author": {
     "name": "Summer Engine",
     "email": "founders@summerengine.com",
@@ -92,7 +92,7 @@
   "interface": {
     "displayName": "Summer",
     "shortDescription": "Superpowers for AI game dev. Build games by talking.",
-    "longDescription": "Summer turns Codex into a game-dev studio for Summer Engine, the AI-native game engine. It adds game-dev skills, a using-summer workflow skill, lifecycle hooks, and a 44-tool MCP bridge for scene editing, asset import, play mode, diagnostics, and generation. File, git, shell, and grep stay with the host agent. Summer Engine is compatible with Godot 4.5. Write code in GDScript and drive the engine through MCP. Session-start orients the session. Pre-commit doctor (opt-in) blocks bad commits.",
+    "longDescription": "Summer turns Codex into a game-dev studio for Summer Engine, the AI-native game engine. It adds game-dev skills, a using-summer workflow skill, lifecycle hooks, and a 52-tool MCP bridge for scene editing, asset import, play mode, diagnostics, and generation. File, git, shell, and grep stay with the host agent. Summer Engine is compatible with Godot 4.5. Write code in GDScript and drive the engine through MCP. Session-start orients the session. Pre-commit doctor (opt-in) blocks bad commits.",
     "developerName": "Summer Engine",
     "category": "Coding",
     "capabilities": ["Interactive", "Read", "Write"],

package/.cursor-plugin/plugin.json

@@ -3,7 +3,7 @@
   "name": "summer",
   "displayName": "Summer",
   "version": "2.5.1",
-  "description": "Agent tooling for Summer Engine: game-dev skills, lifecycle hooks, and a 44-tool MCP bridge to the local desktop app.",
+  "description": "Agent tooling for Summer Engine: game-dev skills, lifecycle hooks, and a 52-tool MCP bridge to the local desktop app.",
   "author": { "name": "Summer Engine", "email": "founders@summerengine.com" },
   "publisher": "summer-engine",
   "homepage": "https://summerengine.com",

package/.factory-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "summer",
-  "description": "Agent tooling for Summer Engine: game-dev skills, lifecycle hooks, and a 44-tool MCP bridge to the local desktop app.",
+  "description": "Agent tooling for Summer Engine: game-dev skills, lifecycle hooks, and a 52-tool MCP bridge to the local desktop app.",
   "version": "2.5.1",
   "author": {
     "name": "Summer Engine",

package/AGENTS.md

@@ -22,11 +22,12 @@ This file is for any AI agent that loads context from `AGENTS.md` (Codex CLI, Fa
 
 ## MCP tool palette (engine on `localhost:6550`)
 
-44 tools total. Categories:
+52 tools total. Categories:
 
 - Scene: `summer_get_scene_tree`, `summer_open_scene`, `summer_create_scene`, `summer_add_node`, `summer_set_prop`, `summer_set_resource_property`, `summer_remove_node`, `summer_save_scene`, `summer_instantiate_scene`, `summer_replace_node`, `summer_select_node`, `summer_inspect_node`, `summer_inspect_resource`, `summer_connect_signal`, `summer_batch`.
 - Diagnostics: `summer_get_script_errors`, `summer_get_diagnostics`, `summer_get_console`, `summer_clear_console`, `summer_get_debugger_errors`, `summer_get_debugger_warnings`.
 - Runtime: `summer_play`, `summer_stop`, `summer_is_running`.
+- Visual: `summer_screenshot` (capture the editor viewport or running game as an image to verify it).
 - Project: `summer_get_project_context`, `summer_open_main_scene`, `summer_project_setting`, `summer_input_map_bind`, `summer_get_agent_playbook`.
 - Assets: `summer_search_assets`, `summer_list_my_assets`, `summer_get_asset`, `summer_get_asset_download_url`, `summer_import_asset`, `summer_import_asset_by_id`, `summer_import_from_url`, `summer_import_from_url_batch`.
 - Generation: `summer_generate_image`, `summer_generate_3d`, `summer_generate_audio`, `summer_generate_video`, `summer_generate_motion`, `summer_check_job`.

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 All notable changes to summer-engine will be documented here. Following [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and [Semantic Versioning](https://semver.org/).
 
+## [2.6.5] — 2026-07-04 — "Cloud tools don't need the engine"
+
+### Fixed
+- Tool descriptions now say explicitly which tools run in Summer's cloud and work WITHOUT the engine open (`summer_generate_*`, `summer_search_assets`, `summer_list_my_assets`, `summer_get_asset`, `summer_get_asset_download_url`, `summer_check_job`) and which need the engine (imports, scene ops). Agents were misreading a missing `npx summer-engine login` as "MCP requires the engine".
+- The "Summer Engine is not running" error now tells the agent that cloud tools still work without the engine.
+
+## [2.6.4] — 2026-07-03 — "See-Work + project binding" (unpublished, ships with 2.6.5)
+
+### Added
+- MCP session binds to its project; the engine rejects wrong-project writes (`identity_mismatch`) instead of applying them to whatever project is open.
+- Structured per-tool-call stderr logging; agent playbook rewritten around the MCP verification ladder; honest game-capture failure states and identity-stamped reads.
+
+## [2.6.3] — 2026-06-30 — "Agent vision"
+
+### Added
+- `summer_screenshot` MCP tool: capture the editor viewport or the running game as an image the agent sees directly (`target: "viewport" | "game"`, viewport by default). Lets the agent visually verify scene layout, asset placement, scale, framing, and runtime state — the client reads the actual frame, with no description step in between. Total MCP tool surface is now 52.
+
+### Fixed
+- MCP/CLI session now reconnects automatically after a transient engine restart (the engine rotates its api-token and can move its port on relaunch), instead of surfacing as a "disconnected" error.
+
 ## [2.6.0] — 2026-06-10 — "Summer Cloud"
 
 ### Added

package/GEMINI.md

@@ -20,12 +20,13 @@ The single most important skill to know is `summer:using-summer` — it explains
 
 ## MCP tools (when the engine is running on `localhost:6550`)
 
-The `summer-engine` MCP server exposes 44 focused tools. The most important:
+The `summer-engine` MCP server exposes 52 focused tools. The most important:
 
 - **Scene mutation**: `summer_add_node`, `summer_set_prop`, `summer_set_resource_property`, `summer_remove_node`, `summer_save_scene`, `summer_replace_node`, `summer_batch`.
 - **Scene inspection**: `summer_get_scene_tree`, `summer_inspect_node`, `summer_inspect_resource`.
 - **Diagnostics**: `summer_get_script_errors` (cheapest), `summer_get_diagnostics`, `summer_get_console`, `summer_get_debugger_errors`, `summer_get_debugger_warnings`.
 - **Run game**: `summer_play`, `summer_stop`, `summer_is_running`.
+- **Visual**: `summer_screenshot` (capture the viewport or running game as an image you can see).
 - **Project**: `summer_get_project_context`, `summer_open_main_scene`, `summer_project_setting`, `summer_input_map_bind`.
 - **Assets**: `summer_search_assets`, `summer_import_asset`, `summer_import_from_url`, `summer_generate_image`, `summer_generate_3d`, `summer_generate_audio`, `summer_generate_video`, `summer_check_job`.
 

package/README.md

@@ -2,7 +2,7 @@
 
 Build real 2D and 3D games through conversation. No coding required. Export to Steam, desktop, mobile, and web. Built on the Godot team's work, customized and honed so AI agents and humans can collaborate on great games.
 
-**Summer** is the MIT open-source agent layer that connects your AI coding agent to Summer Engine. It is the **Summer CLI**, the **Summer MCP** server, and the **Summer agent** skills, hooks, and plugin manifests, all in one package. First-class setup works in Claude Code, Cursor, Codex, Windsurf, Cline, Roo Code, Gemini CLI, GitHub Copilot CLI, GitHub Copilot in VS Code, and OpenCode. Factory Droid uses the plugin marketplace path.
+**Summer** is the MIT open-source agent layer that connects your AI coding agent to Summer Engine. It is the **Summer CLI**, the **Summer MCP** server, and the **Summer agent** skills, hooks, and plugin manifests, all in one package. First-class setup works in Claude Code, Cursor, Codex, Devin Desktop (formerly Windsurf), Cline, Roo Code, Gemini CLI, GitHub Copilot CLI, GitHub Copilot in VS Code, and OpenCode. Factory Droid uses the plugin marketplace path.
 
 - **Source:** [github.com/SummerEngine/summer-engine-agent](https://github.com/SummerEngine/summer-engine-agent)
 - **CLI setup:** [www.summerengine.com/cli](https://www.summerengine.com/cli)
@@ -18,7 +18,7 @@ It just works. Open your agent, say *"let's make an FPS in Summer Engine,"* and
 Three names, one npm package (`summer-engine`):
 
 - **Summer CLI** (`npx -y summer-engine@latest`): installs the engine, signs you in, scaffolds and runs projects, and writes your agent's config. See [www.summerengine.com/cli](https://www.summerengine.com/cli).
-- **Summer MCP**: the local MCP server that gives your agent 44 engine tools to build, run, and debug a real game. See [www.summerengine.com/mcp](https://www.summerengine.com/mcp).
+- **Summer MCP**: the local MCP server that gives your agent 52 engine tools to build, run, and debug a real game. See [www.summerengine.com/mcp](https://www.summerengine.com/mcp).
 - **Summer agent layer**: the game-dev skills, hooks, and plugin manifests that give your AI agent judgment, not just a chat box.
 
 All MIT, all free to use. One paste sets up all three.
@@ -41,7 +41,7 @@ The same operations are available to agents as MCP tools (`summer_cloud_push`, `
 
 ## Get started: one prompt
 
-Open your AI agent (Claude Code, Cursor, Codex, Copilot, Windsurf, etc.) and paste:
+Open your AI agent (Claude Code, Cursor, Codex, Copilot, Devin Desktop, etc.) and paste:
 
 > Install Summer Engine and let's make a game. Read github.com/SummerEngine/summer-engine-agent, check what I already have installed, install whatever is missing, log me in, and scaffold a starter project so we can start building.
 
@@ -102,7 +102,7 @@ The relevant check ids are `node-version`, `cli-version`, `cli-version-current`,
 npx -y summer-engine@latest setup claude-code --yes --force
 ```
 
-Replace `claude-code` with the user's actual agent: `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `gemini`, `github-copilot`, `vscode-copilot`, or `opencode`. Use `github-copilot` for Copilot CLI and `vscode-copilot` for GitHub Copilot Chat/Agent in VS Code. Factory Droid still uses the plugin marketplace path in the install section below. This writes the current Summer skill bundle to `~/.claude/skills/<name>/SKILL.md` (or the agent's equivalent user-skill directory) AND writes the MCP server config so the agent can talk to the engine. The `--force` flag wipes any stale skill content first, so re-runs always end up with the latest copy.
+Replace `claude-code` with the user's actual agent: `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `kilo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`, or `lm-studio`. Use `github-copilot` for Copilot CLI and `vscode-copilot` for GitHub Copilot Chat/Agent in VS Code. Factory Droid still uses the plugin marketplace path in the install section below. This writes the current Summer skill bundle to `~/.claude/skills/<name>/SKILL.md` (or the agent's equivalent user-skill directory) AND writes the MCP server config so the agent can talk to the engine. The `--force` flag wipes any stale skill content first, so re-runs always end up with the latest copy.
 
 **First-install detection:** if `~/.claude/skills/` didn't exist before this command, Claude Code wasn't watching it and won't auto-detect the new files this session. Tell the user **once**: "Skills installed - restart your agent so they load." On subsequent installs (directory already existed), skills auto-detect mid-session and no restart is needed. **You can detect first-install vs upgrade by checking if `~/.claude/skills/` existed before Step 1; record the result before running setup.**
 
@@ -192,7 +192,7 @@ Only skip brainstorm if the user explicitly said "skip brainstorm" or "just buil
 - **Don't loop `summer login` if it times out at 120s.** Re-run it once and tell the user to be quicker; loop forever and the user is stuck.
 - **Don't jump straight into `summer create` from a vague prompt.** Invoke `summer:brainstorm-game` first (Step 6). The build skills assume `.summer/GameSoul.md` exists.
 
-**Using a different agent?** Replace `claude-code` with any supported agent in Step 1: `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `gemini`, `github-copilot`, `vscode-copilot`, or `opencode`. Skill targets vary per agent (Cursor uses `.cursor/rules/`, Windsurf uses `.windsurfrules`, Cline + Roo use `.clinerules/`, Copilot uses `~/.copilot/skills` or `.github/skills`, OpenCode uses agent definitions, etc.). The CLI handles the difference. After install, **Cline and Roo Code users should restart VS Code** so the extension reloads its MCP config. **Gemini users** may need to run `gemini extensions enable summer-engine` after the first install. **VS Code Copilot users** should start the `summer-engine` MCP server from Agent mode if VS Code does not autostart it. **Factory Droid** still has its own plugin path below.
+**Using a different agent?** Replace `claude-code` with any supported agent in Step 1: `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `kilo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`, or `lm-studio`. (`devin` is also accepted as an alias for `windsurf`.) Skill targets vary per agent (Cursor uses `.cursor/rules/`, Devin Desktop uses `.windsurfrules`, Cline + Roo use `.clinerules/`, Copilot uses `~/.copilot/skills` or `.github/skills`, OpenCode uses agent definitions, etc.). The CLI handles the difference. After install, **Cline and Roo Code users should restart VS Code** so the extension reloads its MCP config. **Gemini users** may need to run `gemini extensions enable summer-engine` after the first install. **VS Code Copilot users** should start the `summer-engine` MCP server from Agent mode if VS Code does not autostart it. **Factory Droid** still has its own plugin path below.
 
 **Power-user note:** if the user specifically wants `summer` on their `PATH` for everyday terminal use outside the AI agent, a global npm install is still possible. The agent flow doesn't need it.
 
@@ -269,13 +269,15 @@ Two pieces, plus the glue.
 
 Skills don't list steps. They encode the **order of operations**: diagnose before editing, scope before building, ask before guessing. [Agent Skills](https://agentskills.io) format, so any conformant tool picks them up.
 
-**MCP bridge.** The `summer-engine` MCP server gives the agent 44 tools that talk to your local engine on `localhost:6550`:
+**MCP bridge.** The `summer-engine` MCP server gives the agent 52 tools that talk to your local engine on `localhost:6550`:
 
 | | |
 |---|---|
 | Scene | `summer_add_node`, `summer_set_prop`, `summer_instantiate_scene`, `summer_replace_node`, `summer_get_scene_tree`, `summer_inspect_node`, `summer_batch` |
 | Diagnostics | `summer_get_script_errors`, `summer_get_diagnostics`, `summer_get_console`, `summer_get_debugger_errors`, `summer_get_debugger_warnings` |
 | Runtime | `summer_play`, `summer_stop`, `summer_is_running` |
+| Visual | `summer_screenshot` (see the editor viewport, an offscreen scene render, or the running game) |
+| Interactive | `SimulateInput` / `RunVerification` raw ops via `summer_batch` — drive the running game or run a hidden GDScript probe (engine-build dependent) |
 | Project | `summer_get_project_context`, `summer_open_main_scene`, `summer_project_setting`, `summer_input_map_bind` |
 | Assets | `summer_search_assets`, `summer_import_asset`, `summer_import_from_url`, `summer_generate_image`, `summer_generate_3d`, `summer_generate_audio`, `summer_generate_video` |
 
@@ -285,6 +287,36 @@ File ops, git, shell, and grep already belong to your agent. We don't shadow the
 
 For the full architecture, see [docs/OVERVIEW.md](docs/OVERVIEW.md).
 
+### Using Summer via MCP: the verification loop
+
+There is no single "verify" tool. You **compose** the checks, climbing only as high as the change demands. Call `summer_get_agent_playbook` for the full ladder; the short version:
+
+**1. Does it compile?** After writing a `.gd`, call `summer_get_script_errors res://scripts/player.gd` — no game boot. For a project-wide sweep, `summer_get_diagnostics` (it tells you whether to then read `summer_get_console` / `summer_get_debugger_errors`).
+
+**2. Does it look right?** `summer_screenshot` returns the actual pixels — you see them, no description layer. Pick the target on purpose:
+- `viewport` (default) — the editor's current tab, as it looks now.
+- `scene` — an offscreen render of a scene *file* (`scenePath`). No boot; **static at t=0**. Confesses if the scene has no `Camera3D` (renders grey/black when played) or no light — read those warnings.
+- `game` — a frame from the **running** game (`summer_play` first). Over plain local HTTP this returns an honest failure until the desktop bridge is present; when it fails, drop to `viewport`/`scene` or ask the user.
+
+**3. Does it run?** Compose the loop:
+
+```
+summer_clear_console            # clean slate
+summer_play                     # boot the game (or a specific scene)
+summer_get_debugger_errors      # runtime errors: null refs, missing nodes, physics
+summer_screenshot target:game   # optional: look at the live frame
+summer_stop                     # ALWAYS stop — scene edits are refused while running
+```
+
+**4. Does the interaction work?** To prove input-driven behavior (jump/move/shoot), send a raw op through `summer_batch` (engine-build dependent — a `failure_reason:"unsupported"` comes back verbatim on older builds):
+- `SimulateInput` — inject into the **running** game: `summer_batch ops:[{op:"SimulateInput", type:"action", action:"jump", pressed:true}]`, then re-check screenshot/debugger.
+- `RunVerification` — spawn a hidden, disposable game instance that runs a GDScript probe (press inputs, read state, save frames) and dies, never touching the editor: `summer_batch ops:[{op:"RunVerification", probe_source:"…", max_seconds:20}]` → `{ok, results, frames, out_dir}`.
+- If neither is available on this build, **ask the user to try it** and report what they see — don't fake it.
+
+**Honesty.** Never describe an image you didn't receive; a failed capture is a *result* — report it and climb down (`scene`→`viewport`) or ask the user. Pass structured failures (`failure_reason`, `terminalState`, `identity_mismatch`) through verbatim. `summer_get_project_context` binds the session to the open project; a `projectMismatch` warning on a screenshot means the engine switched projects and the frame may be from the wrong one — rebind before trusting it.
+
+**Debugging the MCP itself.** Set `SUMMER_MCP_DEBUG=1` in the server's environment to log a structured stderr line per tool call (`tool`, `ok`, `durationMs`, `terminalState`, `errorClass`, `failureReason`, `retried`). With the flag off, only failures are logged.
+
 ---
 
 ## The basic workflow
@@ -390,7 +422,15 @@ Writes the MCP server config to VS Code's globalStorage for the Cline extension
 npx -y summer-engine@latest setup roo-code --yes
 ```
 
-Same shape as Cline (Roo Code is a Cline fork): writes globalStorage MCP config and `.clinerules/` files. **Restart VS Code** afterward.
+Same shape as Cline (Roo Code is a Cline fork): writes globalStorage MCP config and `.clinerules/` files. **Restart VS Code** afterward. Note: Roo Code shut down in May 2026 — prefer Kilo Code, its maintained successor.
+
+### Kilo Code (VS Code)
+
+```bash
+npx -y summer-engine@latest setup kilo-code --yes
+```
+
+Writes the MCP server config to VS Code's globalStorage for the Kilo Code extension (project scope writes `.kilocode/mcp.json`) and drops rules into `.kilocode/rules/`. **Restart VS Code** so Kilo reloads its MCP config.
 
 ### Gemini CLI
 
@@ -424,7 +464,19 @@ npx -y summer-engine@latest setup opencode --yes
 
 Writes the MCP server entry into `opencode.json` (`~/.config/opencode/opencode.json` for user scope, `./opencode.json` for project) using the array-shaped `command: ["npx", "-y", "summer-engine@latest", "mcp"]` format. Restart OpenCode. Full guide: [`.opencode/INSTALL.md`](./.opencode/INSTALL.md).
 
-### Windsurf and others
+### LM Studio (local models)
+
+```bash
+npx -y summer-engine@latest setup lm-studio --yes
+```
+
+Writes the MCP server entry into `~/.lmstudio/mcp.json` (app-global; there is no project scope). In LM Studio, toggle the `summer-engine` server on in the **Program** tab, and raise the loaded model's context length to **32k or higher** — MCP tool schemas overflow small contexts silently. LM Studio has no rules/skills folder; the MCP server's `summer_get_agent_playbook` tool covers in-chat guidance. Pair with a tool-calling-reliable local model (gpt-oss-20b on 12–16 GB VRAM, Qwen3-Coder-30B on 24 GB).
+
+### Ollama (local models)
+
+Ollama is the model backend, not an MCP client — pair it with OpenCode, Kilo Code, or Goose and point that agent's provider at `http://localhost:11434/v1`. Before connecting MCP, raise Ollama's context window (defaults to 4k under 24 GB VRAM): start with `OLLAMA_CONTEXT_LENGTH=65536 ollama serve`, then `ollama ps` to confirm the model still fits on the GPU.
+
+### Devin Desktop (formerly Windsurf) and others
 
 ```bash
 npx -y summer-engine@latest setup <agent> --yes --force
@@ -456,7 +508,7 @@ npx -y summer-engine@latest doctor
 | `summer mcp setup <agent>` | Write MCP config for an agent. |
 | `summer setup <agent> [--yes]` | One shot: MCP config + recommended skills + doctor. |
 
-Agents: `claude-code`, `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `gemini`, `opencode`. Scopes: `--scope user` (default), `--scope project`.
+Agents: `claude-code`, `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `kilo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`, `lm-studio`. (`devin` and `devin-desktop` are accepted as aliases for `windsurf`.) Scopes: `--scope user` (default), `--scope project`.
 
 ---
 

package/dist/bin/summer.js

@@ -56,7 +56,7 @@ function printIntro(version) {
     console.log(`     ${sym.arrow()} ${c.bold("Summer Engine")} ${c.dim("v" + version)}  ${c.dim("·")}  AI-native game engine`);
     console.log("");
     console.log(`     ${c.bold("Setup wizard")}`);
-    console.log(`     Open Claude Code, Cursor, Codex, Copilot, Windsurf, or another supported agent and paste:`);
+    console.log(`     Open Claude Code, Cursor, Codex, Copilot, Devin Desktop (formerly Windsurf), or another supported agent and paste:`);
     console.log(`     ${c.brand("\"Install Summer Engine and let's make a game.\"")}`);
     console.log("");
     console.log(`     ${c.bold("Manual commands")}`);

package/dist/commands/setup.js

@@ -10,13 +10,15 @@ const AGENT_LABEL = {
     "claude-code": "Claude Code",
     codex: "Codex",
     cursor: "Cursor",
-    windsurf: "Windsurf",
+    windsurf: "Devin Desktop (Windsurf)",
     cline: "Cline",
     "roo-code": "Roo Code",
+    "kilo-code": "Kilo Code",
     gemini: "Gemini CLI",
     "github-copilot": "GitHub Copilot CLI",
     "vscode-copilot": "GitHub Copilot in VS Code",
     opencode: "OpenCode",
+    "lm-studio": "LM Studio",
 };
 export const setupCommand = new Command("setup")
     .description("Configure Summer Engine for an AI agent and run diagnostics")
@@ -76,6 +78,12 @@ function resolveScope(scopeOpt) {
     return parsed;
 }
 function setupRecommendedSkills(agent, options) {
+    if (agent === "lm-studio") {
+        return {
+            status: "skipped",
+            message: "LM Studio has no rules or skills folder. The MCP server ships summer_get_agent_playbook, so the model can pull Summer guidance in-chat.",
+        };
+    }
     const invocation = skillInstallInvocation(agent, { force: options.force });
     if (!invocation) {
         return {

package/dist/commands/skills.js

@@ -113,7 +113,8 @@ function resolveScope(agent, opts) {
     if (agent === "cursor" ||
         agent === "windsurf" ||
         agent === "cline" ||
-        agent === "roo-code") {
+        agent === "roo-code" ||
+        agent === "kilo-code") {
         return "project";
     }
     return "user";
@@ -127,11 +128,13 @@ function agentLabel(agent) {
         case "cursor":
             return "Cursor";
         case "windsurf":
-            return "Windsurf";
+            return "Devin Desktop (Windsurf)";
         case "cline":
             return "Cline";
         case "roo-code":
             return "Roo Code";
+        case "kilo-code":
+            return "Kilo Code";
         case "gemini":
             return "Gemini CLI";
         case "github-copilot":
@@ -152,7 +155,7 @@ function resolveInstallLocation(agent, scope) {
         if (agent === "windsurf") {
             return { kind: "windsurf-rule-file", path: join(overrideDir, ".windsurfrules") };
         }
-        if (agent === "cline" || agent === "roo-code") {
+        if (agent === "cline" || agent === "roo-code" || agent === "kilo-code") {
             return { kind: "cline-rule-dir", path: overrideDir };
         }
         if (agent === "gemini") {
@@ -187,6 +190,13 @@ function resolveInstallLocation(agent, scope) {
                     ? rooCodeUserRulesDir()
                     : join(process.cwd(), ".clinerules"),
             };
+        case "kilo-code":
+            return {
+                kind: "cline-rule-dir",
+                path: scope === "user"
+                    ? join(homedir(), ".kilocode", "rules")
+                    : join(process.cwd(), ".kilocode", "rules"),
+            };
         case "gemini":
             return {
                 kind: "gemini-skill-dir",
@@ -390,7 +400,7 @@ function printInstallSummary(count, agent, scope, location) {
         console.log("Restart OpenCode so it picks up the new agent definitions.");
     }
     else {
-        console.log(`Windsurf rules are in ${tildeified}`);
+        console.log(`Devin Desktop (formerly Windsurf) rules are in ${tildeified}`);
     }
 }
 export const skillsCommand = new Command("skills")
@@ -484,7 +494,7 @@ function installClaudeCommands(scope, force) {
 }
 /**
  * Drop a `.summer-version` marker into the install dir so doctor's
- * `skills-version-stale` check can detect drift later. Windsurf writes a
+ * `skills-version-stale` check can detect drift later. Devin Desktop (formerly Windsurf) writes a
  * single rules file with no surrounding dir, so we skip it there.
  */
 function writeMarkerForLocation(location) {

package/dist/lib/agent-config.d.ts

@@ -1,5 +1,5 @@
 export declare const SUMMER_MCP_SERVER_NAME = "summer-engine";
-export declare const supportedAgents: readonly ["codex", "claude-code", "cursor", "windsurf", "cline", "roo-code", "gemini", "github-copilot", "vscode-copilot", "opencode"];
+export declare const supportedAgents: readonly ["codex", "claude-code", "cursor", "windsurf", "cline", "roo-code", "kilo-code", "gemini", "github-copilot", "vscode-copilot", "opencode", "lm-studio"];
 export type SupportedAgent = (typeof supportedAgents)[number];
 export type ConfigScope = "user" | "project";
 export interface StdioMcpServerConfig {

package/dist/lib/agent-config.js

@@ -11,10 +11,12 @@ export const supportedAgents = [
     "windsurf",
     "cline",
     "roo-code",
+    "kilo-code",
     "gemini",
     "github-copilot",
     "vscode-copilot",
     "opencode",
+    "lm-studio",
 ];
 const agentAliases = {
     claude: "claude-code",
@@ -22,10 +24,16 @@ const agentAliases = {
     codex: "codex",
     cursor: "cursor",
     windsurf: "windsurf",
+    devin: "windsurf",
+    "devin-desktop": "windsurf",
+    devindesktop: "windsurf",
     cline: "cline",
     "roo-code": "roo-code",
     roo: "roo-code",
     roocode: "roo-code",
+    kilo: "kilo-code",
+    kilocode: "kilo-code",
+    "kilo-code": "kilo-code",
     gemini: "gemini",
     "gemini-cli": "gemini",
     copilot: "github-copilot",
@@ -39,6 +47,9 @@ const agentAliases = {
     "github-copilot-vscode": "vscode-copilot",
     opencode: "opencode",
     "open-code": "opencode",
+    lmstudio: "lm-studio",
+    "lm-studio": "lm-studio",
+    "lm_studio": "lm-studio",
 };
 export function parseAgent(value) {
     if (!value)
@@ -148,7 +159,7 @@ function resolveConfigTarget(agent, scope, cwd, env) {
     const warnings = [];
     if (override) {
         if (scope === "project" &&
-            (agent === "cline" || agent === "roo-code" || agent === "gemini")) {
+            (agent === "cline" || agent === "roo-code" || agent === "gemini" || agent === "lm-studio")) {
             warnings.push(`${agent} MCP config has no project scope today; treating as user scope.`);
         }
         return {
@@ -212,6 +223,25 @@ function resolveConfigTarget(agent, scope, cwd, env) {
             warnings,
         };
     }
+    if (agent === "kilo-code") {
+        return {
+            path: scope === "user"
+                ? vsCodeGlobalStoragePath(env, "kilocode.kilo-code", "mcp_settings.json")
+                : join(cwd, ".kilocode", "mcp.json"),
+            format: "json",
+            warnings,
+        };
+    }
+    if (agent === "lm-studio") {
+        if (scope === "project") {
+            warnings.push("LM Studio's MCP config is app-global (~/.lmstudio/mcp.json); treating as user scope.");
+        }
+        return {
+            path: join(homedir(), ".lmstudio", "mcp.json"),
+            format: "json",
+            warnings,
+        };
+    }
     if (agent === "gemini") {
         if (scope === "project") {
             warnings.push("Gemini extensions are user-scoped today; writing to ~/.gemini/extensions/summer-engine/ instead of project.");
@@ -250,7 +280,7 @@ function resolveConfigTarget(agent, scope, cwd, env) {
         };
     }
     if (scope === "project") {
-        warnings.push("Windsurf documents MCP configuration as user-scoped; project scope writes .windsurf/mcp_config.json for teams that load workspace config.");
+        warnings.push("Devin Desktop (formerly Windsurf) documents MCP configuration as user-scoped; project scope writes .windsurf/mcp_config.json for teams that load workspace config.");
     }
     return {
         path: scope === "user"
@@ -260,18 +290,18 @@ function resolveConfigTarget(agent, scope, cwd, env) {
         warnings,
     };
 }
-function vsCodeGlobalStoragePath(env, extensionId) {
+function vsCodeGlobalStoragePath(env, extensionId, fileName = "cline_mcp_settings.json") {
     const os = platform();
     if (os === "win32") {
         const appData = env.APPDATA ?? join(homedir(), "AppData", "Roaming");
-        return join(appData, "Code", "User", "globalStorage", extensionId, "settings", "cline_mcp_settings.json");
+        return join(appData, "Code", "User", "globalStorage", extensionId, "settings", fileName);
     }
     if (os === "darwin") {
-        return join(homedir(), "Library", "Application Support", "Code", "User", "globalStorage", extensionId, "settings", "cline_mcp_settings.json");
+        return join(homedir(), "Library", "Application Support", "Code", "User", "globalStorage", extensionId, "settings", fileName);
     }
     // Linux and other Unix
     const xdg = env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
-    return join(xdg, "Code", "User", "globalStorage", extensionId, "settings", "cline_mcp_settings.json");
+    return join(xdg, "Code", "User", "globalStorage", extensionId, "settings", fileName);
 }
 function opencodeUserConfigPath(env) {
     const os = platform();
@@ -305,6 +335,10 @@ function getConfigPathOverride(agent, env) {
         return env.SUMMER_CLINE_CONFIG_FILE;
     if (agent === "roo-code")
         return env.SUMMER_ROO_CODE_CONFIG_FILE;
+    if (agent === "kilo-code")
+        return env.SUMMER_KILO_CODE_CONFIG_FILE;
+    if (agent === "lm-studio")
+        return env.SUMMER_LM_STUDIO_CONFIG_FILE;
     if (agent === "gemini")
         return env.SUMMER_GEMINI_CONFIG_FILE;
     if (agent === "github-copilot")
@@ -558,15 +592,19 @@ function createNextSteps(agent, scope, path) {
                     ? "Restart VS Code so Cline reloads its MCP config."
                     : agent === "roo-code"
                         ? "Restart VS Code so Roo Code reloads its MCP config."
-                        : agent === "gemini"
-                            ? "Run `gemini extensions enable summer-engine` (if not already enabled), then restart Gemini CLI."
-                            : agent === "github-copilot"
-                                ? "Restart Copilot CLI, or run /mcp reload and /skills reload in the active session."
-                                : agent === "vscode-copilot"
-                                    ? "Restart VS Code or run MCP: List Servers, then start summer-engine in Copilot Agent mode."
-                                    : agent === "opencode"
-                                        ? "Restart OpenCode so it reloads opencode.json."
-                                        : "Restart Windsurf and refresh MCP servers from Cascade settings.";
+                        : agent === "kilo-code"
+                            ? "Restart VS Code so Kilo Code reloads its MCP config."
+                            : agent === "lm-studio"
+                                ? "Open LM Studio, toggle on the summer-engine MCP server in the Program tab, and raise the loaded model's context length to 32k or higher."
+                                : agent === "gemini"
+                                    ? "Run `gemini extensions enable summer-engine` (if not already enabled), then restart Gemini CLI."
+                                    : agent === "github-copilot"
+                                        ? "Restart Copilot CLI, or run /mcp reload and /skills reload in the active session."
+                                        : agent === "vscode-copilot"
+                                            ? "Restart VS Code or run MCP: List Servers, then start summer-engine in Copilot Agent mode."
+                                            : agent === "opencode"
+                                                ? "Restart OpenCode so it reloads opencode.json."
+                                                : "Restart Devin Desktop (formerly Windsurf) and refresh MCP servers from the agent settings.";
     const projectTrust = scope === "project" && agent === "codex"
         ? "Codex only loads project .codex/config.toml from trusted projects."
         : null;

package/dist/lib/api-client.d.ts

@@ -2,6 +2,10 @@ export type EngineSnapshot = {
     ok: boolean;
     localPath?: string;
     path?: string;
+    /** Raw image bytes, base64-encoded. Carried so a caller (e.g. the MCP
+     *  screenshot tool) can return an MCP image content block to a vision-capable
+     *  client without re-reading localPath off disk. */
+    base64?: string;
     width?: number;
     height?: number;
     format?: string;
@@ -12,12 +16,43 @@ export type EngineSnapshot = {
     bytes?: number;
     error?: string;
     metadata?: Record<string, unknown>;
+    /** Structured failure classifier the engine returns on a game snapshot over
+     *  local HTTP (409 `bridge_required`) — surfaced verbatim so the tool can give
+     *  an honest, actionable message instead of a truncated generic 409 string.
+     *  When P4.4 lands (game snapshots answer 200/202 over HTTP) this simply
+     *  never fires and the tool works. */
+    failureReason?: string;
+    /** Scene-preview confession fields (P4.3). Populated only for target:"scene".
+     *  A scene with no Camera3D renders grey/black when played; the engine reports
+     *  whether it had to synthesize a camera/light so the model can warn honestly. */
+    sceneHasCamera?: boolean;
+    sceneHadLight?: boolean;
+    usedSyntheticCamera?: boolean;
+    /** Set true when the bound projectIdHash no longer matches the engine's live
+     *  health hash at capture time — the frame may be from the WRONG project
+     *  (item 4, client-side drift check). */
+    projectMismatch?: boolean;
 };
 export declare class EngineApiClient {
     private port;
     private token;
-    constructor(port: number, token: string);
+    private boundProjectIdHash?;
+    constructor(port: number, token: string, boundProjectIdHash?: string);
     static connect(): Promise<EngineApiClient>;
+    /** The projectIdHash this session is bound to (undefined if none was reported
+     *  at connect — e.g. no project open yet). */
+    getBoundProjectIdHash(): string | undefined;
+    /**
+     * Re-read health and rebind to the currently-open project. Called by
+     * summer_get_project_context so the agent can INTENTIONALLY follow a project
+     * switch (the deliberate escape hatch after an identity_mismatch). Returns the
+     * new bound hash. Reads carry no identity, so this always reaches the engine
+     * even when a mutation would be rejected.
+     */
+    rebind(): Promise<string | undefined>;
+    /** Identity to attach to a MUTATING command's options so the engine can reject
+     *  a wrong-project write. Empty when unbound (engine then skips the check). */
+    private identityOptions;
     private request;
     /** Raw fetch with auth + timeout — returns the Response so callers can inspect
      *  the status (202 queued vs 200 legacy). */
@@ -47,7 +82,46 @@ export declare class EngineApiClient {
     getSelection(): Promise<unknown>;
     private writeSnapshotFile;
     private snapshot;
+    /** Shared: turn an ops/snapshot response envelope into an EngineSnapshot.
+     *  Used by viewport/game snapshots and by scenePreview. */
+    private _parseSnapshotResponse;
+    /**
+     * Probe /api/snapshot/game for the structural 409 `bridge_required` shape
+     * (tool_net_thread.cpp:495-503). Returns a structured failure only when the
+     * engine actually answers 409 with `bridge_required` / `unsupported_transport`;
+     * ANY other status (200/202/other) returns null so the caller proceeds to the
+     * normal queued path — so the moment the engine starts answering over HTTP
+     * (P4.4), game capture just works with no code change here.
+     */
+    private _detectBridgeRequired;
     viewportSnapshot(): Promise<EngineSnapshot>;
     gameSnapshot(): Promise<EngineSnapshot>;
+    /**
+     * Offscreen scene render via the `ScenePreview` op over /api/ops (no game
+     * boot; physics/animations are static). Mirrors the web previewScene op input
+     * (snapshot-tools.ts): { op:'ScenePreview', scene_path?, framing?, size?,
+     * node_path? } — scene_path optional, engine defaults to the open scene. The
+     * result carries image_base64 + mime (+ width/height) plus the P4.3 confession
+     * fields (scene_has_camera / scene_had_light / used_synthetic_camera).
+     */
+    scenePreview(input?: {
+        scenePath?: string;
+        framing?: "auto" | "top" | "front" | "iso";
+        size?: [number, number];
+        nodePath?: string;
+    }): Promise<EngineSnapshot>;
     getPort(): number;
+    /**
+     * Cheap drift probe for the MCP client cache. The engine mints a fresh
+     * api-token on every launch (local_api_server.cpp::_generate_api_token) and can
+     * bind a different port (tool_net_thread.cpp::start increments 6550..6565 when
+     * the old socket lingers), so a client built before an engine restart holds
+     * dead credentials. Re-read the on-disk creds and report whether they no longer
+     * match this client's snapshot.
+     *
+     * Empty / unreadable creds (engine mid-write, or just closed) are treated as
+     * "no drift" so a transient read never thrashes the cache — the live request
+     * will fail and trigger a reconnect+retry if the client really is stale.
+     */
+    credentialsChanged(): Promise<boolean>;
 }