breakpoint-mcp 1.12.1 → 1.14.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. **270 tools
+editor, Godot's own LSP + DAP, and a runtime bridge inside the running game. **271 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,11 +687,13 @@ 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(),
         mode: z.string(),
         count: z.number(),
+        persisted: z.boolean(),
         instances: z.array(z.object({ index: z.number(), instance_path: z.string() })),
     },
     card_deck_from_table: {
@@ -699,6 +702,7 @@ export const outputSchemas = {
         rows_read: z.number(),
         rows_skipped: z.number(),
         unmapped_columns: z.array(z.string()),
+        persisted: z.boolean(),
         instances: z.array(z.object({ row_index: z.number(), instance_path: z.string() })),
     },
     card_set_face: {
@@ -769,6 +773,7 @@ export const outputSchemas = {
         unbound: z.array(z.string()),
         placed: z.boolean(),
         cell: z.string().nullable(),
+        persisted: z.boolean(),
     },
     piece_move: {
         moved: z.boolean(),

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,30 +479,46 @@ 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;
     const base = sceneRootName(args.template_path);
     const places = computeLayout(args.mode, args.cards.length, args);
+    // Finding-A save-persistence (opt-in), threaded per-card through emitOneCard: when
+    // set, every card in the hand gets Editable Children so its bound slot data serializes
+    // on save instead of reverting on reload. Default off keeps the runtime-bound contract.
+    const persisted = args.persist === true;
     const instances = [];
     for (let i = 0; i < args.cards.length; i++) {
         const { instance_path } = await emitOneCard(emit, {
             template_path: args.template_path, parent: container, data: args.cards[i].data,
             name: `${base}_${i}`, face_up: args.cards[i].face_up ?? true, placement: places[i],
+            persist: args.persist,
         });
         instances.push({ index: i, instance_path });
     }
-    return { container_path: container, mode: args.mode, count: instances.length, instances };
+    return { container_path: container, mode: args.mode, count: instances.length, persisted, instances };
 }
 export async function emitDeckFromTable(emit, readFile, args) {
     const container = args.parent === "" ? "." : args.parent;
@@ -547,13 +563,15 @@ export async function emitDeckFromTable(emit, readFile, args) {
         const { instance_path } = await emitOneCard(emit, {
             template_path: args.template_path, parent: container, data, name, face_up,
             placement: args.layout ? places[i] : undefined,
+            persist: args.persist,
         });
         instances.push({ row_index: allRows.indexOf(row), instance_path });
     }
     const unmapped_columns = [...header].filter((c) => !referenced.has(c)).sort();
     return {
         deck_container: container, count: instances.length, rows_read,
-        rows_skipped: rows_read - instances.length, unmapped_columns, instances,
+        rows_skipped: rows_read - instances.length, unmapped_columns,
+        persisted: args.persist === true, instances,
     };
 }
 /**
@@ -1012,13 +1030,25 @@ export async function emitPieceInstance(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: [face_up] });
     const { bound, unbound } = splitFromCall(res, args.data);
+    // Finding-A save-persistence (opt-in), mirroring card_instance. set_data mutates the
+    // piece's internal Art/Label nodes, but a sealed sub-scene doesn't serialize those
+    // overrides, so they revert on reload. Enabling "Editable Children" bakes them into the
+    // saved scene. Emitted last, on the piece's final resting path (after any place_on
+    // reparent). Default off preserves the lighter runtime-bound contract.
+    const persisted = args.persist === true;
     if (args.place_on) {
         const placed = await emitBoardPlace(emit, {
             board: args.place_on.board, cell: args.place_on.cell, node: instPath, align: args.place_on.align,
         });
-        return { instance_path: placed.node_path, face_up, bound, unbound, placed: true, cell: args.place_on.cell };
+        if (persisted) {
+            await emit("node.set_editable_instance", { path: placed.node_path, editable: true });
+        }
+        return { instance_path: placed.node_path, face_up, bound, unbound, placed: true, cell: args.place_on.cell, persisted };
+    }
+    if (persisted) {
+        await emit("node.set_editable_instance", { path: instPath, editable: true });
     }
-    return { instance_path: instPath, face_up, bound, unbound, placed: false, cell: null };
+    return { instance_path: instPath, face_up, bound, unbound, placed: false, cell: null, persisted };
 }
 /**
  * Move a piece onto a destination cell (reusing `board_place` for the reparent +
@@ -1380,6 +1410,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;
@@ -1404,6 +1435,7 @@ export function registerTabletopTools(server, bridge, config) {
             })).min(1).describe("One entry per card to instance"),
             mode: z.enum(["row", "fan", "stack", "grid"]).describe("Arrangement mode"),
             ...layoutKnobs,
+            persist: z.boolean().optional().describe("Bake each card's bound slot data into the saved scene by enabling Editable Children on every instanced card (default false = runtime-bound only, reverts on reload)"),
         },
     }, async (raw) => {
         const a = raw;
@@ -1440,6 +1472,7 @@ export function registerTabletopTools(server, bridge, config) {
                 align: z.enum(["start", "center", "end"]).optional(),
                 origin: z.object({ x: z.number(), y: z.number() }).optional(),
             }).optional().describe("Optional arrangement (same knobs as card_hand_layout); omitted → stacked at origin"),
+            persist: z.boolean().optional().describe("Bake each stamped card's bound slot data into the saved scene by enabling Editable Children on every card (default false = runtime-bound only, reverts on reload)"),
         },
     }, async (raw) => {
         const a = raw;
@@ -1665,6 +1698,7 @@ export function registerTabletopTools(server, bridge, config) {
                 cell: z.string().describe("Cell id to place onto (resolves to <board>/cell_<cell>)"),
                 align: z.object({ x: z.number(), y: z.number() }).optional().describe("Offset from the cell origin in px (default centred)"),
             }).optional().describe("Optionally place the new piece on a board cell in the same call"),
+            persist: z.boolean().optional().describe("Bake the bound 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.1",
+  "version": "1.14.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",