gdharness 0.13.38 → 0.13.40

package/build/cli.js

@@ -15373,7 +15373,7 @@ function buildToolDefinitions() {
     };
   });
 }
-var PROJECT_INFO_SECTIONS, PROJECT_PATH, RUNNING_PROJECT_PATH, SCENE_PATH, SCRIPT_PATH, RESOURCE_PATH, NODE_PATH, PROPERTIES, XY, ANIMATION_TRACK, SCRIPT_MODIFICATIONS, INPUT_EVENTS, TILESET_SOURCES, TILEMAP_CELLS, COLOUR, TOOL_SPECS, SPECS_BY_NAME;
+var PROJECT_INFO_SECTIONS, PROJECT_PATH, RUNNING_PROJECT_PATH, RUNNING_PID, SCENE_PATH, SCRIPT_PATH, RESOURCE_PATH, NODE_PATH, PROPERTIES, XY, ANIMATION_TRACK, SCRIPT_MODIFICATIONS, INPUT_EVENTS, TILESET_SOURCES, TILEMAP_CELLS, COLOUR, TOOL_SPECS, SPECS_BY_NAME;
 var init_tool_definitions = __esm(() => {
   PROJECT_INFO_SECTIONS = [
     "autoloads",
@@ -15391,6 +15391,10 @@ var init_tool_definitions = __esm(() => {
     type: "string",
     description: "Which game, when more than one is running: the project directory it was started from. Not needed with one game."
   };
+  RUNNING_PID = {
+    type: "number",
+    description: "Which game, when several are running from one project, such as a bench and its workers: its process id, as editor_status lists under runtimes. Not needed with one game per project."
+  };
   SCENE_PATH = {
     type: "string",
     description: 'Scene file inside the project, such as "scenes/main.tscn" or "res://scenes/main.tscn".'
@@ -16029,7 +16033,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_output",
-      description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. Answers with the counts and the verdict as well as the entries. A run that has quit still answers here, with running false and its exit code, until the next one starts. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering.",
+      description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. Answers with the counts and the verdict as well as the entries. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering.",
       parameters: {
         severity: {
           type: "string",
@@ -16057,7 +16061,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_status",
-      description: 'Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means "not reached yet" as often as it means "no editor". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it.',
+      description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it.",
       parameters: {},
       requires: []
     },
@@ -16114,6 +16118,7 @@ var init_tool_definitions = __esm(() => {
       description: "Questions about the running game: what is written on the screen, the scene tree, the nodes matching a query, where one node is on screen, what one property reads, or the performance metrics. Needs the game running with the runtime addon.",
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
+        pid: RUNNING_PID,
         nodePath: {
           type: "string",
           ops: ["tree", "text", "find", "rect", "property"],
@@ -16192,6 +16197,7 @@ var init_tool_definitions = __esm(() => {
       description: "Sets a property or calls a method on a node in the running game. Needs the game running with the runtime addon.",
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
+        pid: RUNNING_PID,
         nodePath: { type: "string", description: 'Absolute node path, such as "/root/Main/Player".' },
         property: {
           type: "string",
@@ -16231,6 +16237,7 @@ var init_tool_definitions = __esm(() => {
       description: "A picture of the running game: the whole screen or one viewport, as an image. Needs the game running with a window.",
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
+        pid: RUNNING_PID,
         viewportPath: {
           type: "string",
           ops: ["viewport"],
@@ -16251,6 +16258,7 @@ var init_tool_definitions = __esm(() => {
       description: "Input to the running game: a whole click on a Control or a 3D node named by path, an item chosen out of a menu, typing into whatever has the focus, or a raw action, key, mouse button or mouse motion. All of it works headless, where the window is 64 by 64 and the GUI only takes what is inside it.",
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
+        pid: RUNNING_PID,
         nodePath: {
           type: "string",
           ops: ["click", "choose"],
@@ -16347,6 +16355,7 @@ var init_tool_definitions = __esm(() => {
       description: "Lets the running game get on with it and answers when something has happened: a number of frames, a signal, a property reaching a value, or words appearing on a screen. Needs the game running with the runtime addon.",
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
+        pid: RUNNING_PID,
         frames: {
           type: "number",
           ops: ["frames"],
@@ -16382,7 +16391,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "debug_breakpoint",
-      description: "Sets or removes a breakpoint through the editor's debug adapter. Needs the editor, not a running game: set them first, then editor_run, and the game stops where you asked.",
+      description: "Sets or removes a breakpoint through the editor's debug adapter. Needs the editor, not a running game: set them first, then editor_run, and the game stops where you asked. The editor keeps a breakpoint set this way for one play, so every breakpoint this server holds is sent again before each play editor_run starts, and the start answer lists them under breakpoints. The set is also kept in the project, for the server that comes after a reconnect: a breakpoint stays until it is removed here, whichever server set it. Every answer lists the whole set under held, and the breakpoints the user set in the editor's own gutter under setInEditor; setting one here never takes those away, and removing a line here clears it whoever set it. Godot clears every breakpoint in the editor when a debug session opens unless network/debug_adapter/sync_breakpoints is on, which the addon turns on as it loads; an editor running an older addon is said so under breakpointsAtRisk, here and in editor_status.",
       parameters: {
         projectPath: PROJECT_PATH,
         scriptPath: SCRIPT_PATH,
@@ -16407,7 +16416,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "debug_state",
-      description: "Where the debugged game is stopped: the stack trace, what is in scope at a frame with the values, or the debug adapter's console output so far.",
+      description: "Where the debugged game is stopped: the stack trace, what is in scope at a frame with the values, or the debug adapter's console output so far. A stop is reported by the editor's adapter only to the sessions connected when it happened, so a server that connected afterwards, which is every server after a reconnect, is shown a thread and no frames about a game still sitting at its breakpoint. That server asks the runtime instead: a held game accepts a connection and never answers, and the refusal then says held rather than running, and that the stack cannot be read from here. debug_control continue lets it go, and the next stop is one this session is told about, with its stack.",
       parameters: {
         frameId: {
           type: "number",
@@ -31179,15 +31188,77 @@ var init_stdio2 = __esm(() => {
   init_stdio();
 });
 
-// src/bridge-announce.ts
+// src/breakpoint-note.ts
 import { mkdirSync as mkdirSync6, readFileSync as readFileSync10, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname7, join as join12 } from "node:path";
+import { dirname as dirname7, isAbsolute as isAbsolute2, join as join12, relative as relative2 } from "node:path";
+function breakpointNotePath(projectPath) {
+  return join12(projectPath, ".godot", "gdharness-breakpoints.json");
+}
+function writeBreakpointNote(projectPath, held) {
+  const path = breakpointNotePath(projectPath);
+  const root = realPathOr(projectPath);
+  const inside = held.map((one) => ({ scriptPath: realPathOr(one.scriptPath), lines: one.lines })).filter((one) => one.lines.length > 0 && withinProject(root, one.scriptPath));
+  try {
+    if (inside.length === 0) {
+      rmSync6(path, { force: true });
+      return;
+    }
+    const note = {
+      breakpoints: inside.map((one) => ({
+        script: relative2(root, one.scriptPath).replaceAll("\\", "/"),
+        lines: [...one.lines]
+      }))
+    };
+    mkdirSync6(dirname7(path), { recursive: true });
+    writeFileSync8(path, `${JSON.stringify(note, null, 2)}
+`, "utf8");
+  } catch (error) {
+    console.error(`[SERVER] Could not record the breakpoints at ${path}: ${errorMessage(error)}`);
+  }
+}
+function readBreakpointNote(projectPath) {
+  try {
+    const parsed = JSON.parse(readFileSync10(breakpointNotePath(projectPath), "utf8"));
+    if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.breakpoints)) {
+      return [];
+    }
+    const held = [];
+    for (const entry of parsed.breakpoints) {
+      if (typeof entry !== "object" || entry === null) {
+        continue;
+      }
+      const { script, lines: listed } = entry;
+      if (typeof script !== "string" || isAbsolute2(script) || script.split("/").includes("..")) {
+        continue;
+      }
+      const lines = Array.isArray(listed) ? listed.filter((line) => Number.isInteger(line) && line > 0) : [];
+      if (lines.length > 0) {
+        held.push({ scriptPath: realPathOr(join12(projectPath, script)), lines });
+      }
+    }
+    return held;
+  } catch {
+    return [];
+  }
+}
+function withinProject(projectPath, scriptPath) {
+  const rel = relative2(projectPath, scriptPath);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute2(rel);
+}
+var init_breakpoint_note = __esm(() => {
+  init_errors();
+  init_paths();
+});
+
+// src/bridge-announce.ts
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync11, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname8, join as join13 } from "node:path";
 function announcementPath(projectPath) {
-  return join12(projectPath, ".godot", "gdharness-bridge.json");
+  return join13(projectPath, ".godot", "gdharness-bridge.json");
 }
 function readAnnouncement(path) {
   try {
-    const parsed = JSON.parse(readFileSync10(path, "utf8"));
+    const parsed = JSON.parse(readFileSync11(path, "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -31206,7 +31277,7 @@ function announcementIsOurs(path) {
 function announceBridge(projectPath, bridge) {
   const path = announcementPath(projectPath);
   try {
-    mkdirSync6(dirname7(path), { recursive: true });
+    mkdirSync7(dirname8(path), { recursive: true });
     const announcement = {
       protocol: BRIDGE_ANNOUNCE_PROTOCOL,
       host: bridge.host,
@@ -31215,7 +31286,7 @@ function announceBridge(projectPath, bridge) {
       version: bridge.version,
       startedAt: new Date().toISOString()
     };
-    writeFileSync8(path, `${JSON.stringify(announcement, null, 2)}
+    writeFileSync9(path, `${JSON.stringify(announcement, null, 2)}
 `, "utf8");
     return path;
   } catch (error) {
@@ -31228,7 +31299,7 @@ function withdrawBridge(path) {
     return;
   }
   try {
-    rmSync6(path, { force: true });
+    rmSync7(path, { force: true });
   } catch (error) {
     console.error(`[SERVER] Could not withdraw the editor bridge announcement: ${errorMessage(error)}`);
   }
@@ -31239,16 +31310,16 @@ var init_bridge_announce = __esm(() => {
 });
 
 // src/config-pin.ts
-import { existsSync as existsSync10, readFileSync as readFileSync11 } from "node:fs";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync12 } from "node:fs";
+import { join as join14 } from "node:path";
 function versionsNamedInConfig(projectPath) {
-  const config = join13(projectPath, ".mcp.json");
+  const config = join14(projectPath, ".mcp.json");
   if (!existsSync10(config)) {
     return [];
   }
   let text;
   try {
-    text = readFileSync11(config, "utf8");
+    text = readFileSync12(config, "utf8");
     JSON.parse(text);
   } catch {
     return [];
@@ -31417,7 +31488,10 @@ class GodotDAPClient {
   attached = false;
   lastThreadId = 1;
   halt = null;
+  holdKnown = false;
   breakpoints = new Map;
+  inEditor = new Map;
+  onBreakpointsChanged = null;
   constructor(port = portFromEnv("GDHARNESS_DAP_PORT", DEFAULT_DAP_PORT), host = "127.0.0.1") {
     this.port = port;
     this.host = host;
@@ -31462,11 +31536,7 @@ class GodotDAPClient {
           this.failPendingRequests(error);
         });
         socket.on("close", () => {
-          this.connected = false;
-          this.initialized = false;
-          this.attached = false;
-          this.halt = null;
-          this.socket = null;
+          this.forgetConnection();
           this.failPendingRequests(new Error("DAP connection closed"));
         });
         resolve();
@@ -31482,10 +31552,7 @@ class GodotDAPClient {
   }
   async abandon() {
     if (!this.socket) {
-      this.connected = false;
-      this.initialized = false;
-      this.attached = false;
-      this.halt = null;
+      this.forgetConnection();
       return;
     }
     await new Promise((resolve) => {
@@ -31505,11 +31572,16 @@ class GodotDAPClient {
         resolve();
       }, 500);
     });
+    this.forgetConnection();
+  }
+  forgetConnection() {
     this.socket = null;
     this.connected = false;
     this.initialized = false;
     this.attached = false;
     this.halt = null;
+    this.holdKnown = false;
+    this.inEditor.clear();
   }
   async ensureConnected() {
     if (!this.connected) {
@@ -31598,6 +31670,37 @@ class GodotDAPClient {
         description: said(body, "description"),
         text: said(body, "text")
       };
+      this.holdKnown = true;
+      return;
+    }
+    if (eventName === "continued") {
+      this.halt = null;
+      this.holdKnown = true;
+      return;
+    }
+    if (eventName === "breakpoint") {
+      const body = event.body;
+      const breakpoint = body?.["breakpoint"];
+      const source = typeof breakpoint === "object" && breakpoint !== null ? breakpoint["source"] : undefined;
+      const path = typeof source === "object" && source !== null ? source["path"] : undefined;
+      const line = typeof breakpoint === "object" && breakpoint !== null ? breakpoint["line"] : undefined;
+      if (typeof path !== "string" || typeof line !== "number") {
+        return;
+      }
+      if (said(body, "reason") === "removed") {
+        this.inEditor.get(path)?.delete(line);
+        const held = this.breakpoints.get(path);
+        if (held?.delete(line) === true) {
+          if (held.size === 0) {
+            this.breakpoints.delete(path);
+          }
+          this.onBreakpointsChanged?.(this.breakpointsHeld());
+        }
+        return;
+      }
+      const known = this.inEditor.get(path) ?? new Set;
+      known.add(line);
+      this.inEditor.set(path, known);
       return;
     }
     if (eventName === "terminated" || eventName === "exited") {
@@ -31636,6 +31739,43 @@ class GodotDAPClient {
     await this.sendRequest("attach", {});
     await this.sendRequest("configurationDone", {});
     this.attached = true;
+    if (!this.holdKnown) {
+      await this.learnWhetherHeld();
+    }
+  }
+  async learnWhetherHeld() {
+    try {
+      const threads = await this.sendRequest("threads");
+      const listed = threads["threads"];
+      const first = Array.isArray(listed) ? listed[0]?.["id"] : undefined;
+      if (typeof first !== "number") {
+        return;
+      }
+      this.lastThreadId = first;
+      const response = await this.sendRequest("stackTrace", { threadId: first, startFrame: 0, levels: 1 });
+      if (this.holdKnown) {
+        return;
+      }
+      const frames = response["stackFrames"];
+      if (Array.isArray(frames) && frames.length > 0) {
+        this.halt = {
+          reason: "attached",
+          description: "held when this session attached; the stop that held it was reported to an earlier one",
+          text: ""
+        };
+        this.holdKnown = true;
+      }
+    } catch {}
+  }
+  holdIsKnown() {
+    return this.holdKnown;
+  }
+  learnedRunning() {
+    if (this.holdKnown) {
+      return;
+    }
+    this.halt = null;
+    this.holdKnown = true;
   }
   setOutputSink(sink) {
     this.onOutput = sink;
@@ -31648,38 +31788,96 @@ class GodotDAPClient {
     return lines;
   }
   async setBreakpoint(filePath, line) {
-    await this.ensureConnected();
-    await this.initialize();
-    const fileBreakpoints = this.breakpoints.get(filePath) ?? new Set;
-    fileBreakpoints.add(line);
-    this.breakpoints.set(filePath, fileBreakpoints);
-    const lines = Array.from(fileBreakpoints).sort((a, b) => a - b);
-    return await this.sendRequest("setBreakpoints", {
-      source: { path: filePath },
-      breakpoints: lines.map((breakpointLine) => ({ line: breakpointLine }))
-    });
+    const wanted = new Set(this.breakpoints.get(filePath) ?? []);
+    wanted.add(line);
+    return await this.sendBreakpoints(filePath, wanted);
   }
   async removeBreakpoint(filePath, line) {
+    const wanted = new Set(this.breakpoints.get(filePath) ?? []);
+    wanted.delete(line);
+    return await this.sendBreakpoints(filePath, wanted, line);
+  }
+  async sendBreakpoints(filePath, mine, clearing) {
     await this.ensureConnected();
     await this.initialize();
-    const fileBreakpoints = this.breakpoints.get(filePath) ?? new Set;
-    fileBreakpoints.delete(line);
-    if (fileBreakpoints.size === 0) {
-      this.breakpoints.delete(filePath);
-    } else {
-      this.breakpoints.set(filePath, fileBreakpoints);
+    const lines = new Set([...mine, ...this.inEditor.get(filePath) ?? []]);
+    if (clearing !== undefined) {
+      lines.delete(clearing);
     }
-    const remaining = Array.from(fileBreakpoints).sort((a, b) => a - b);
-    return await this.sendRequest("setBreakpoints", {
+    const sorted = Array.from(lines).sort((a, b) => a - b);
+    const answer = await this.sendRequest("setBreakpoints", {
       source: { path: filePath },
-      breakpoints: remaining.map((breakpointLine) => ({ line: breakpointLine }))
+      breakpoints: sorted.map((breakpointLine) => ({ line: breakpointLine }))
     });
+    if (mine.size === 0) {
+      this.breakpoints.delete(filePath);
+    } else {
+      this.breakpoints.set(filePath, new Set(mine));
+    }
+    if (lines.size === 0) {
+      this.inEditor.delete(filePath);
+    } else {
+      this.inEditor.set(filePath, lines);
+    }
+    return answer;
+  }
+  setBreakpointsSink(sink) {
+    this.onBreakpointsChanged = sink;
+  }
+  breakpointsInEditor() {
+    const theirs = [];
+    for (const [scriptPath, lines] of this.inEditor) {
+      const mine = this.breakpoints.get(scriptPath);
+      const rest = Array.from(lines).filter((line) => !mine?.has(line)).sort((a, b) => a - b);
+      if (rest.length > 0) {
+        theirs.push({ scriptPath, lines: rest });
+      }
+    }
+    return theirs;
+  }
+  async reapplyBreakpoints() {
+    const applied = [];
+    const refused = [];
+    for (const [filePath, lines] of Array.from(this.breakpoints)) {
+      try {
+        await this.sendBreakpoints(filePath, lines);
+        applied.push({ scriptPath: filePath, lines: Array.from(lines).sort((a, b) => a - b) });
+      } catch (error) {
+        this.breakpoints.delete(filePath);
+        refused.push({
+          scriptPath: filePath,
+          reason: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    if (refused.length > 0) {
+      this.onBreakpointsChanged?.(this.breakpointsHeld());
+    }
+    return { applied, refused };
+  }
+  breakpointsHeld() {
+    return Array.from(this.breakpoints, ([scriptPath, lines]) => ({
+      scriptPath,
+      lines: Array.from(lines).sort((a, b) => a - b)
+    }));
+  }
+  holdBreakpoints(held) {
+    for (const { scriptPath, lines } of held) {
+      const fileBreakpoints = this.breakpoints.get(scriptPath) ?? new Set;
+      for (const line of lines) {
+        fileBreakpoints.add(line);
+      }
+      if (fileBreakpoints.size > 0) {
+        this.breakpoints.set(scriptPath, fileBreakpoints);
+      }
+    }
   }
   async continue(threadId) {
     await this.attach();
     const resolvedThreadId = await this.resolveThreadId(threadId);
     await this.sendRequest("continue", { threadId: resolvedThreadId });
     this.halt = null;
+    this.holdKnown = true;
   }
   async stepOver(threadId) {
     await this.attach();
@@ -31778,11 +31976,7 @@ class GodotDAPClient {
   }
   failOversizedStream(detail) {
     const socket = this.socket;
-    this.socket = null;
-    this.connected = false;
-    this.initialized = false;
-    this.attached = false;
-    this.halt = null;
+    this.forgetConnection();
     this.reader = new FrameReader;
     socket?.destroy();
     this.failPendingRequests(new Error(`Godot DAP ${detail}. The connection was dropped.`));
@@ -31861,14 +32055,10 @@ async function handleDAPTool(client, toolName, args) {
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
+    const cure = toolName === "dap_set_breakpoint" || toolName === "dap_remove_breakpoint" ? "Breakpoints need the editor open, not a running game: editor_status says whether one is connected, and the path is the script as the project spells it." : "The debug tools answer for a game the editor is playing: start one with editor_run.";
     return {
       isError: true,
-      content: [
-        {
-          type: "text",
-          text: `DAP tool '${toolName}' failed: ${message}. ` + "The debug tools answer for a game the editor is playing: start one with editor_run."
-        }
-      ]
+      content: [{ type: "text", text: `DAP tool '${toolName}' failed: ${message}. ${cure}` }]
     };
   }
 }
@@ -34945,6 +35135,7 @@ var init_godot_bridge = __esm(() => {
         dapPort: this.connectionInfo?.dapPort,
         debugPort: this.connectionInfo?.debugPort,
         openedByAServer: this.connectionInfo?.openedByAServer,
+        syncsBreakpoints: this.connectionInfo?.syncsBreakpoints,
         pendingRequests: this.pendingRequests.size,
         queuedResources: this.resourceQueues.size,
         listeningSince: this.listeningSince ?? undefined
@@ -35087,6 +35278,7 @@ var init_godot_bridge = __esm(() => {
             this.connectionInfo.dapPort = servedPort(message.dap_port);
             this.connectionInfo.debugPort = servedPort(message.debug_port);
             this.connectionInfo.openedByAServer = message.opened_by_a_server === true;
+            this.connectionInfo.syncsBreakpoints = typeof message.syncs_breakpoints === "boolean" ? message.syncs_breakpoints : undefined;
             this.log("info", `Godot ready: ${message.project_path}`);
             this.emitBridgeEvent("godot_connected", { projectPath: message.project_path });
           }
@@ -35688,7 +35880,7 @@ var init_junit = __esm(() => {
 import { realpathSync as realpathSync2 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection2 } from "node:net";
-import { dirname as dirname8, resolve as resolve3 } from "node:path";
+import { dirname as dirname9, resolve as resolve3 } from "node:path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function diagnosticsKey(uri) {
   let decoded;
@@ -35816,7 +36008,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname8(resolve3(filePath));
+    const rootPath = this.rootPath ?? dirname9(resolve3(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params) {
@@ -36261,13 +36453,13 @@ var init_process_time = __esm(() => {
 });
 
 // src/project-scan.ts
-import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync12 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync13 } from "node:fs";
+import { join as join15 } from "node:path";
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
 function steppedOver(directory) {
-  return existsSync12(join14(directory, ".gdignore"));
+  return existsSync12(join15(directory, ".gdignore"));
 }
 function projectStructure(projectPath) {
   const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
@@ -36280,7 +36472,7 @@ function projectStructure(projectPath) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join14(directory, entry.name));
+        visit(join15(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (extension === "tscn") {
@@ -36310,14 +36502,14 @@ function scriptsWithoutUid(projectPath) {
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join14(directory, entry.name), spelled);
+        visit(join15(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync12(join14(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync12(join15(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -36352,7 +36544,7 @@ function searchProject(projectPath, options) {
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join14(directory, entry.name);
+      const entryPath = join15(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -36363,7 +36555,7 @@ function searchProject(projectPath, options) {
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync12(entryPath, "utf8").split(`
+      for (const [index, line] of readFileSync13(entryPath, "utf8").split(`
 `).entries()) {
         if (full()) {
           break;
@@ -36392,16 +36584,16 @@ var init_project_scan = __esm(() => {
 });
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync13, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname9, join as join15 } from "node:path";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync14, rmSync as rmSync8, writeFileSync as writeFileSync10 } from "node:fs";
+import { dirname as dirname10, join as join16 } from "node:path";
 function restartNotePath(projectPath) {
-  return join15(projectPath, ".godot", "gdharness-restart.json");
+  return join16(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync7(dirname9(path), { recursive: true });
-    writeFileSync9(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync8(dirname10(path), { recursive: true });
+    writeFileSync10(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
@@ -36409,7 +36601,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync13(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync14(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -36424,7 +36616,7 @@ function restartOwed(projectPath) {
 }
 function restartSettled(projectPath) {
   try {
-    rmSync7(restartNotePath(projectPath), { force: true });
+    rmSync8(restartNotePath(projectPath), { force: true });
   } catch (error) {
     console.error(`[SERVER] Could not clear the restart note: ${errorMessage(error)}`);
   }
@@ -36434,10 +36626,10 @@ var init_restart_note = __esm(() => {
 });
 
 // src/runtime-client.ts
-import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync14, unlinkSync } from "node:fs";
+import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync15, unlinkSync } from "node:fs";
 import { createConnection as createConnection3 } from "node:net";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join16, resolve as resolve4 } from "node:path";
+import { join as join17, resolve as resolve4 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
 function runtimeDirectory(variables = process.env) {
   const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
@@ -36445,13 +36637,13 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join16(perUser ?? tmpdir4(), "gdharness");
+  return join17(perUser ?? tmpdir4(), "gdharness");
 }
 function runtimeDirectories(variables = process.env) {
   const candidates = [runtimeDirectory(variables)];
   const fallbacks = process.platform === "win32" ? [envValue("SystemRoot", variables) ?? envValue("windir", variables) ?? "C:\\Windows"] : ["/tmp", "/var/tmp"];
   for (const base of fallbacks) {
-    candidates.push(join16(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+    candidates.push(join17(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
   return [...new Set(candidates.map((path) => resolve4(path)))];
 }
@@ -36466,7 +36658,7 @@ function processAlive(pid) {
 function parseAnnouncement(file, pid) {
   let fields;
   try {
-    fields = asParams(JSON.parse(readFileSync14(file, "utf8")));
+    fields = asParams(JSON.parse(readFileSync15(file, "utf8")));
   } catch {
     return { kind: "rubbish" };
   }
@@ -36507,7 +36699,7 @@ function discoverRuntimes(directories = runtimeDirectories()) {
 function wentAway(file, pid) {
   let project = "";
   try {
-    const fields = asParams(JSON.parse(readFileSync14(file, "utf8")));
+    const fields = asParams(JSON.parse(readFileSync15(file, "utf8")));
     project = readString(readParams(fields, "project") ?? {}, "path") ?? "";
   } catch {
     return;
@@ -36536,7 +36728,7 @@ function announcedIn(directory) {
     if (!match) {
       continue;
     }
-    const file = join16(directory, entry);
+    const file = join17(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
     const alive = processAlive(pid);
     const announced = alive ? parseAnnouncement(file, pid) : { kind: "rubbish" };
@@ -36577,7 +36769,25 @@ function tooNew(unspoken) {
   const half = unspoken.some((game) => game.protocol > RUNTIME_PROTOCOL) ? "this server is the older half: reconnect it so it spawns the installed version" : "the addon is the older half: reinstall it and restart the game";
   return `A game is running, in a protocol this server does not speak ${named}. This server speaks ${RUNTIME_PROTOCOL}, so ${half}.`;
 }
-function chooseRuntime(endpoints, projectPath, unspoken = []) {
+function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
+  if (pid !== undefined) {
+    const named = endpoints.find((endpoint) => endpoint.pid === pid);
+    if (named !== undefined) {
+      if (projectPath !== undefined && resolve4(named.project.path) !== resolve4(projectPath)) {
+        return {
+          problem: `The game with pid ${pid} is running ${named.project.path}, not ${resolve4(projectPath)}. Running: ${endpoints.map(describe2).join("; ")}.`
+        };
+      }
+      return { endpoint: named };
+    }
+    const tooNewToo = unspoken.find((game) => game.pid === pid);
+    if (tooNewToo !== undefined) {
+      return { problem: tooNew([tooNewToo]) };
+    }
+    return {
+      problem: endpoints.length === 0 ? `No game with the runtime addon is running, so there is none with pid ${pid}. Start one with editor_run, or play the project from the editor with the addon enabled.` : `No running game has pid ${pid}. Running: ${endpoints.map(describe2).join("; ")}. editor_status lists them under runtimes as they come and go.`
+    };
+  }
   if (endpoints.length === 0) {
     if (unspoken.length > 0) {
       return { problem: tooNew(unspoken) };
@@ -36608,14 +36818,14 @@ function chooseRuntime(endpoints, projectPath, unspoken = []) {
       return { endpoint: matching[0] };
     }
     return {
-      problem: `Several games are running from ${wanted}: ${matching.map(describe2).join("; ")}. Stop all but one.`
+      problem: `Several games are running from ${wanted}: ${matching.map(describe2).join("; ")}. Pass pid to choose one.`
     };
   }
   if (endpoints.length === 1 && endpoints[0]) {
     return { endpoint: endpoints[0] };
   }
   return {
-    problem: `Several games are running: ${endpoints.map(describe2).join("; ")}. Pass projectPath to choose one.`
+    problem: `Several games are running: ${endpoints.map(describe2).join("; ")}. Pass projectPath to choose one, or pid when they are from one project.`
   };
 }
 function runtimeRequest(endpoint, command, params, timeoutMs) {
@@ -36713,36 +36923,36 @@ var init_runtime_client = __esm(() => {
 
 // src/run-record.ts
 import { execFileSync } from "node:child_process";
-import { mkdirSync as mkdirSync8, openSync, readdirSync as readdirSync6, readFileSync as readFileSync15, rmSync as rmSync8, statSync as statSync3, writeFileSync as writeFileSync10 } from "node:fs";
-import { basename as basename2, join as join17 } from "node:path";
+import { mkdirSync as mkdirSync9, openSync, readdirSync as readdirSync6, readFileSync as readFileSync16, rmSync as rmSync9, statSync as statSync3, writeFileSync as writeFileSync11 } from "node:fs";
+import { basename as basename2, join as join18 } from "node:path";
 function runsDirectory() {
-  return join17(runtimeDirectory(), "runs");
+  return join18(runtimeDirectory(), "runs");
 }
 function recordPath() {
-  return join17(runsDirectory(), "run.json");
+  return join18(runsDirectory(), "run.json");
 }
 function recordPaths() {
-  return runtimeDirectories().map((directory) => join17(directory, "runs", "run.json"));
+  return runtimeDirectories().map((directory) => join18(directory, "runs", "run.json"));
 }
 function openTranscript(startedAt) {
-  mkdirSync8(runsDirectory(), { recursive: true });
-  const path = join17(runsDirectory(), `run-${startedAt}.log`);
+  mkdirSync9(runsDirectory(), { recursive: true });
+  const path = join18(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync(path, "a") };
 }
 function writeRunRecord(record) {
-  mkdirSync8(runsDirectory(), { recursive: true });
-  writeFileSync10(recordPath(), JSON.stringify(record, null, 2), "utf8");
+  mkdirSync9(runsDirectory(), { recursive: true });
+  writeFileSync11(recordPath(), JSON.stringify(record, null, 2), "utf8");
 }
 function editorNotePath() {
-  return join17(runsDirectory(), "editor-run.json");
+  return join18(runsDirectory(), "editor-run.json");
 }
 function writeEditorRunNote(note) {
-  mkdirSync8(runsDirectory(), { recursive: true });
-  writeFileSync10(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
+  mkdirSync9(runsDirectory(), { recursive: true });
+  writeFileSync11(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
 }
 function readEditorRunNote() {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(join17(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(join18(directory, "runs", "editor-run.json"));
     if (note !== null) {
       return note;
     }
@@ -36752,7 +36962,7 @@ function readEditorRunNote() {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync15(path, "utf8"));
+    parsed = JSON.parse(readFileSync16(path, "utf8"));
   } catch {
     return null;
   }
@@ -36775,7 +36985,7 @@ function recordRunEnded(pid, exitCode) {
     return;
   }
   try {
-    writeFileSync10(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
+    writeFileSync11(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
   } catch {}
 }
 function readRunRecord() {
@@ -36790,7 +37000,7 @@ function readRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync15(path, "utf8"));
+    parsed = JSON.parse(readFileSync16(path, "utf8"));
   } catch {
     return null;
   }
@@ -36835,7 +37045,7 @@ function runningAs(pid) {
     const began = startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync15(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync16(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = execFileSync("ps", ["-p", String(pid), "-o", "args="], {
@@ -36955,7 +37165,7 @@ function clearRunRecord(ours = () => true) {
       continue;
     }
     try {
-      rmSync8(path);
+      rmSync9(path);
     } catch {}
   }
 }
@@ -36979,12 +37189,12 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join17(directory, entry);
+    const path = join18(directory, entry);
     if (path === keep || ageMs(path, now) < keepMs) {
       continue;
     }
     try {
-      rmSync8(path);
+      rmSync9(path);
     } catch {}
   }
 }
@@ -37002,21 +37212,41 @@ import {
   closeSync,
   existsSync as existsSync14,
   fstatSync,
-  mkdirSync as mkdirSync9,
+  mkdirSync as mkdirSync10,
   mkdtempSync as mkdtempSync3,
   openSync as openSync2,
   readdirSync as readdirSync7,
-  readFileSync as readFileSync16,
+  readFileSync as readFileSync17,
   readSync
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename3, dirname as dirname10, join as join18, normalize as normalize3 } from "node:path";
+import { basename as basename3, dirname as dirname11, join as join19, normalize as normalize3, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { promisify as promisify6 } from "node:util";
 function patienceForFrames(frames, atLeast) {
   return Math.max(atLeast, frames / SLOWEST_FRAME_RATE * 1000 + atLeast);
 }
+function projectSpelling(projectPath, absolutePath) {
+  return `res://${relative3(realPathOr(projectPath), realPathOr(absolutePath)).replaceAll("\\", "/")}`;
+}
+function whichGame(args) {
+  return { projectPath: args["projectPath"], pid: args["pid"] };
+}
+function describeHalt(halt) {
+  switch (halt.reason) {
+    case "breakpoint":
+      return "at a breakpoint";
+    case "step":
+      return "after a step";
+    case "exception":
+      return halt.text === "" ? "on an error" : `on an error: ${halt.text}`;
+    case "attached":
+      return "held when this session attached";
+    default:
+      return `stopped with reason "${halt.reason}"`;
+  }
+}
 function stillRunning(run) {
   if (run?.exitCode !== null || run.endedUnwatched === true) {
     return false;
@@ -37038,6 +37268,19 @@ function runIsUp(run, editorSays) {
   }
   return editorSays ?? stillRunning(run);
 }
+function endedPreviousRun(ended) {
+  if (ended === null) {
+    return;
+  }
+  return ended.pid ?? true;
+}
+function endedToStartThis(ended) {
+  if (ended === null) {
+    return "";
+  }
+  const which = ended.pid === null ? "The game the editor was playing" : `The run that was going, pid ${ended.pid},`;
+  return ` ${which} was ended to start this one; its output is no longer what editor_output answers about.`;
+}
 function runtimeVerdict(endpoint, after) {
   if (endpoint !== null) {
     return { listening: true, pid: endpoint.pid, port: endpoint.port };
@@ -37165,7 +37408,7 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync14(join18(projectPath, wanted))) {
+  if (wanted === "" || existsSync14(join19(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -37179,11 +37422,11 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync16(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync17(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync16(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync17(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -37199,7 +37442,7 @@ function camelCased(params) {
 class GodotServer {
   mcp;
   locator = new GodotLocator2;
-  operationsScript = join18(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join19(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -37211,6 +37454,7 @@ class GodotServer {
   lastGodotVersion = null;
   lspClient = null;
   dapClient = null;
+  breakpointsSeededOn = null;
   bridgeStartupError = null;
   bridgeRetry = null;
   successorWatch = null;
@@ -37735,7 +37979,7 @@ class GodotServer {
         switch (op) {
           case "tree":
             return await this.handleRuntimeCommand("get_tree", {
-              projectPath: args["projectPath"],
+              ...whichGame(args),
               root: readNonEmptyString(args, "nodePath") ?? "/root",
               depth: readPositiveNumber(args, "depth") ?? 3,
               include_properties: readBoolean(args, "includeProperties") ?? false
@@ -37744,36 +37988,36 @@ class GodotServer {
             return await this.handleFindRuntimeNodes(args);
           case "text":
             return await this.handleRuntimeCommand("read_text", {
-              projectPath: args["projectPath"],
+              ...whichGame(args),
               root: readNonEmptyString(args, "nodePath") ?? "/root",
               include_hidden: readBoolean(args, "includeHidden") ?? false,
               limit: readPositiveNumber(args, "limit") ?? 500
             });
           case "rect":
             return await this.handleRuntimeCommand("get_rect", {
-              projectPath: args["projectPath"],
+              ...whichGame(args),
               path: readNonEmptyString(args, "nodePath") ?? ""
             });
           case "property":
             return await this.handleRuntimeCommand("get_property", {
-              projectPath: args["projectPath"],
+              ...whichGame(args),
               path: readNonEmptyString(args, "nodePath") ?? "",
               property: readNonEmptyString(args, "property") ?? ""
             });
           default:
             return await this.handleRuntimeCommand("get_metrics", {
-              projectPath: args["projectPath"],
+              ...whichGame(args),
               metrics: readArray(args, "metrics") ?? []
             });
         }
       case "runtime_invoke":
         return op === "set" ? await this.handleRuntimeCommand("set_property", {
-          projectPath: args["projectPath"],
+          ...whichGame(args),
           path: readNonEmptyString(args, "nodePath") ?? "",
           property: readString(args, "property") ?? "",
           value: args["value"]
         }) : await this.handleRuntimeCommand("call_method", {
-          projectPath: args["projectPath"],
+          ...whichGame(args),
           path: readNonEmptyString(args, "nodePath") ?? "",
           method: readString(args, "method") ?? "",
           args: readArray(args, "args") ?? []
@@ -37783,7 +38027,7 @@ class GodotServer {
       case "runtime_input":
         if (op === "click") {
           return await this.handleRuntimeCommand("click", {
-            projectPath: args["projectPath"],
+            ...whichGame(args),
             path: readNonEmptyString(args, "nodePath") ?? "",
             button: readString(args, "button") ?? "left",
             double: readBoolean(args, "doubleClick") ?? false
@@ -37791,7 +38035,7 @@ class GodotServer {
         }
         if (op === "choose") {
           return await this.handleRuntimeCommand("choose", {
-            projectPath: args["projectPath"],
+            ...whichGame(args),
             path: readNonEmptyString(args, "nodePath") ?? "",
             text: readString(args, "text") ?? "",
             ...args["index"] === undefined ? {} : { index: args["index"] }
@@ -37809,17 +38053,30 @@ class GodotServer {
         if (!located.ok) {
           return this.createErrorResponse(located.reason, PATH_SOLUTIONS);
         }
-        return await this.handleDAP(op === "set" ? "dap_set_breakpoint" : "dap_remove_breakpoint", {
+        const session = this.dapHoldingBreakpointsOf(project.value.path);
+        const answered = await this.handleDAP(op === "set" ? "dap_set_breakpoint" : "dap_remove_breakpoint", {
           ...args,
           scriptPath: realPathOr(located.absolutePath)
         });
+        if (answered.isError === true) {
+          return answered;
+        }
+        const held = session.breakpointsHeld();
+        writeBreakpointNote(project.value.path, held);
+        return this.jsonTextResponse({
+          ...asParams(JSON.parse(answered.content[0]?.text ?? "{}")),
+          held: this.breakpointsAsProjectSpells(project.value.path, held),
+          setInEditor: this.breakpointsAsProjectSpells(project.value.path, session.breakpointsInEditor()),
+          note: "The editor keeps a breakpoint set this way for one play. Every breakpoint held here is sent again before each play editor_run starts, and kept in the project for the server after a reconnect.",
+          ...this.breakpointsAtRisk()
+        });
       }
       case "debug_control":
       case "debug_state": {
         if (tool === "debug_state" && op === "output") {
           return await this.handleDAP("dap_get_output", args);
         }
-        const held = await this.debuggedGame();
+        const held = await this.debuggedGame(tool === "debug_control" ? "move" : "read");
         if (!held.ok) {
           return held.response;
         }
@@ -37842,7 +38099,7 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join18(path, "project.godot");
+    const file = join19(path, "project.godot");
     if (!existsSync14(file)) {
       return {
         ok: false,
@@ -37868,7 +38125,7 @@ class GodotServer {
     }
     return { ok: true, value: given };
   }
-  async debuggedGame() {
+  async debuggedGame(intent) {
     const game = this.activeProcess;
     if (game !== null && game.exitCode !== null) {
       return {
@@ -37885,6 +38142,16 @@ class GodotServer {
         response: this.createErrorResponse("No game is running, so there is no debug session to answer for.", ["Start one with editor_run start, which has the editor play it"])
       };
     }
+    const going = await this.runStillGoing(game);
+    if (!going) {
+      return {
+        ok: false,
+        response: this.createErrorResponse("The last run has already ended, so there is no debug session to answer for.", [
+          "editor_output still reads what it printed, until the next run starts",
+          "editor_run start plays another, which the debugger can hold"
+        ])
+      };
+    }
     if (!game.throughEditor) {
       return {
         ok: false,
@@ -37906,6 +38173,19 @@ class GodotServer {
       };
     }
     if (!this.dap().isStopped()) {
+      const hold = await this.holdOf(game, going);
+      if (hold.heldAt !== null) {
+        if (intent === "move") {
+          return { ok: true, value: game };
+        }
+        return {
+          ok: false,
+          response: this.createErrorResponse(hold.heldAt === undefined ? `Whether the game is held cannot be told from here, so there is no stack to read. ${hold.heldNote ?? ""}` : `The game is held, and this server cannot read its stack: ${hold.heldAt.description}.`, [
+            "debug_control continue lets a held game go, and the next stop is one this session is told about",
+            "editor_output says what it printed on the way to where it is"
+          ])
+        };
+      }
       return {
         ok: false,
         response: this.createErrorResponse("The game is running, not stopped, so it has no stack and no scope to read.", [
@@ -38043,7 +38323,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync16(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync17(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -38104,18 +38384,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname10(output.absolutePath);
+    const folder = dirname11(output.absolutePath);
     try {
-      mkdirSync9(folder, { recursive: true });
+      mkdirSync10(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname10(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname11(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
-    const exportLogs = mkdtempSync3(join18(tmpdir5(), "gdharness-export-"));
+    const exportLogs = mkdtempSync3(join19(tmpdir5(), "gdharness-export-"));
     const exportArgs = [
       "--headless",
       "--log-file",
-      join18(exportLogs, "engine.log"),
+      join19(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -38173,7 +38453,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync14(join18(project.value.path, runner))) {
+    if (!existsSync14(join19(project.value.path, runner))) {
       return this.createErrorResponse(`gdUnit4 is not installed in this project: no ${runner}.`, [
         "Install gdUnit4 under addons/gdUnit4, from https://github.com/godot-gdunit-labs/gdUnit4"
       ]);
@@ -38208,7 +38488,7 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync3(join18(tmpdir5(), "gdharness-tests-"));
+    const userData = mkdtempSync3(join19(tmpdir5(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const hung = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -38224,14 +38504,14 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join18(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join19(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
       const written = existsSync14(reportsDir) ? readdirSync7(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
       const newest = written.at(-1);
       if (newest !== undefined) {
-        report = parseJUnit(readFileSync16(join18(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync17(join19(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -38371,7 +38651,7 @@ class GodotServer {
         return null;
       }
       try {
-        return readFileSync16(contained.absolutePath, "utf8");
+        return readFileSync17(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -38413,7 +38693,7 @@ class GodotServer {
       return null;
     }
     try {
-      return readFileSync16(contained.absolutePath, "utf8");
+      return readFileSync17(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -38459,9 +38739,38 @@ class GodotServer {
       this.dapClient.setOutputSink((line) => {
         this.writeToTranscript(line);
       });
+      this.dapClient.setBreakpointsSink((held) => {
+        const project = this.godotBridge.getStatus().projectPath ?? this.ownProject;
+        if (project !== null) {
+          writeBreakpointNote(project, held);
+        }
+      });
     }
     return this.dapClient;
   }
+  dapHoldingBreakpointsOf(projectPath) {
+    const client = this.dap();
+    if (this.breakpointsSeededOn !== client) {
+      client.holdBreakpoints(readBreakpointNote(projectPath));
+      this.breakpointsSeededOn = client;
+    }
+    return client;
+  }
+  breakpointsAtRisk() {
+    const status = this.godotBridge.getStatus();
+    if (!status.connected || status.syncsBreakpoints === true) {
+      return {};
+    }
+    return {
+      breakpointsAtRisk: status.syncsBreakpoints === false ? "This editor clears every breakpoint in its script editor whenever a debug session opens on its adapter, which this server does for its first breakpoint or stack read: network/debug_adapter/sync_breakpoints is off. The installed addon turns it on as it loads, so the editor is running an older one; editor_launch restart puts the installed addon in, or turn the setting on in Editor Settings > Network > Debug Adapter." : "Whether this editor keeps its breakpoints when a debug session opens cannot be told: the addon it is running predates the report. Godot clears them unless network/debug_adapter/sync_breakpoints is on, which the installed addon turns on as it loads; editor_launch restart puts the installed addon in."
+    };
+  }
+  breakpointsAsProjectSpells(projectPath, held) {
+    return held.map((one) => ({
+      scriptPath: projectSpelling(projectPath, one.scriptPath),
+      lines: one.lines
+    }));
+  }
   writeToTranscript(line) {
     const run = this.activeProcess;
     if (run?.throughEditor !== true || run.transcript === null) {
@@ -38518,6 +38827,7 @@ class GodotServer {
       ...status.connected ? this.whatTheLaunchedEditorDropped() : {},
       startupError: this.bridgeStartupError,
       staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION) : undefined,
+      ...this.breakpointsAtRisk(),
       retryingBridge: this.bridgeRetry === null ? undefined : true,
       announcedAt: this.announcedAt ?? undefined,
       projectIs: this.projectHasMovedOn() ?? undefined,
@@ -38551,8 +38861,12 @@ class GodotServer {
   async handleEditorStatus() {
     const located = await this.locator.find();
     const announced = runtimesAnnounced();
-    const games = await Promise.all(announced.running.map(async (endpoint) => {
-      const reply = await runtimeRequest(endpoint, "ping", {}, this.runtimeTimeoutMs());
+    const pinged = Promise.all(announced.running.map(async (endpoint) => {
+      const held = this.knownHoldOn(endpoint);
+      const reply = held === null ? await runtimeRequest(endpoint, "ping", {}, HOLD_PING_MS) : {
+        ok: false,
+        message: `The game is held by the editor's debugger, ${describeHalt(held)}, and answers no runtime call while it is. debug_control continue lets it go.`
+      };
       return {
         pid: endpoint.pid,
         port: endpoint.port,
@@ -38561,8 +38875,18 @@ class GodotServer {
         problem: reply.ok ? null : reply.message
       };
     }));
-    const playing = await this.editorPlayingState();
-    await this.pickUpWhatTheEditorIsPlaying();
+    const asked = (async () => {
+      const playing = await this.editorPlayingState();
+      await this.pickUpWhatTheEditorIsPlaying();
+      const current = this.currentRun();
+      const active = current === null ? false : await this.runStillGoing(current, playing?.playing ?? null);
+      return {
+        playing,
+        active,
+        hold: current === null ? {} : await this.holdOf(current, active)
+      };
+    })();
+    const [games, { playing, active, hold }] = await Promise.all([pinged, asked]);
     return this.jsonTextResponse({
       editor: {
         ...this.getEditorStatusPayload(),
@@ -38574,8 +38898,9 @@ class GodotServer {
         problem: located.ok ? undefined : GodotLocator2.refusal(located).message
       },
       game: {
-        processActive: runIsUp(this.currentRun(), playing === null ? null : playing.playing),
+        processActive: active,
         playingInEditor: playing,
+        ...hold,
         runtimeConnected: games.some((game) => game.reachable),
         runtimes: games,
         unreadable: announced.unspoken.map((game) => ({
@@ -38593,7 +38918,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync16(join18(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync17(join19(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -38786,10 +39111,12 @@ class GodotServer {
     if (op === "check") {
       return await this.checkBoot(engine.value, project.value.path, sceneArgument, args, given.value);
     }
+    await this.pickUpWhatTheEditorIsPlaying();
     let ended = null;
-    if (stillRunning(this.currentRun())) {
+    const before = this.currentRun();
+    if (before !== null && await this.runStillGoing(before)) {
       this.logDebug("Ending the running game before starting another");
-      ended = this.currentRun()?.pid ?? null;
+      ended = { pid: before.pid ?? this.announcedPidOf(before) ?? null };
       await this.endActiveGame("editor_run start, which ends the run that was going before it starts another");
     }
     const alreadyPlaying = new Set(discoverRuntimes().map((endpoint) => endpoint.pid));
@@ -38813,8 +39140,8 @@ class GodotServer {
     const started = this.spawnKeptGame(engine.value, cmdArgs, project.value.path);
     this.activeProcess = started;
     const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && given.value.length > 0 ? " The editor cannot be handed arguments for a game it plays, so this one was started " + "here: the debug_* tools answer only for a game the editor is playing." : "";
-    const endedForThis = ended === null ? "" : ` The run that was going, pid ${ended}, was ended to start this one; its output is no longer what editor_output answers about.`;
-    const stranded = wereHereFirst.filter((one) => one.pid !== ended && alive(one.pid));
+    const endedForThis = endedToStartThis(ended);
+    const stranded = wereHereFirst.filter((one) => one.pid !== ended?.pid && alive(one.pid));
     const named = stranded.map((one) => one.protocol === null ? `pid ${one.pid}` : `pid ${one.pid} on protocol ${one.protocol}`).join(", ");
     const alsoRunning = stranded.length === 0 ? "" : ` A game of this project was already running and still is: ${named}. Starting this one did not end it and nothing here can, because this server did not start it. End it yourself, or bring the halves to one version where a protocol is named.`;
     return this.jsonTextResponse({
@@ -38825,23 +39152,38 @@ class GodotServer {
       arguments: cmdArgs,
       transcript: started.transcript,
       refreshedClasses: refreshed.value,
-      endedPreviousRun: ended ?? undefined,
+      endedPreviousRun: endedPreviousRun(ended),
       runtime: await this.runtimeUp(project.value.path, alreadyPlaying, runtimeWaitMs, given.value.length > 0),
       message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}${endedForThis}${alsoRunning}`
     });
   }
-  async gameIsUp() {
-    const run = this.currentRun();
-    const editorSays = run?.throughEditor === true ? (await this.editorPlayingState())?.playing ?? null : null;
-    return runIsUp(run, editorSays);
-  }
   async runtimeUp(projectPath, before, budgetMs, withArgs) {
-    if (!existsSync14(join18(projectPath, RUNTIME_AUTOLOAD2.path))) {
+    if (!existsSync14(join19(projectPath, RUNTIME_AUTOLOAD2.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
     }
+    let asking = null;
+    let editorAskedAt = 0;
+    let editorSaysGoing = true;
     const endpoint = await announcedSince(projectPath, before, {
       budgetMs,
-      giveUp: () => this.dapClient?.isStopped() === true || !stillRunning(this.currentRun())
+      giveUp: () => {
+        if (this.dapClient?.isStopped() === true) {
+          return true;
+        }
+        const run = this.currentRun();
+        if (run === null || !run.throughEditor) {
+          return !stillRunning(run);
+        }
+        if (asking === null && Date.now() - editorAskedAt >= RUN_POLL_MS) {
+          editorAskedAt = Date.now();
+          asking = this.runStillGoing(run).then((going) => {
+            editorSaysGoing = going;
+          }).finally(() => {
+            asking = null;
+          });
+        }
+        return !editorSaysGoing;
+      }
     });
     const going = this.currentRun();
     if (endpoint !== null && going?.throughEditor === true && going.announcedPid === undefined) {
@@ -38851,7 +39193,7 @@ class GodotServer {
       addon: true,
       budgetMs,
       heldAt: this.dapClient?.whereItStopped() ?? null,
-      running: await this.gameIsUp(),
+      running: endpoint !== null || going !== null && await this.runStillGoing(going),
       withArgs
     });
   }
@@ -38874,6 +39216,7 @@ class GodotServer {
         "Closing the other editor, or moving its debug adapter port in its editor settings, frees this one"
       ]);
     }
+    const breakpoints = await this.dapHoldingBreakpointsOf(projectPath).reapplyBreakpoints();
     const answer = await this.handleViaBridge("play_scene", scene === null ? {} : { scenePath: `res://${scene}` });
     if (answer.isError === true) {
       return answer;
@@ -38891,7 +39234,8 @@ class GodotServer {
       startedAt,
       exitCode: null,
       throughEditor: true,
-      brokeOn: null
+      brokeOn: null,
+      announcedBefore: alreadyPlaying
     };
     this.activeProcess = played;
     writeEditorRunNote({ projectPath, transcript: transcript.path, startedAt });
@@ -38902,9 +39246,14 @@ class GodotServer {
       scene: scene === null ? "the main scene" : `res://${scene}`,
       refreshedClasses,
       debugPort: readNumber(asParams(JSON.parse(answer.content[0]?.text ?? "{}")), "debugPort"),
-      endedPreviousRun: ended ?? undefined,
+      endedPreviousRun: endedPreviousRun(ended),
+      breakpoints: breakpoints.applied.length === 0 ? undefined : this.breakpointsAsProjectSpells(projectPath, breakpoints.applied),
+      breakpointsRefused: breakpoints.refused.length === 0 ? undefined : breakpoints.refused.map((one) => ({
+        scriptPath: projectSpelling(projectPath, one.scriptPath),
+        reason: one.reason
+      })),
       runtime: await this.runtimeUp(projectPath, alreadyPlaying, runtimeWaitMs, false),
-      message: "The editor is playing it, so its debugger holds it: the debug_* tools can reach it, " + "editor_output reads its console through the debug adapter, and editor_run stop ends it." + (ended === null ? "" : ` The run that was going, pid ${ended}, was ended to start this one; its output is no longer what editor_output answers about.`)
+      message: "The editor is playing it, so its debugger holds it: the debug_* tools can reach it, " + "editor_output reads its console through the debug adapter, and editor_run stop ends it." + endedToStartThis(ended)
     });
   }
   drainEditorOutput(game) {
@@ -39100,7 +39449,7 @@ class GodotServer {
       return;
     }
     try {
-      await this.dap().connect();
+      await this.dap().attach();
     } catch (error) {
       this.logDebug(`Picked up an editor-played run without its adapter: ${errorMessage(error)}`);
     }
@@ -39122,6 +39471,18 @@ class GodotServer {
     };
     this.activeProcess = picked;
   }
+  announcedPidOf(run) {
+    if (!run.throughEditor || run.announcedPid !== undefined) {
+      return run.announcedPid;
+    }
+    const before = run.announcedBefore ?? new Set;
+    const fresh = this.allAnnouncedForOurProject(runtimesAnnounced().running).filter((one) => !before.has(one.pid));
+    const theOne = fresh.length === 1 ? fresh[0] : undefined;
+    if (theOne !== undefined) {
+      run.announcedPid = theOne.pid;
+    }
+    return run.announcedPid;
+  }
   adoptRecordedRun() {
     const record = readRunRecord();
     if (record === null || !this.couldBeOurs(record.projectPath)) {
@@ -39250,12 +39611,22 @@ class GodotServer {
     }
     const budgetMs = readPositiveNumber(args, "timeoutMs") ?? WAIT_FOR_RUN_MS;
     const until = Date.now() + budgetMs;
-    while (stillRunning(run) && Date.now() < until) {
+    while (await this.runStillGoing(run) && Date.now() < until) {
       this.drainEditorOutput(run);
       this.drainTranscript(run);
       await delay3(RUN_POLL_MS);
     }
-    return await this.handleGetDebugOutput(args, stillRunning(run) ? budgetMs : undefined);
+    return await this.handleGetDebugOutput(args, await this.runStillGoing(run) ? budgetMs : undefined);
+  }
+  async runStillGoing(run, editorSays) {
+    if (!run.throughEditor) {
+      return stillRunning(run);
+    }
+    const announced = this.announcedPidOf(run);
+    if (announced !== undefined && !alive(announced)) {
+      return false;
+    }
+    return runIsUp(run, editorSays === undefined ? (await this.editorPlayingState())?.playing ?? null : editorSays);
   }
   async handleGetDebugOutput(args, waitedMs) {
     await this.pickUpWhatTheEditorIsPlaying();
@@ -39265,7 +39636,8 @@ class GodotServer {
     }
     this.drainEditorOutput(run);
     this.drainTranscript(run);
-    if (run.endedUnwatched !== true && !stillRunning(run)) {
+    const going = await this.runStillGoing(run);
+    if (run.endedUnwatched !== true && !going) {
       run.log.finish();
       run.endedUnwatched = run.exitCode === null;
     }
@@ -39276,12 +39648,13 @@ class GodotServer {
       contains: readNonEmptyString(args, "contains"),
       limit: readPositiveNumber(args, "limit") ?? 200
     });
-    const halt = run.throughEditor ? this.dapClient?.whereItStopped() ?? null : null;
+    const hold = await this.holdOf(run, going);
     const wanted = readBoolean(args, "cpu") ?? false;
-    const cpuSeconds = wanted && run.pid !== null && stillRunning(run) ? await cpuSecondsOf(run.pid) : undefined;
+    const processToAsk = run.pid ?? this.announcedPidOf(run) ?? null;
+    const cpuSeconds = wanted && processToAsk !== null && stillRunning(run) ? await cpuSecondsOf(processToAsk) : undefined;
     const notes = [];
     if (wanted && cpuSeconds === undefined && stillRunning(run)) {
-      notes.push(run.pid === null ? "cpu was asked for and there is no process to ask: the editor is playing this run and holds it, so nothing here has its process id. editor_run start without a connected editor, or with args, starts the game here instead and that run answers cpuSeconds." : "cpu was asked for and this platform would not say what the run has used.");
+      notes.push(processToAsk === null ? "cpu was asked for and there is no process to ask: the editor is playing this run and holds it, and the game announced no runtime, so nothing here has its process id. A game with the runtime addon announces one; editor_run start without a connected editor, or with args, starts the game here instead and that run answers cpuSeconds either way." : "cpu was asked for and this platform would not say what the run has used.");
     }
     if (waitedMs !== undefined) {
       notes.push(`The wait of ${waitedMs}ms ran out and the run is still going, so this is what it had printed by then rather than everything it will print. editor_run wait again to keep waiting.`);
@@ -39305,15 +39678,15 @@ class GodotServer {
       notes.push(`Everything this run has printed is in ${run.transcript}, uncapped and still being written. Read it for output, not for whether the run is alive: a transcript that stops growing is a run between prints. running above is asked of the operating system while there is a process to ask about, and for an editor-played run that announced no runtime it is the editor's answer instead, which can lag after the game has gone.`);
     }
     return this.jsonTextResponse({
-      running: stillRunning(run),
+      running: going,
       exitCode: run.exitCode,
       through: run.throughEditor ? "editor" : "gdharness",
-      pid: run.pid,
+      pid: run.pid ?? this.announcedPidOf(run) ?? null,
       errors: run.log.count("error"),
       warnings: run.log.count("warning"),
       clean: run.consoleLost === true ? undefined : run.log.count("error") === 0,
       consoleLost: run.consoleLost === true ? true : undefined,
-      heldAt: halt,
+      ...hold,
       endedUnwatched: run.endedUnwatched === true ? true : undefined,
       endedBy: stillRunning(run) ? undefined : run.endedHere ?? null,
       project: !run.throughEditor && run.process === null ? run.projectPath ?? undefined : undefined,
@@ -39334,18 +39707,19 @@ class GodotServer {
     }
     this.drainEditorOutput(stopped);
     this.drainTranscript(stopped);
+    const wasRunning = await this.runStillGoing(stopped);
     this.logDebug("Stopping the running game");
     await this.endActiveGame("editor_run stop");
     return this.jsonTextResponse({
       stopped: true,
       through: stopped.throughEditor ? "editor" : "gdharness",
-      endedPid: stopped.pid,
-      exitedBeforeStop: stopped.exitCode !== null,
+      endedPid: stopped.pid ?? this.announcedPidOf(stopped) ?? null,
+      exitedBeforeStop: stopped.exitCode !== null || !wasRunning,
       exitCode: stopped.exitCode,
       errors: stopped.log.count("error"),
       warnings: stopped.log.count("warning"),
       clean: stopped.log.count("error") === 0,
-      note: stopped.throughEditor ? "The editor was asked to stop the scene it is playing. Anything that game started for itself, with OS.create_process or otherwise, is not the editor's to stop and is still running." : "The process named under endedPid was ended. Anything that game started for itself, with OS.create_process or otherwise, is a separate process and is still running.",
+      note: !wasRunning ? "This run was over before the stop, so nothing was ended here: editor_output has what it printed and how it ended. Anything that game started for itself, with OS.create_process or otherwise, is a separate process and may still be running." : stopped.throughEditor ? "The editor was asked to stop the scene it is playing. Anything that game started for itself, with OS.create_process or otherwise, is not the editor's to stop and is still running." : "The process named under endedPid was ended. Anything that game started for itself, with OS.create_process or otherwise, is a separate process and is still running.",
       entries: forAnswer(stopped.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries)
     });
   }
@@ -39496,16 +39870,68 @@ class GodotServer {
     const override = Number.parseInt(envValue("GDHARNESS_RUNTIME_TIMEOUT_MS") ?? "", 10);
     return Number.isInteger(override) && override > 0 ? override : 1e4;
   }
+  knownHoldOn(endpoint) {
+    const run = this.activeProcess;
+    const session = this.dapClient;
+    if (run === null || !run.throughEditor || !stillRunning(run) || session === null) {
+      return null;
+    }
+    if (this.announcedPidOf(run) !== endpoint.pid || !session.holdIsKnown()) {
+      return null;
+    }
+    return session.whereItStopped();
+  }
+  async holdOf(run, going) {
+    if (!run.throughEditor || !(going ?? await this.runStillGoing(run))) {
+      return { heldAt: null };
+    }
+    const session = this.dapClient;
+    if (session?.holdIsKnown()) {
+      return { heldAt: session.whereItStopped() };
+    }
+    const its = this.announcedPidOf(run);
+    const endpoint = its === undefined ? undefined : runtimesAnnounced().running.find((one) => one.pid === its);
+    if (endpoint === undefined) {
+      return {
+        heldAt: undefined,
+        heldUnknown: true,
+        heldNote: "Whether this run is held at a breakpoint cannot be told from here: this server connected to the debugger after any stop, the adapter reports a stop only to the sessions connected when it happened, and the run has announced no runtime to ask instead. A game that draws nothing and answers nothing is held; debug_control continue lets a held game go."
+      };
+    }
+    const reply = await runtimeRequest(endpoint, "ping", {}, HOLD_PING_MS);
+    if (reply.ok) {
+      session?.learnedRunning();
+      return { heldAt: session?.whereItStopped() ?? null };
+    }
+    if (reply.reason === "busy") {
+      return {
+        heldAt: {
+          reason: "unanswered",
+          description: `the game accepted a runtime connection and did not answer a ping within ${HOLD_PING_MS}ms, which is what a game held at a breakpoint does, and what one stuck in a long frame does. This server connected to the debugger after the stop, so the adapter will not show it the stack; debug_control continue lets a held game go`,
+          text: ""
+        }
+      };
+    }
+    return { heldAt: undefined, heldUnknown: true, heldNote: reply.message };
+  }
   async handleRuntimeCommand(command, args, timeoutMs = this.runtimeTimeoutMs()) {
-    const { op: _op, projectPath, ...params } = asParams(args);
+    const { op: _op, projectPath, pid, ...params } = asParams(args);
     const announced = runtimesAnnounced();
-    const choice = chooseRuntime(announced.running, typeof projectPath === "string" ? projectPath : this.ownProject ?? undefined, announced.unspoken);
+    const choice = chooseRuntime(announced.running, typeof projectPath === "string" ? projectPath : this.ownProject ?? undefined, announced.unspoken, typeof pid === "number" ? pid : undefined);
     if ("problem" in choice) {
       return this.createErrorResponse(choice.problem);
     }
+    const held = this.knownHoldOn(choice.endpoint);
+    if (held !== null) {
+      return this.createErrorResponse(`The game (pid ${choice.endpoint.pid}) is held by the editor's debugger, ${describeHalt(held)}, and answers no runtime call while it is.`, [
+        "debug_control continue lets it go, after which this call answers",
+        "debug_state stack reads where it is held, and debug_state scopes what it is holding there",
+        "editor_output says heldAt for the run, and editor_run stop ends it"
+      ]);
+    }
     const expectsScreenshot = command === "capture_screenshot" || command === "capture_viewport";
-    const screenshotDir = expectsScreenshot ? mkdtempSync3(join18(tmpdir5(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join18(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? mkdtempSync3(join19(tmpdir5(), "gdharness-runtime-screenshot-")) : null;
+    const screenshotPath = screenshotDir ? join19(screenshotDir, "capture.png") : null;
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs);
       if (!reply.ok) {
@@ -39526,7 +39952,7 @@ class GodotServer {
       return {
         content: [
           { type: "text", text: `Screenshot captured: ${dimensions}` },
-          { type: "image", data: readFileSync16(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync17(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
@@ -39557,7 +39983,7 @@ class GodotServer {
     const includeHidden = readBoolean(args, "includeHidden");
     return await this.handleRuntimeCommand("find_nodes", {
       ...filters,
-      projectPath: args["projectPath"],
+      ...whichGame(args),
       root: readNonEmptyString(args, "nodePath") ?? "/root",
       limit: readPositiveNumber(args, "limit") ?? 100,
       ...property === undefined ? {} : { property },
@@ -39568,18 +39994,18 @@ class GodotServer {
     if (op === "frames") {
       const frames = readPositiveNumber(args, "frames") ?? 1;
       const waited = patienceForFrames(frames, this.runtimeTimeoutMs());
-      return await this.handleRuntimeCommand("wait_frames", { projectPath: args["projectPath"], frames }, waited);
+      return await this.handleRuntimeCommand("wait_frames", { ...whichGame(args), frames }, waited);
     }
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 5000;
     const nodePath = readNonEmptyString(args, "nodePath") ?? "";
     const patience = Math.max(this.runtimeTimeoutMs(), timeoutMs + 5000);
     return op === "signal" ? await this.handleRuntimeCommand("wait_signal", {
-      projectPath: args["projectPath"],
+      ...whichGame(args),
       path: nodePath,
       signal: readString(args, "signal") ?? "",
       timeout_ms: timeoutMs
     }, patience) : await this.handleRuntimeCommand("wait_until", {
-      projectPath: args["projectPath"],
+      ...whichGame(args),
       path: nodePath,
       property: readString(args, "property") ?? "",
       value: args["value"],
@@ -39592,11 +40018,12 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run6, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, SLOWEST_FRAME_RATE = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CACHE_WRITE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run6, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CACHE_WRITE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();
   init_types();
+  init_breakpoint_note();
   init_bridge_announce();
   init_class_cache();
   init_config_pin();
@@ -39624,7 +40051,7 @@ var init_server3 = __esm(() => {
   init_tool_definitions();
   init_update_check();
   run6 = promisify6(execFile6);
-  __dirname2 = dirname10(fileURLToPath4(import.meta.url));
+  __dirname2 = dirname11(fileURLToPath4(import.meta.url));
   VALUE_NAMES = {
     string: "a string",
     number: "a number",
@@ -39663,7 +40090,7 @@ var init_server3 = __esm(() => {
 
 // src/cli.ts
 import { existsSync as existsSync15 } from "fs";
-import { join as join19, resolve as resolve5 } from "path";
+import { join as join20, resolve as resolve5 } from "path";
 
 // src/errors.ts
 class Refusal extends Error {
@@ -41133,7 +41560,8 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 ## Start here
 
 - ${projectPathSentence()}. The \`runtime_*\` and \`debug_*\` ones pick between running
-  games instead; the others answer about the editor this server is connected to. There is no
+  games instead, by \`projectPath\`, or by \`pid\` when several run from one project, as a bench
+  and its workers do; the others answer about the editor this server is connected to. There is no
   ambient project, and an argument a tool does not declare is refused rather than ignored.
 - \`editor_status\` says whether an editor is connected and whether its addon matches the server.
   \`addonIsStale\` means they differ, and \`staleNote\` says which half is behind: an editor that
@@ -41205,6 +41633,12 @@ The autoload reaches an export. \`gdharness runtime off\` in the project before
 move. There is no pause and no step out: Godot's debug adapter implements neither, so use a
 breakpoint on the line you want instead.
 
+A held game draws nothing and answers no \`runtime_*\` call. The server says so at once when it
+knows, naming why the game is held and \`debug_control continue\` as what lets it go, and
+\`editor_output\` and \`editor_status\` carry the same under \`heldAt\`. A breakpoint set with
+\`debug_breakpoint\` holds for every start until \`debug_breakpoint remove\`, across a reconnect,
+so take it off when the question it was for is answered.
+
 ## Editing
 
 \`scene_tree\` for what a scene holds, rather than what the \`.tscn\` text implies. \`scene_node\`,
@@ -41353,7 +41787,7 @@ class UsageError extends Refusal {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve5(named ?? ".");
-  if (!existsSync15(join19(projectPath, "project.godot"))) {
+  if (!existsSync15(join20(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -41392,7 +41826,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync15(join19(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync15(join20(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
     console.log(`  that file is not in this project, so it boots with a missing script: restore it, or point the entry at res://${RUNTIME_AUTOLOAD.path}`);
   }
 }