@beremaran/godot-agent-loop 1.0.0

package/addons/godot_agent_loop/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2025 Tugcan Topaloglu
+Copyright (c) 2026 Berke Arslan
+Copyright (c) 2025 Solomon Elias (Original godot-mcp: https://github.com/Coding-Solo/godot-mcp)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/addons/godot_agent_loop/README.md

@@ -0,0 +1,31 @@
+# Godot Agent Loop Bridge
+
+An optional Godot 4 editor addon for
+[Godot Agent Loop](https://github.com/beremaran/godot-agent-loop). It adds a
+dock with authenticated connection status, live Agent Activity, human
+Pause/Resume Agent control, protocol and Godot compatibility diagnostics, and
+setup help for Claude Code, Codex, OpenCode, and Pi.
+
+## Install
+
+Copy `addons/godot_agent_loop/` into a Godot project, then enable **Godot Agent
+Loop Bridge** under **Project > Project Settings > Plugins**. Installing the
+addon is optional: the external MCP package creates and removes a transient
+bridge when this persistent addon is absent.
+
+The addon listens only on loopback. It accepts commands only after a secret
+authenticated protocol handshake from an editor launched through Godot Agent
+Loop. A normally launched editor shows setup diagnostics but does not accept
+agent commands.
+
+## Human control
+
+Use **Pause Agent** before editing shared project state. Inspection remains
+available, while subsequent agent mutations are refused before dispatch. Use
+**Resume Agent** to return control.
+
+This addon does not install Node.js, an MCP client, or an AI agent. Follow the
+client setup in the main project documentation, then use `launch_editor` so the
+bridge receives its per-session authentication secret.
+
+Licensed under the MIT License; see [LICENSE](LICENSE).

package/addons/godot_agent_loop/plugin.cfg

@@ -0,0 +1,8 @@
+[plugin]
+
+name="Godot Agent Loop Bridge"
+description="Authenticated agent activity, pause control, compatibility diagnostics, and setup help for Godot Agent Loop."
+author="Berke Arslan"
+version="1.0.0"
+script="plugin.gd"
+protocol_version="1"

package/addons/godot_agent_loop/plugin.gd

@@ -0,0 +1,417 @@
+@tool
+extends EditorPlugin
+
+## Small, authenticated editor bridge used by editor-capable integrations.
+## Mutations are recorded through EditorUndoRedoManager; the bridge never edits
+## scene text directly and never evaluates arbitrary code in the editor.
+
+var _server: TCPServer
+var _peer: StreamPeerTCP
+var _buffer: PackedByteArray = PackedByteArray()
+var _port: int = 9091
+var _secret: String = ""
+var _activity_dock: VBoxContainer
+var _activity_list: ItemList
+var _connection_status: Label
+var _compatibility_status: Label
+var _driver_status: Label
+var _driver_pause_button: Button
+var _driver_paused: bool = false
+var _session_authenticated: bool = false
+var _server_version: String = ""
+var _last_history_id: int = EditorUndoRedoManager.GLOBAL_HISTORY
+var _activity_entries: Array[Dictionary] = []
+var _last_filesystem_sync: Dictionary = {}
+const MAX_ACTIVITY_ENTRIES: int = 200
+const PROTOCOL_VERSION: String = "1"
+const ADDON_VERSION: String = "1.0.0"
+
+func _enter_tree() -> void:
+	set_process(true)
+	_port = _read_port()
+	_secret = OS.get_environment("GODOT_MCP_EDITOR_SECRET")
+	_driver_paused = OS.get_environment("GODOT_MCP_EDITOR_START_PAUSED").strip_edges().to_lower() in ["1", "true", "yes"]
+	_server = TCPServer.new()
+	_create_activity_dock()
+	var error: int = _server.listen(_port, "127.0.0.1")
+	if error != OK:
+		push_error("Godot Agent Loop editor bridge could not listen on %d: %s" % [_port, error_string(error)])
+		_set_connection_status("Unavailable — port %d: %s" % [_port, error_string(error)])
+	elif _secret.is_empty():
+		_set_connection_status("Waiting — relaunch the editor through Godot Agent Loop")
+	else:
+		_set_connection_status("Waiting for an authenticated agent")
+
+func _exit_tree() -> void:
+	set_process(false)
+	if _peer != null:
+		_peer.disconnect_from_host()
+	_peer = null
+	if _server != null:
+		_server.stop()
+	_server = null
+	if _activity_dock != null:
+		remove_control_from_docks(_activity_dock)
+		_activity_dock.queue_free()
+	_activity_dock = null
+	_activity_list = null
+	_connection_status = null
+	_compatibility_status = null
+	_driver_status = null
+	_driver_pause_button = null
+
+func _process(_delta: float) -> void:
+	if _server != null and _server.is_connection_available():
+		if _peer != null:
+			_server.take_connection().disconnect_from_host()
+		else:
+			_peer = _server.take_connection()
+			_session_authenticated = false
+			_server_version = ""
+			_set_connection_status("Connected — authenticating")
+	if _peer == null:
+		return
+	var poll_error: Error = _peer.poll()
+	if poll_error != OK:
+		return
+	if _peer.get_status() != StreamPeerTCP.STATUS_CONNECTED:
+		_peer = null
+		_buffer = PackedByteArray()
+		_session_authenticated = false
+		_server_version = ""
+		_set_connection_status("Waiting for an authenticated agent")
+		return
+	var available: int = _peer.get_available_bytes()
+	if available <= 0:
+		return
+	var incoming: Array = _peer.get_data(mini(available, 64 * 1024))
+	if incoming[0] != OK:
+		return
+	var incoming_variant: Variant = incoming[1]
+	if not incoming_variant is PackedByteArray:
+		return
+	var incoming_bytes: PackedByteArray = incoming_variant
+	_buffer.append_array(incoming_bytes)
+	while true:
+		var newline: int = _buffer.find(10)
+		if newline < 0:
+			break
+		var line: String = _buffer.slice(0, newline).get_string_from_utf8().strip_edges()
+		_buffer = _buffer.slice(newline + 1)
+		if line.is_empty():
+			continue
+		_handle_request(line)
+
+func _handle_request(line: String) -> void:
+	var parsed: Variant = JSON.parse_string(line)
+	if not parsed is Dictionary:
+		_send({"id": null, "error": "invalid_request"})
+		return
+	var request: Dictionary = parsed
+	if _secret.is_empty() or str(request.get("secret", "")) != _secret:
+		_send({"id": request.get("id", null), "error": "authentication_required"})
+		return
+	var command: String = str(request.get("command", ""))
+	if command == "handshake":
+		var handshake: Dictionary = _handshake(request.get("params", {}))
+		handshake["id"] = request.get("id", null)
+		_send(handshake)
+		return
+	if not _session_authenticated:
+		_send({"id": request.get("id", null), "error": "handshake_required", "protocol_version": PROTOCOL_VERSION})
+		return
+	var result: Dictionary = _dispatch(command, request.get("params", {}))
+	result["id"] = request.get("id", null)
+	_send(result)
+
+func _dispatch(command: String, raw_params: Variant) -> Dictionary:
+	var params: Dictionary = raw_params if raw_params is Dictionary else {}
+	match command:
+		"inspect":
+			return _inspect()
+		"activity":
+			return _record_activity(params)
+		"driver_state":
+			return _driver_state()
+		"filesystem_changed":
+			return _sync_filesystem(params)
+		"select":
+			return _select(params)
+		"save":
+			var save_error: Error = EditorInterface.save_scene()
+			return {"success": save_error == OK, "saved": save_error == OK, "error_code": save_error}
+		"reload":
+			var scene_path: String = str(params.get("scene_path", ""))
+			EditorInterface.reload_scene_from_path(scene_path)
+			return {"success": true, "scene_path": scene_path}
+		"open_scene":
+			var open_path: String = str(params.get("scene_path", ""))
+			if open_path.is_empty():
+				return {"error": "scene_path is required"}
+			EditorInterface.open_scene_from_path(open_path)
+			return {"success": true, "scene_path": open_path}
+		"set_property":
+			return _set_property(params)
+		"rename_node":
+			return _rename_node(params)
+		"undo":
+			var undo_redo: EditorUndoRedoManager = EditorInterface.get_editor_undo_redo()
+			if undo_redo == null:
+				return {"success": false, "action": "undo"}
+			var undo_history: UndoRedo = undo_redo.get_history_undo_redo(_last_history_id)
+			return {"success": undo_history.undo(), "action": "undo"}
+		"redo":
+			var redo_manager: EditorUndoRedoManager = EditorInterface.get_editor_undo_redo()
+			if redo_manager == null:
+				return {"success": false, "action": "redo"}
+			var redo_history: UndoRedo = redo_manager.get_history_undo_redo(_last_history_id)
+			return {"success": redo_history.redo(), "action": "redo"}
+		_:
+			return {"error": "unknown_command", "allowed": ["inspect", "activity", "driver_state", "filesystem_changed", "select", "save", "reload", "open_scene", "set_property", "rename_node", "undo", "redo"]}
+
+func _handshake(raw_params: Variant) -> Dictionary:
+	var params: Dictionary = raw_params if raw_params is Dictionary else {}
+	var requested_protocol: String = str(params.get("protocol_version", ""))
+	_server_version = str(params.get("server_version", ""))
+	if requested_protocol != PROTOCOL_VERSION:
+		_session_authenticated = false
+		_set_connection_status("Incompatible protocol — server %s, addon %s" % [requested_protocol, PROTOCOL_VERSION])
+		return {
+			"error": "incompatible_protocol",
+			"requested_protocol": requested_protocol,
+			"protocol_version": PROTOCOL_VERSION,
+			"addon_version": ADDON_VERSION,
+		}
+	_session_authenticated = true
+	_set_connection_status("Authenticated — server %s" % (_server_version if not _server_version.is_empty() else "unknown"))
+	return {
+		"success": true,
+		"product": "Godot Agent Loop",
+		"protocol_version": PROTOCOL_VERSION,
+		"addon_version": ADDON_VERSION,
+		"server_version": _server_version,
+		"godot_version": Engine.get_version_info().get("string", "unknown"),
+	}
+
+func _create_activity_dock() -> void:
+	_activity_dock = VBoxContainer.new()
+	_activity_dock.name = "Godot Agent Loop"
+	var title := Label.new()
+	title.text = "Agent Activity"
+	title.tooltip_text = "Live authenticated MCP command lifecycle"
+	_activity_dock.add_child(title)
+	_connection_status = Label.new()
+	_connection_status.name = "ConnectionStatus"
+	_connection_status.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
+	_activity_dock.add_child(_connection_status)
+	_compatibility_status = Label.new()
+	_compatibility_status.name = "CompatibilityStatus"
+	_compatibility_status.text = "Addon %s · protocol %s · Godot %s" % [ADDON_VERSION, PROTOCOL_VERSION, Engine.get_version_info().get("string", "unknown")]
+	_compatibility_status.tooltip_text = "The MCP server and addon must use the same editor protocol version."
+	_activity_dock.add_child(_compatibility_status)
+	var driver_row := HBoxContainer.new()
+	driver_row.name = "DriverControls"
+	_driver_status = Label.new()
+	_driver_status.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+	driver_row.add_child(_driver_status)
+	_driver_pause_button = Button.new()
+	var connect_error: Error = _driver_pause_button.pressed.connect(_toggle_driver_pause) as Error
+	if connect_error != OK:
+		push_error("Godot Agent Loop could not connect its pause control: %s" % error_string(connect_error))
+	driver_row.add_child(_driver_pause_button)
+	_activity_dock.add_child(driver_row)
+	_update_driver_controls()
+	_activity_list = ItemList.new()
+	_activity_list.name = "Activity"
+	_activity_list.custom_minimum_size = Vector2(320, 180)
+	_activity_list.size_flags_vertical = Control.SIZE_EXPAND_FILL
+	_activity_dock.add_child(_activity_list)
+	var setup_title := Label.new()
+	setup_title.text = "Setup help"
+	_activity_dock.add_child(setup_title)
+	var setup_help := RichTextLabel.new()
+	setup_help.name = "SetupHelp"
+	setup_help.fit_content = true
+	setup_help.custom_minimum_size = Vector2(320, 96)
+	setup_help.text = "Claude Code / Codex: install the Godot Agent Loop plugin\nOpenCode: godot-agent-loop setup opencode --write\nPi: pi install npm:@beremaran/godot-agent-loop\nRelaunch the editor through the MCP launch_editor tool to authenticate."
+	_activity_dock.add_child(setup_help)
+	add_control_to_dock(DOCK_SLOT_RIGHT_BL, _activity_dock)
+
+func _set_connection_status(message: String) -> void:
+	if _connection_status != null:
+		_connection_status.text = "Connection: %s" % message
+
+func _toggle_driver_pause() -> void:
+	_driver_paused = not _driver_paused
+	_update_driver_controls()
+
+func _update_driver_controls() -> void:
+	if _driver_status != null:
+		_driver_status.text = "Agent paused — human editing" if _driver_paused else "Agent is driving"
+	if _driver_pause_button != null:
+		_driver_pause_button.text = "Resume Agent" if _driver_paused else "Pause Agent"
+		_driver_pause_button.tooltip_text = "Allow subsequent MCP mutations" if _driver_paused else "Refuse subsequent MCP mutations while you edit"
+
+func _driver_state() -> Dictionary:
+	return {"success": true, "paused": _driver_paused, "agent_driving": not _driver_paused}
+
+func _record_activity(params: Dictionary) -> Dictionary:
+	var event: String = str(params.get("event", ""))
+	if not event in ["request_started", "request_finished", "request_timed_out"]:
+		return {"error": "invalid_activity_event"}
+	var command: String = str(params.get("command", "unknown"))
+	var target: String = str(params.get("target", "game"))
+	var outcome: String = str(params.get("outcome", "running"))
+	var raw_duration_ms: Variant = params.get("duration_ms", 0)
+	var duration_ms: int = 0
+	if raw_duration_ms is int:
+		duration_ms = raw_duration_ms
+	elif raw_duration_ms is float:
+		var float_duration_ms: float = raw_duration_ms
+		duration_ms = roundi(float_duration_ms)
+	var correlation_id: String = str(params.get("correlation_id", ""))
+	var marker: String = "…" if event == "request_started" else "✓" if outcome == "success" else "✗"
+	var suffix: String = "" if event == "request_started" else " · %d ms" % duration_ms
+	var text: String = "%s %s → %s%s" % [marker, command, target, suffix]
+	var entry: Dictionary = {
+		"event": event, "correlation_id": correlation_id, "command": command,
+		"target": target, "outcome": outcome, "duration_ms": duration_ms, "text": text,
+	}
+	_activity_entries.append(entry)
+	var item_index: int = _activity_list.add_item(text)
+	_activity_list.set_item_tooltip(item_index, correlation_id)
+	if event != "request_started":
+		var color := Color(0.35, 0.85, 0.45) if outcome == "success" else Color(1.0, 0.4, 0.35)
+		_activity_list.set_item_custom_fg_color(item_index, color)
+	while _activity_entries.size() > MAX_ACTIVITY_ENTRIES:
+		_activity_entries.pop_front()
+		_activity_list.remove_item(0)
+	return {"success": true, "activity_count": _activity_entries.size()}
+
+func _sync_filesystem(params: Dictionary) -> Dictionary:
+	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
+	filesystem.scan()
+	var scene_path: String = str(params.get("scene_path", ""))
+	var root: Node = EditorInterface.get_edited_scene_root()
+	var reloaded: bool = false
+	if root != null and not scene_path.is_empty() and root.scene_file_path == scene_path:
+		EditorInterface.reload_scene_from_path(scene_path)
+		reloaded = true
+	var focus_path: String = str(params.get("focus_path", ""))
+	var focused: bool = false
+	if reloaded and not focus_path.is_empty():
+		focused = _focus_editor_node(focus_path)
+	_last_filesystem_sync = {
+		"success": true, "rescanned": true, "scene_path": scene_path,
+		"resource_path": str(params.get("resource_path", "")), "reloaded": reloaded,
+		"command": str(params.get("command", "")), "focus_path": focus_path,
+		"focused": focused,
+	}
+	return _last_filesystem_sync.duplicate(true)
+
+func _inspect() -> Dictionary:
+	var root: Node = EditorInterface.get_edited_scene_root()
+	var selected: Array[String] = []
+	var selection: EditorSelection = EditorInterface.get_selection()
+	for node: Node in selection.get_selected_nodes():
+		selected.append(str(node.get_path()))
+	var open_scenes: Array = []
+	var open_result: Variant = EditorInterface.get_open_scenes()
+	if open_result is PackedStringArray:
+		var packed_open_scenes: PackedStringArray = open_result
+		open_scenes.assign(packed_open_scenes)
+	var edited_root: Variant = null
+	if root != null:
+		edited_root = {"name": root.name, "type": root.get_class(), "path": str(root.get_path())}
+	return {"success": true, "edited_scene": "" if root == null else str(root.scene_file_path),
+		"edited_root": edited_root,
+		"selection": selected, "open_scenes": open_scenes,
+		"has_undo_redo": EditorInterface.get_editor_undo_redo() != null,
+		"activity_dock": _activity_dock != null, "activity": _activity_entries.duplicate(true),
+		"driver_paused": _driver_paused, "agent_driving": not _driver_paused,
+		"authenticated": _session_authenticated, "server_version": _server_version,
+		"addon_version": ADDON_VERSION, "protocol_version": PROTOCOL_VERSION,
+		"godot_version": Engine.get_version_info().get("string", "unknown"),
+		"last_filesystem_sync": _last_filesystem_sync.duplicate(true)}
+
+func _select(params: Dictionary) -> Dictionary:
+	var selection: EditorSelection = EditorInterface.get_selection()
+	selection.clear()
+	var root: Node = EditorInterface.get_edited_scene_root()
+	if root == null:
+		return {"error": "no_edited_scene"}
+	var selected: Array[String] = []
+	var paths: Variant = params.get("node_paths", [])
+	if not paths is Array:
+		return {"error": "node_paths must be an array"}
+	for raw_path: Variant in paths:
+		var node: Node = root.get_node_or_null(NodePath(str(raw_path)))
+		if node == null:
+			return {"error": "node_not_found", "node_path": str(raw_path)}
+		selection.add_node(node)
+		selected.append(str(node.get_path()))
+		if selected.size() == 1:
+			EditorInterface.edit_node(node)
+	return {"success": true, "selection": selected}
+
+func _focus_editor_node(path: String) -> bool:
+	var root: Node = EditorInterface.get_edited_scene_root()
+	if root == null:
+		return false
+	var normalized: String = path.trim_prefix("root/")
+	var node: Node = root if normalized == "." or normalized == "root" or normalized.is_empty() else root.get_node_or_null(NodePath(normalized))
+	if node == null:
+		return false
+	var selection: EditorSelection = EditorInterface.get_selection()
+	selection.clear()
+	selection.add_node(node)
+	EditorInterface.edit_node(node)
+	return true
+
+func _set_property(params: Dictionary) -> Dictionary:
+	var target: Node = _edited_node(params)
+	var property: String = str(params.get("property", ""))
+	if target == null: return {"error": "node_not_found"}
+	if property.is_empty() or not property in target: return {"error": "property_not_found", "property": property}
+	var before: Variant = target.get(property)
+	var after: Variant = params.get("value")
+	return _commit_property_action(target, property, before, after)
+
+func _rename_node(params: Dictionary) -> Dictionary:
+	var target: Node = _edited_node(params)
+	var new_name: String = str(params.get("name", ""))
+	if target == null: return {"error": "node_not_found"}
+	if new_name.is_empty() or not NodePath(new_name).is_absolute() and new_name.contains("/"):
+		return {"error": "invalid_name"}
+	var before: String = target.name
+	return _commit_property_action(target, "name", before, new_name)
+
+func _edited_node(params: Dictionary) -> Node:
+	var root: Node = EditorInterface.get_edited_scene_root()
+	if root == null: return null
+	var path: String = str(params.get("node_path", "."))
+	return root if path == "." or path.is_empty() else root.get_node_or_null(NodePath(path))
+
+func _commit_property_action(target: Node, property: String, before: Variant, after: Variant) -> Dictionary:
+	var manager: EditorUndoRedoManager = EditorInterface.get_editor_undo_redo()
+	if manager == null: return {"error": "undo_redo_unavailable"}
+	manager.create_action("MCP %s" % property)
+	manager.add_do_property(target, property, after)
+	manager.add_undo_property(target, property, before)
+	manager.commit_action()
+	_last_history_id = manager.get_object_history_id(target)
+	return {"success": true, "property": property, "before": before, "after": target.get(property), "undo_recorded": true}
+
+func _send(response: Dictionary) -> void:
+	if _peer == null:
+		return
+	var send_error: Error = _peer.put_data((JSON.stringify(response) + "\n").to_utf8_buffer())
+	if send_error != OK:
+		push_warning("Godot Agent Loop editor bridge send failed: %s" % error_string(send_error))
+
+func _read_port() -> int:
+	var configured: String = OS.get_environment("GODOT_MCP_EDITOR_PORT")
+	if configured.is_valid_int():
+		var value: int = int(configured)
+		if value > 0 and value < 65536: return value
+	return _port

package/agent-plugin/.claude-plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
+  "name": "godot-agent-loop",
+  "displayName": "Godot Agent Loop",
+  "version": "1.0.0",
+  "description": "Build, playtest, and prove Godot games with an evidence-first MCP automation loop.",
+  "author": {
+    "name": "Berke Arslan"
+  },
+  "homepage": "https://github.com/beremaran/godot-agent-loop",
+  "repository": "https://github.com/beremaran/godot-agent-loop",
+  "license": "MIT",
+  "keywords": [
+    "godot",
+    "mcp",
+    "game-development"
+  ],
+  "mcpServers": "./.mcp.json"
+}

package/agent-plugin/.codex-plugin/plugin.json

@@ -0,0 +1,37 @@
+{
+  "name": "godot-agent-loop",
+  "version": "1.0.0",
+  "description": "Build, playtest, and prove Godot games with an evidence-first MCP automation loop.",
+  "author": {
+    "name": "Berke Arslan",
+    "url": "https://github.com/beremaran"
+  },
+  "homepage": "https://github.com/beremaran/godot-agent-loop",
+  "repository": "https://github.com/beremaran/godot-agent-loop",
+  "license": "MIT",
+  "keywords": [
+    "godot",
+    "mcp",
+    "game-development"
+  ],
+  "skills": "./skills/",
+  "mcpServers": "./.mcp.json",
+  "interface": {
+    "displayName": "Godot Agent Loop",
+    "shortDescription": "Build, playtest, and prove Godot games",
+    "longDescription": "Build, playtest, and prove Godot games with an evidence-first MCP automation loop.",
+    "developerName": "Berke Arslan",
+    "category": "Developer Tools",
+    "capabilities": [
+      "Read",
+      "Write"
+    ],
+    "websiteURL": "https://github.com/beremaran/godot-agent-loop",
+    "defaultPrompt": [
+      "Build a small playable Godot game and prove both its win and lose states.",
+      "Debug this Godot project from a reproducible failure and verify the fix independently.",
+      "Prepare this Godot game for release and report export evidence and remaining gates."
+    ],
+    "brandColor": "#478CBF"
+  }
+}

package/agent-plugin/.mcp.json

@@ -0,0 +1,14 @@
+{
+  "mcpServers": {
+    "godot-agent-loop": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@beremaran/godot-agent-loop@1.0.0"
+      ],
+      "env": {
+        "GODOT_MCP_TOOL_SURFACE": "compact"
+      }
+    }
+  }
+}

package/agent-plugin/adapter-manifest.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "../docs/agent-adapter.schema.json",
+  "name": "godot-agent-loop",
+  "displayName": "Godot Agent Loop",
+  "version": "1.0.0",
+  "description": "Build, playtest, and prove Godot games with an evidence-first MCP automation loop.",
+  "package": "@beremaran/godot-agent-loop",
+  "mcp": {
+    "command": ["npx", "-y", "@beremaran/godot-agent-loop@1.0.0"],
+    "environment": {
+      "GODOT_MCP_TOOL_SURFACE": "compact"
+    },
+    "defaultToolCount": 39,
+    "discoveryTool": "godot_tools"
+  },
+  "skills": [
+    {
+      "name": "build-godot-game",
+      "description": "Build a new playable Godot 4 game or substantial gameplay slice through Godot Agent Loop. Use for requests to create a game from an empty project or project path, add a complete mechanic, or deliver a playable scene with input, visible state, and win/lose behavior."
+    },
+    {
+      "name": "debug-godot-game",
+      "description": "Diagnose and fix a Godot 4 game that crashes, logs errors, renders incorrectly, ignores input, has wrong scene state, or fails a gameplay expectation. Use for runtime bugs, script failures, broken scenes/resources, flaky behavior, and regressions that need reproduction before repair."
+    },
+    {
+      "name": "ship-godot-game",
+      "description": "Prepare and verify a Godot 4 game for a reproducible release. Use for export readiness, project test gates, .NET/C# verification, addon and import integrity, export artifact inspection, smoke runs, release evidence, or deterministic teardown before shipping."
+    },
+    {
+      "name": "verify-godot-change",
+      "description": "Verify a Godot 4 project change with static checks and independent evidence from the running game. Use after editing scenes, scripts, resources, input, UI, rendering, or gameplay, and when deciding whether a Godot task is genuinely complete."
+    }
+  ],
+  "defaultPrompts": [
+    "Build a small playable Godot game and prove both its win and lose states.",
+    "Debug this Godot project from a reproducible failure and verify the fix independently.",
+    "Prepare this Godot game for release and report export evidence and remaining gates."
+  ],
+  "clients": {
+    "claudeCode": { "manifest": ".claude-plugin/plugin.json" },
+    "codex": { "manifest": ".codex-plugin/plugin.json" },
+    "openCode": { "setupCommand": "godot-agent-loop setup opencode" },
+    "pi": { "extension": "pi/extension.ts" }
+  }
+}