breakpoint-mcp 1.12.0 → 1.13.0

package/README.md

@@ -3,7 +3,7 @@
 The MCP **host** for [Breakpoint MCP](https://github.com/jlivingston-Cipher/godot-breakpoint-mcp) —
 a [Model Context Protocol](https://modelcontextprotocol.io) server that exposes the
 Godot game engine to AI coding assistants across four planes: headless CLI, the live
-editor, Godot's own LSP + DAP, and a runtime bridge inside the running game. **258 tools
+editor, Godot's own LSP + DAP, and a runtime bridge inside the running game. **270 tools
 + 5 MCP resources**, built against the stable `@modelcontextprotocol/sdk` 1.x API.
 Developed and tested with **Claude**; because MCP is an open protocol, other clients can
 connect too (currently untested — reports welcome).

package/addon/breakpoint_mcp/operations.gd

@@ -85,6 +85,8 @@ func dispatch(method: String, params: Dictionary) -> Dictionary:
 			return _node_change_type(params)
 		"node.set_owner":
 			return _node_set_owner(params)
+		"node.set_editable_instance":
+			return _node_set_editable_instance(params)
 		"node.call_method":
 			return _node_call_method(params)
 		"node.get_path":
@@ -1129,6 +1131,40 @@ func _node_set_owner(params: Dictionary) -> Dictionary:
 	return _ok({"path": _path_of(root, node), "owner": owner_out})
 
 
+## Toggle "Editable Children" on an instanced sub-scene. When enabled, property
+## overrides on the instance's INTERNAL nodes serialize into the owning scene on
+## save (otherwise the sub-scene is sealed and its internals revert on reload).
+## The flag lives on the owning scene's state, so it is set on the instance's
+## owner (the scene root that will save it), which is where is_editable_instance
+## reads it. This is what lets card_instance bake author-time slot data.
+func _node_set_editable_instance(params: Dictionary) -> Dictionary:
+	var root := _edited_root()
+	if root == null:
+		return _err("no_scene", "No scene is open")
+	var node := _resolve(root, String(params.get("path", "")))
+	if node == null:
+		return _err("bad_path", "Node not found: %s" % params.get("path", ""))
+	if node == root:
+		return _err("refused", "The scene root is not an instance")
+	if node.scene_file_path == "":
+		return _err("refused", "Node is not an instanced sub-scene (no scene_file_path); editable-instance applies only to scene instances")
+	var owner_node: Node = node.owner
+	if owner_node == null:
+		return _err("refused", "Node has no owner; it is not saved into a scene, so editable-instance has nothing to record against")
+	var editable := bool(params.get("editable", true))
+	var old_editable := owner_node.is_editable_instance(node)
+	var ur := _plugin.get_undo_redo()
+	ur.create_action("Breakpoint: set editable-instance of %s" % node.name)
+	ur.add_do_method(owner_node, "set_editable_instance", node, editable)
+	ur.add_undo_method(owner_node, "set_editable_instance", node, old_editable)
+	ur.commit_action()
+	return _ok({
+		"path": _path_of(root, node),
+		"editable": owner_node.is_editable_instance(node),
+		"owner": _path_of(root, owner_node),
+	})
+
+
 func _node_call_method(params: Dictionary) -> Dictionary:
 	var root := _edited_root()
 	if root == null:

package/dist/schemas.js

@@ -127,6 +127,7 @@ export const outputSchemas = {
     node_move_child: { path: z.string(), index: z.number() },
     node_change_type: { path: z.string(), name: z.string(), type: z.string(), old_type: z.string() },
     node_set_owner: { path: z.string(), owner: z.string().nullable() },
+    node_set_editable_instance: { path: z.string(), editable: z.boolean(), owner: z.string() },
     node_call_method: { path: z.string(), method: z.string(), result: encodedValue },
     node_get_path: {
         path: z.string(), name: z.string(), type: z.string(),
@@ -686,6 +687,7 @@ export const outputSchemas = {
         face_up: z.boolean(),
         bound: z.array(z.string()),
         unbound: z.array(z.string()),
+        persisted: z.boolean(),
     },
     card_hand_layout: {
         container_path: z.string(),

package/dist/tools/editor/node.js

@@ -141,6 +141,16 @@ export function registerNodeTools(server, call) {
             owner_path: z.string().optional().describe("Ancestor to own the node; \".\" or omitted for the scene root"),
         },
     }, async ({ path, owner_path }) => call("node.set_owner", owner_path !== undefined ? { path, owner_path } : { path }));
+    server.registerTool("node_set_editable_instance", {
+        title: "Set editable-instance (editable children)",
+        description: "Toggle \"Editable Children\" on an instanced sub-scene (undoable). When enabled, property overrides on the instance's " +
+            "internal nodes serialize into the saved scene; without it the sub-scene is sealed and its internals revert on reload. " +
+            "This is what lets author-time edits (e.g. card_instance slot data) be baked into the .tscn.",
+        inputSchema: {
+            path: z.string().describe("Node path of the instanced sub-scene, relative to the scene root"),
+            editable: z.boolean().optional().describe("Enable (true, default) or disable editable children"),
+        },
+    }, async ({ path, editable }) => call("node.set_editable_instance", { path, editable: editable ?? true }));
     server.registerTool("node_call_method", {
         title: "Call node method (edit-time)",
         description: "Invoke a method on a node in the EDITED scene. DESTRUCTIVE (arbitrary invocation, not undoable) — gated by confirmation. " +

package/dist/tools/tabletop.js

@@ -479,16 +479,27 @@ async function emitOneCard(emit, args) {
     }
     const res = await emit("node.call_method", { path: instPath, method: "set_data", args: [args.data] });
     await emit("node.call_method", { path: instPath, method: "set_face", args: [args.face_up] });
-    return { instance_path: instPath, ...splitFromCall(res, args.data) };
+    // Finding-A save-persistence (opt-in). set_data mutates the instance's internal
+    // slot nodes, but a sealed sub-scene doesn't serialize those overrides, so the
+    // data reverts on reload. Enabling "Editable Children" makes the overrides
+    // serialize into the saved scene → authored card data survives a reload.
+    // Default off preserves the lighter runtime-bound contract (cards populated at
+    // load via set_data), which is correct for gameplay decks.
+    const persisted = args.persist === true;
+    if (persisted) {
+        await emit("node.set_editable_instance", { path: instPath, editable: true });
+    }
+    return { instance_path: instPath, ...splitFromCall(res, args.data), persisted };
 }
 export async function emitCardInstance(emit, args) {
     const face_up = args.face_up ?? true;
     const name = args.name ?? sceneRootName(args.template_path);
-    const { instance_path, bound, unbound } = await emitOneCard(emit, {
+    const { instance_path, bound, unbound, persisted } = await emitOneCard(emit, {
         template_path: args.template_path, parent: args.parent, data: args.data, name, face_up,
         placement: args.position ? { x: args.position.x, y: args.position.y } : undefined,
+        persist: args.persist,
     });
-    return { instance_path, face_up, bound, unbound };
+    return { instance_path, face_up, bound, unbound, persisted };
 }
 export async function emitCardHand(emit, args) {
     const container = args.parent === "" ? "." : args.parent;
@@ -1380,6 +1391,7 @@ export function registerTabletopTools(server, bridge, config) {
             position: z.object({ x: z.number(), y: z.number() }).optional().describe("Local position of the instance"),
             face_up: z.boolean().optional().describe("Show the face (default true); false shows the back on two-sided cards"),
             name: z.string().optional().describe("Optional node name for the instance"),
+            persist: z.boolean().optional().describe("Bake the bound slot data into the saved scene by enabling Editable Children on the instance (default false = runtime-bound only, reverts on reload)"),
         },
     }, async (raw) => {
         const a = raw;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "breakpoint-mcp",
-  "version": "1.12.0",
+  "version": "1.13.0",
   "description": "MCP server exposing Godot to AI coding assistants over the Model Context Protocol — developed and tested with Claude — across four planes (CLI, live editor, LSP+DAP, runtime) with elicitation-gated destructive tools, long jobs on the formal MCP task model, captured console output, and MCP resources.",
   "type": "module",
   "license": "MIT",