feat(setup): add first-class Bionic support

CHANGELOG.md

@@ -2,6 +2,12 @@
 
 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/).
 
+## [Unreleased]
+
+### Added
+- First-class LM Studio Bionic setup through `summer setup bionic`: public MCP discovery configuration, native Bionic Agent Skills, statically bound project-scope connections, setup aliases, diagnostics markers, tests, and a dedicated guide.
+- MCP Roots-based project routing for clients that advertise the capability, including safe rebinding on `roots/list_changed` and ambiguity protection.
+
 ## [3.0.0] (2026-09-09): "The Library"
 
 v3 rebuilds the package around one idea: every resource is described once (`library/<kind>/<slug>/resource.yaml`) and everything else (the searchable index, every agent manifest, the skill and template registries, counts, aliases) is generated from it, with CI failing on drift. Migrating from v2: `docs/MIGRATION-V2-V3.md`. The design contract and the verified-vs-planned status live in the repository under `docs/design/`.

README.md

@@ -31,7 +31,7 @@ You stay in control of every change and release. Summer never publishes, install
 
 ## Get started: one prompt
 
-Open your AI agent (Claude Code, Cursor, Codex, Copilot, Devin Desktop, etc.) and paste:
+Open your AI agent (Claude Code, Cursor, Codex, Copilot, Bionic, Devin Desktop, etc.) and paste:
 
 > Install Summer Engine and let's make a game. Read github.com/summerengine/summer, check what I already have installed, install whatever is missing, log me in, and scaffold a starter project so we can start building.
 
@@ -93,7 +93,7 @@ The check ids are `node-version`, `cli-version`, `cli-version-current`, `skills-
 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`, `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 uses the plugin marketplace path (see [`integrations/README.md`](integrations/README.md)). This installs **every skill in the library** (`status: preview` skills included — they are labelled as preview in their guidance, and `--stable-only` skips them) to `~/.claude/skills/<slug>/SKILL.md` (or the agent's equivalent user-skill directory) AND writes the MCP server config so the agent can talk to the engine, then runs doctor and prints what it installed and where. The `--force` flag wipes any stale skill content first, so re-runs always end up with the latest copy. `--recommended` installs only the recommended subset — don't use it from this playbook.
+Replace `claude-code` with the user's actual agent: `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `kilo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`, `bionic`, or `lm-studio`. Use `github-copilot` for Copilot CLI and `vscode-copilot` for GitHub Copilot Chat/Agent in VS Code. Factory Droid uses the plugin marketplace path (see [`integrations/README.md`](integrations/README.md)). This installs **every skill in the library** (`status: preview` skills included — they are labelled as preview in their guidance, and `--stable-only` skips them) to `~/.claude/skills/<slug>/SKILL.md` (or the agent's equivalent user-skill directory) AND writes the MCP server config so the agent can talk to the engine, then runs doctor and prints what it installed and where. The `lm-studio` target is MCP-only and uses `summer_get_agent_playbook` for in-chat guidance; the separate `bionic` target installs native Agent Skills. The `--force` flag wipes any stale skill content first, so re-runs always end up with the latest copy. `--recommended` installs only the recommended subset — don't use it from this playbook.
 
 **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.**
 
@@ -186,7 +186,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 the `brainstorm-game` skill 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`, `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; the CLI handles the difference, and [`integrations/README.md`](integrations/README.md) documents exactly what gets written where for every client. 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.
+**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`, `bionic`, or `lm-studio`. (`devin` is also accepted as an alias for `windsurf`.) Skill targets vary per agent (Bionic uses `~/.lmstudio/skills`); the CLI handles the difference, and [`integrations/README.md`](integrations/README.md) documents exactly what gets written where for every client. After install, **Bionic users** should enable `summer-engine` under **Settings → Connected Apps** and verify Summer skills under **Settings → Skills**. **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.
 
 **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.
 
@@ -313,7 +313,6 @@ Not downloaded, not collected:
 A command, tool contract, or roadmap entry does not by itself mean a hosted
 service is production-ready. Managed publishing, hosting, store submission, and
 matchmaking are not promised by this package.
-
 ## CLI reference
 
 | Command | What it does |
@@ -344,7 +343,7 @@ matchmaking are not promised by this package.
 | `summer mcp setup <agent>` | Deprecated alias of `summer setup <agent>`. |
 | `summer setup <agent> [--yes] [--force] [--recommended] [--stable-only]` | One shot: MCP config + all skills, preview included (`--recommended` for the subset, `--stable-only` to skip preview) + doctor. Idempotent. |
 
-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`.
+Agents: `claude-code`, `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `kilo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`, `bionic`, `lm-studio`. (`devin` and `devin-desktop` are accepted as aliases for `windsurf`; `lm-bionic` and `lm-studio-bionic` are accepted as aliases for `bionic`.) Scopes: `--scope user` (default), `--scope project`.
 
 ## Contributing
 
@@ -362,7 +361,7 @@ Testing an unpublished build end to end against the real engine and a real agent
 - [Development guide](docs/DEVELOPMENT.md) · [v2 → v3 migration](docs/MIGRATION-V2-V3.md)
 - [Design: contract](docs/design/CONTRACT.md) · [decisions](docs/design/DECISIONS.md) · [roadmap](docs/design/ROADMAP.md)
 - [Agent support map](integrations/README.md) · [Template pinning](library/templates/README.md) · [Evals](evals/README.md)
-- Per-host notes: [Claude Code](docs/CLAUDE_CODE.md) · [Codex](docs/CODEX.md) · [Cursor](docs/CURSOR.md) · [OpenCode](.opencode/INSTALL.md)
+- Per-host notes: [Claude Code](docs/CLAUDE_CODE.md) · [Codex](docs/CODEX.md) · [Cursor](docs/CURSOR.md) · [Bionic](docs/BIONIC.md) · [OpenCode](.opencode/INSTALL.md)
 
 ## License
 

docs/BIONIC.md

@@ -0,0 +1,56 @@
+# Bionic
+
+[LM Studio Bionic](https://lmstudio.ai/docs/bionic) is a separate agentic app from LM Studio. It supports local models and cloud-hosted open models, local coding projects, MCP servers, and standard [Agent Skills](https://lmstudio.ai/docs/bionic/agent/skills).
+
+## Recommended Setup
+
+Run this from the Summer game directory:
+
+```bash
+npx -y summer-engine@latest setup bionic --scope project --yes --force
+```
+
+This performs two setup steps:
+
+- publishes the `summer-engine` stdio entry to the public [`~/.lmstudio/mcp.json`](https://lmstudio.ai/docs/app/mcp) integration file, which Bionic discovers under Connected Apps, and binds it to the current game;
+- installs Summer Agent Skills under `.agents/skills/<skill>/SKILL.md`.
+
+The published MCP registration is app-global. Bionic currently starts global MCP servers outside the active Code Project and does not advertise MCP Roots. Project-scope setup therefore pins both its stdio `cwd` and `SUMMER_ENGINE_PROJECT` to the current directory. Because Bionic does not update that global connection when its active Code Project changes, re-run the setup command from the new game directory when switching projects.
+
+If you always run exactly one Summer editor and prefer global skills, use user scope instead:
+
+```bash
+npx -y summer-engine@latest setup bionic --yes --force
+```
+
+User scope installs skills under `~/.lmstudio/skills/<skill>/SKILL.md` and leaves editor discovery automatic.
+
+Bionic owns its internal enabled/connection state; Summer does not write Bionic's private app-state files.
+
+## Enable Summer in Bionic
+
+1. Open **Settings → Connected Apps**.
+2. Enable `summer-engine` and confirm that its tools are ready.
+3. Open **Settings → Skills** and verify that the Summer skills are enabled.
+
+If the MCP entry does not appear after setup, restart Bionic and check **Connected Apps** again.
+
+## Project Skills
+
+For project skills without changing MCP configuration, run this from the project root (the recommended setup command above already does this):
+
+```bash
+npx -y summer-engine@latest skills install --recommended --agent bionic --scope project
+```
+
+This writes standard Agent Skills to `.agents/skills/<skill>/SKILL.md`, a discovery path covered by the [Bionic changelog](https://lmstudio.ai/changelog). Bionic can also expose compatible skills already installed for Codex or Claude Code through **Settings → Skills → Use skills found in other apps**.
+
+## Run Summer Engine
+
+Keep Summer Engine open on the same project while Bionic works:
+
+```bash
+npx -y summer-engine@latest run path/to/project
+```
+
+Use a model with reliable tool calling and enough context for the Summer MCP tool schemas. Bionic should use Summer MCP for project files, scene/editor operations, play mode, and diagnostics.

docs/OVERVIEW.md

@@ -14,7 +14,7 @@ Three things, plus glue.
 
 **CLI.** Install the engine, log in, scaffold projects, run them, run doctor — and `summer tool <name>` runs any MCP tool from the terminal. The complete command reference is in [`DEVELOPMENT.md`](DEVELOPMENT.md#cli-command-reference); `summer --help` is the source of truth.
 
-The glue: **lifecycle hooks** (session-start orientation, opt-in pre-commit doctor), plugin manifests for plugin-capable harnesses, and `summer setup` targets for Claude Code, Cursor, Codex, Gemini, OpenCode, GitHub Copilot CLI, GitHub Copilot in VS Code, Cline, Roo Code, Kilo Code, LM Studio, and Devin Desktop (formerly Windsurf). The per-client map is [`../integrations/README.md`](../integrations/README.md).
+The glue: **lifecycle hooks** (session-start orientation, opt-in pre-commit doctor), plugin manifests for plugin-capable harnesses, and `summer setup` targets for Claude Code, Cursor, Codex, Gemini, OpenCode, GitHub Copilot CLI, GitHub Copilot in VS Code, Cline, Roo Code, Kilo Code, Bionic, LM Studio, and Devin Desktop (formerly Windsurf). The per-client map is [`../integrations/README.md`](../integrations/README.md).
 
 ## Quick start
 
@@ -55,10 +55,12 @@ Each agent has its own home for SKILL.md files:
 | `cursor` | `~/.cursor/rules` (as `summer-<skill>.mdc`) | `.cursor/rules` |
 | `cline` | `~/Documents/Cline/Rules` | `.clinerules` |
 | `roo-code` | `~/Documents/Roo/Rules` | `.clinerules` |
+| `kilo-code` | `~/.kilocode/rules` | `.kilocode/rules` |
 | `gemini` | `~/.gemini/extensions/summer-engine/skills` | n/a |
 | `github-copilot` | `~/.copilot/skills` | `.github/skills` |
 | `vscode-copilot` | `~/.copilot/skills` | `.github/skills` |
 | `opencode` | `~/.config/opencode/agents/summer` | `.opencode/agents/summer` |
+| `bionic` | `~/.lmstudio/skills` | `.agents/skills` |
 | `windsurf` (Devin Desktop) | `~/.windsurfrules` (managed blocks) | `.windsurfrules` |
 
 Use `--scope project` when you want the skills committed with the game:

docs/SETUP_PROMPT.md

@@ -1,6 +1,6 @@
 # Copy-Paste Setup Prompt
 
-Use this when a human wants to install Summer Engine from Claude Code, Cursor, Codex, Devin Desktop (formerly Windsurf), Cline, Roo Code, Gemini CLI, GitHub Copilot CLI, GitHub Copilot in VS Code, or OpenCode.
+Use this when a human wants to install Summer Engine from Claude Code, Cursor, Codex, Devin Desktop (formerly Windsurf), Cline, Roo Code, Kilo Code, Gemini CLI, GitHub Copilot CLI, GitHub Copilot in VS Code, OpenCode, Bionic, or LM Studio.
 
 Source: https://github.com/summerengine/summer
 MCP setup page: https://summerengine.com/mcp
@@ -23,7 +23,7 @@ Expected agent behavior:
 6. Create and run a starter project only after choosing a stable parent directory.
 7. Use the `brainstorm-game` skill before building from a vague prompt.
 
-First-class setup targets: `claude-code`, `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `kilo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`, `lm-studio`.
+First-class setup targets: `claude-code`, `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `kilo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`, `bionic`, `lm-studio`.
 
 Factory Droid uses its plugin marketplace path today. Other older-school or adjacent surfaces worth watching are Continue, Aider, Zed, JetBrains AI/Junie, Goose, and Amp; do not claim first-class Summer setup support for those until a real config target exists.
 

docs/SKILLS.md

@@ -43,7 +43,7 @@ summer skills install --all --stable-only --agent claude-code   # Stable skills
 summer skills install --recommended --agent cursor --scope project   # Per-project
 ```
 
-Supported agents: `summer`, `codex`, `claude-code`, `cursor`, `windsurf`, `cline`, `roo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`. Supported scopes: `user`, `project`.
+Supported agents: `summer`, `codex`, `claude-code`, `cursor`, `windsurf`, `cline`, `roo-code`, `kilo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`, `bionic`. Supported scopes: `user`, `project`.
 
 ## Recommended set
 

integrations/README.md

@@ -65,6 +65,7 @@ How the plugin manifests reference skills, and what is verified:
 | vscode-copilot | — | MCP: VS Code user-profile `mcp.json` / `.vscode/mcp.json`; skills: `~/.copilot/skills/` or `.github/skills/` |
 | opencode | — (JS plugin via npm `main`, `.opencode/plugins/summer.js`) | MCP entry in `opencode.json` (`type: "local"`, array `command`); skills: the plugin registers `library/skills/` via `skills.paths`; `skills install --agent opencode` additionally writes `agents/summer/` markdown |
 | lm-studio | — | MCP: `~/.lmstudio/mcp.json` (app-global); no skills folder — guidance via `summer_get_agent_playbook` |
+| bionic | — | MCP: `~/.lmstudio/mcp.json` (app-global; `--scope project` statically binds the entry to the current game via stdio `cwd` + `SUMMER_ENGINE_PROJECT`); skills: `~/.lmstudio/skills/` (user) / `.agents/skills/` (project); MCP Roots-based project routing when the client advertises it (`src/mcp/client-roots.ts`) |
 
 Source of truth for the setup paths: `src/installer/agent-config.ts` and
 `src/cli/commands/skills.ts`.

integrations/bionic/README.md

@@ -0,0 +1,32 @@
+# Bionic integration
+
+No manifest file is generated in this repo for Bionic —
+`manifest-target.json` is intentionally empty. Support is delivered at install
+time by `summer setup bionic`, which writes:
+
+- MCP config: `~/.lmstudio/mcp.json` — the public integration file Bionic
+  discovers under **Settings → Connected Apps**. The file is app-global; when
+  `--scope project` is requested, the entry is statically bound to the current
+  project instead (its stdio `cwd` and `SUMMER_ENGINE_PROJECT` are pinned to
+  the game directory, and setup warns that re-running from another project
+  switches the binding). Bionic currently starts global MCP servers outside
+  the active Code Project and does not update the connection when the project
+  changes, so re-run setup from the new game directory when switching games.
+  The MCP server also honours MCP Roots when a client advertises them
+  (`src/mcp/client-roots.ts`): a single unambiguous Summer project root binds
+  the session, ambiguity fails closed, and explicit CLI/env binding wins.
+- Skills: `summer setup bionic` installs the whole library in the same scope as
+  the MCP config — `~/.lmstudio/skills/<skill>/SKILL.md` (user) or
+  `.agents/skills/<skill>/SKILL.md` (project). After install, enable
+  `summer-engine` under **Settings → Connected Apps** and verify the Summer
+  skills under **Settings → Skills**.
+
+Bionic is a separate agentic app from LM Studio; the `lm-studio` setup target
+remains MCP-only. Bionic owns its internal enabled/connection state; Summer
+does not write Bionic's private app-state files.
+
+Full guide: `docs/BIONIC.md`. Aliases: `bionic`, `lm-bionic`,
+`lm-studio-bionic`, `lmstudiobionic`.
+
+Source of truth: `src/installer/agent-config.ts`,
+`src/installer/skill-locations.ts`, `src/installer/version-check.ts`.

integrations/bionic/manifest-target.json

@@ -0,0 +1,3 @@
+{
+  "targets": []
+}

package.json

@@ -1,7 +1,7 @@
 {
   "name": "summer-engine",
   "version": "3.0.0",
-  "description": "Local Summer CLI and MCP server for Summer Engine. Install and run the engine, connect Claude Code, Cursor, Codex, Gemini, and other agents, and build real games with bundled skills, hooks, and plugins.",
+  "description": "Local Summer CLI and MCP server for Summer Engine. Install and run the engine, connect Claude Code, Cursor, Codex, Bionic, Gemini, and other agents, and build real games with bundled skills, hooks, and plugins.",
   "keywords": [
     "summer-engine",
     "summer-cli",
@@ -17,6 +17,8 @@
     "claude-code",
     "cursor",
     "codex",
+    "bionic",
+    "lm-studio",
     "gamedev",
     "game-development",
     "3d",

scripts/generate-registry/targets.ts

@@ -40,6 +40,7 @@ export const MANIFEST_TARGETS: Record<string, ManifestTarget[]> = {
   "github-copilot": [],
   "vscode-copilot": [],
   "lm-studio": [],
+  bionic: [],
   // OpenCode consumes the package as a JS module (.opencode/plugins/summer.js)
   // and auto-discovers skills from disk — no generated manifest today.
   opencode: [],