breakpoint-mcp 1.13.0 → 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/dist/schemas.js

@@ -693,6 +693,7 @@ export const outputSchemas = {
         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: {
@@ -701,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: {
@@ -771,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/tabletop.js

@@ -505,15 +505,20 @@ 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;
@@ -558,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,
     };
 }
 /**
@@ -1023,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 +
@@ -1416,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;
@@ -1452,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;
@@ -1677,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.13.0",
+  "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",