gdharness 0.13.37 → 0.13.39

package/build/cli.js

@@ -15917,7 +15917,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "script_diagnostics",
-      description: "Errors and warnings for a script from the editor's language server, and whether the script is clean. Needs the editor running. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares comes back under contradictedByTheFile, and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says which remedy applies, because they differ: a stale analysed type needs editor_launch restart, while a class missing from the cache needs project_import refresh_classes.",
+      description: "Errors and warnings for a script from the editor's language server, and whether the script is clean. Needs the editor running. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares comes back under contradictedByTheFile, and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
       parameters: {
         projectPath: PROJECT_PATH,
         scriptPath: SCRIPT_PATH
@@ -16029,7 +16029,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 +16057,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: []
     },
@@ -16382,7 +16382,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.",
       parameters: {
         projectPath: PROJECT_PATH,
         scriptPath: SCRIPT_PATH,
@@ -16407,7 +16407,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 +31179,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 +31268,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 +31277,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 +31290,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 +31301,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,6 +31479,7 @@ class GodotDAPClient {
   attached = false;
   lastThreadId = 1;
   halt = null;
+  holdKnown = false;
   breakpoints = new Map;
   constructor(port = portFromEnv("GDHARNESS_DAP_PORT", DEFAULT_DAP_PORT), host = "127.0.0.1") {
     this.port = port;
@@ -31462,11 +31525,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 +31541,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 +31561,15 @@ 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;
   }
   async ensureConnected() {
     if (!this.connected) {
@@ -31598,6 +31658,12 @@ 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 === "terminated" || eventName === "exited") {
@@ -31636,6 +31702,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 +31751,70 @@ 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);
+  }
+  async sendBreakpoints(filePath, lines) {
     await this.ensureConnected();
     await this.initialize();
-    const fileBreakpoints = this.breakpoints.get(filePath) ?? new Set;
-    fileBreakpoints.delete(line);
-    if (fileBreakpoints.size === 0) {
+    const sorted = Array.from(lines).sort((a, b) => a - b);
+    const answer = await this.sendRequest("setBreakpoints", {
+      source: { path: filePath },
+      breakpoints: sorted.map((breakpointLine) => ({ line: breakpointLine }))
+    });
+    if (lines.size === 0) {
       this.breakpoints.delete(filePath);
     } else {
-      this.breakpoints.set(filePath, fileBreakpoints);
+      this.breakpoints.set(filePath, new Set(lines));
+    }
+    return answer;
+  }
+  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)
+        });
+      }
+    }
+    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);
+      }
     }
-    const remaining = Array.from(fileBreakpoints).sort((a, b) => a - b);
-    return await this.sendRequest("setBreakpoints", {
-      source: { path: filePath },
-      breakpoints: remaining.map((breakpointLine) => ({ line: breakpointLine }))
-    });
   }
   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 +31913,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.`));
@@ -35688,7 +35819,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 +35947,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 +36392,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 +36411,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 +36441,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 +36483,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 +36494,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 +36523,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 +36540,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 +36555,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 +36565,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 +36576,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 +36597,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 +36638,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 +36667,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" };
@@ -36713,36 +36844,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 +36883,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 +36906,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 +36921,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 +36966,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 +37086,7 @@ function clearRunRecord(ours = () => true) {
       continue;
     }
     try {
-      rmSync8(path);
+      rmSync9(path);
     } catch {}
   }
 }
@@ -36979,12 +37110,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 +37133,38 @@ 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 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;
@@ -37165,7 +37313,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 +37327,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 +37347,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 +37359,7 @@ class GodotServer {
   lastGodotVersion = null;
   lspClient = null;
   dapClient = null;
+  breakpointsSeededOn = null;
   bridgeStartupError = null;
   bridgeRetry = null;
   successorWatch = null;
@@ -37809,17 +37958,28 @@ 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),
+          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."
+        });
       }
       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 +38002,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 +38028,7 @@ class GodotServer {
     }
     return { ok: true, value: given };
   }
-  async debuggedGame() {
+  async debuggedGame(intent) {
     const game = this.activeProcess;
     if (game !== null && game.exitCode !== null) {
       return {
@@ -37906,6 +38066,19 @@ class GodotServer {
       };
     }
     if (!this.dap().isStopped()) {
+      const hold = await this.holdOf(game);
+      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 +38216,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 +38277,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 +38346,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 +38381,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 +38397,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 +38544,7 @@ class GodotServer {
         return null;
       }
       try {
-        return readFileSync16(contained.absolutePath, "utf8");
+        return readFileSync17(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -38413,7 +38586,7 @@ class GodotServer {
       return null;
     }
     try {
-      return readFileSync16(contained.absolutePath, "utf8");
+      return readFileSync17(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -38462,6 +38635,20 @@ class GodotServer {
     }
     return this.dapClient;
   }
+  dapHoldingBreakpointsOf(projectPath) {
+    const client = this.dap();
+    if (this.breakpointsSeededOn !== client) {
+      client.holdBreakpoints(readBreakpointNote(projectPath));
+      this.breakpointsSeededOn = client;
+    }
+    return client;
+  }
+  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) {
@@ -38551,8 +38738,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 +38752,13 @@ 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();
+      return { playing, hold: current === null ? {} : await this.holdOf(current) };
+    })();
+    const [games, { playing, hold }] = await Promise.all([pinged, asked]);
     return this.jsonTextResponse({
       editor: {
         ...this.getEditorStatusPayload(),
@@ -38576,6 +38772,7 @@ class GodotServer {
       game: {
         processActive: runIsUp(this.currentRun(), playing === null ? null : playing.playing),
         playingInEditor: playing,
+        ...hold,
         runtimeConnected: games.some((game) => game.reachable),
         runtimes: games,
         unreadable: announced.unspoken.map((game) => ({
@@ -38593,7 +38790,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;
     }
@@ -38836,7 +39033,7 @@ class GodotServer {
     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 });
     }
     const endpoint = await announcedSince(projectPath, before, {
@@ -38874,6 +39071,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;
@@ -38903,6 +39101,11 @@ class GodotServer {
       refreshedClasses,
       debugPort: readNumber(asParams(JSON.parse(answer.content[0]?.text ?? "{}")), "debugPort"),
       endedPreviousRun: ended ?? undefined,
+      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.`)
     });
@@ -39100,7 +39303,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)}`);
     }
@@ -39120,8 +39323,16 @@ class GodotServer {
       brokeOn: null,
       pickedUpPlaying: true
     };
+    const announced = this.theOneAnnouncedForOurProject();
+    if (announced !== undefined) {
+      picked.announcedPid = announced.pid;
+    }
     this.activeProcess = picked;
   }
+  theOneAnnouncedForOurProject() {
+    const ofProject = this.allAnnouncedForOurProject(runtimesAnnounced().running);
+    return ofProject.length === 1 ? ofProject[0] : undefined;
+  }
   adoptRecordedRun() {
     const record = readRunRecord();
     if (record === null || !this.couldBeOurs(record.projectPath)) {
@@ -39276,7 +39487,7 @@ 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);
     const wanted = readBoolean(args, "cpu") ?? false;
     const cpuSeconds = wanted && run.pid !== null && stillRunning(run) ? await cpuSecondsOf(run.pid) : undefined;
     const notes = [];
@@ -39313,7 +39524,7 @@ class GodotServer {
       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,
@@ -39496,6 +39707,50 @@ 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;
+    }
+    const its = run.announcedPid ?? this.theOneAnnouncedForOurProject()?.pid;
+    if (its !== endpoint.pid || !session.holdIsKnown()) {
+      return null;
+    }
+    return session.whereItStopped();
+  }
+  async holdOf(run) {
+    if (!run.throughEditor || !stillRunning(run)) {
+      return { heldAt: null };
+    }
+    const session = this.dapClient;
+    if (session?.holdIsKnown()) {
+      return { heldAt: session.whereItStopped() };
+    }
+    const endpoint = run.announcedPid !== undefined ? runtimesAnnounced().running.find((one) => one.pid === run.announcedPid) : this.theOneAnnouncedForOurProject();
+    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 announced = runtimesAnnounced();
@@ -39503,9 +39758,17 @@ class GodotServer {
     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 +39789,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 {
@@ -39592,11 +39855,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 +39888,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 +39927,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 {
@@ -41231,8 +41495,10 @@ its own, which is the measured cure and needs no change to the declaring script;
 restart\` also does it and costs a window.
 
 The scan writes \`.godot/global_script_class_cache.cfg\` from the list the editor is holding, so
-a class it cannot resolve is dropped out of that file too, and the next fresh engine, CI run or
-clone starts from the narrower one. That is the same class \`unseenByEditor\` names.
+a class it cannot resolve would go out of that file with it. The answer names that loss under
+\`cacheLost\` and rebuilds the cache from the declarations on disk, naming what came back under
+\`cacheRestored\`, so no fresh engine, CI run or clone inherits the short file. That is the same
+class \`unseenByEditor\` names, and the loss is not a reason to refuse the scan.
 
 A diagnostic about a member rather than a type, \`Static function "x()" not found in base "Y"\`
 about something the engine compiles, is a different thing and is no longer stale here: each ask
@@ -41351,7 +41617,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;
@@ -41390,7 +41656,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}`);
   }
 }