gdharness 0.13.38 → 0.13.40

package/build/index.js

@@ -10175,15 +10175,15 @@ import {
   closeSync,
   existsSync as existsSync9,
   fstatSync,
-  mkdirSync as mkdirSync6,
+  mkdirSync as mkdirSync7,
   mkdtempSync as mkdtempSync2,
   openSync as openSync2,
   readdirSync as readdirSync6,
-  readFileSync as readFileSync12,
+  readFileSync as readFileSync13,
   readSync
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename2, dirname as dirname5, join as join12, normalize as normalize2 } from "node:path";
+import { basename as basename2, dirname as dirname6, join as join13, normalize as normalize2, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { promisify as promisify4 } from "node:util";
@@ -24751,16 +24751,135 @@ class StdioServerTransport {
   }
 }
 
-// src/bridge-announce.ts
+// src/breakpoint-note.ts
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname, join as join2 } from "node:path";
+import { dirname, isAbsolute as isAbsolute2, join as join2, relative as relative2 } from "node:path";
+
+// src/paths.ts
+import { realpathSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+var RESOURCE_SCHEME = "res://";
+var OTHER_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]+:\/\//;
+function realPathOr(path) {
+  try {
+    return realpathSync.native(path);
+  } catch {
+    return path;
+  }
+}
+function isSameDirectory(onePath, otherPath) {
+  return relative(realPathOr(resolve(onePath)), realPathOr(resolve(otherPath))) === "";
+}
+function isWithinRoot(rootPath, candidatePath) {
+  const step = relative(resolve(rootPath), resolve(candidatePath));
+  return step !== ".." && !step.startsWith(`..${sep}`) && !isAbsolute(step);
+}
+function resolveWithinProject(projectPath, candidatePath) {
+  const trimmed = candidatePath.trim();
+  if (trimmed === "") {
+    return { ok: false, reason: "Path is empty." };
+  }
+  if (trimmed.includes("\x00")) {
+    return { ok: false, reason: "Path contains a null byte." };
+  }
+  const withoutScheme = trimmed.startsWith(RESOURCE_SCHEME) ? trimmed.slice(RESOURCE_SCHEME.length) : trimmed;
+  const scheme = OTHER_SCHEME.exec(withoutScheme);
+  if (scheme) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' uses the '${scheme[0]}' scheme, which names somewhere other than this project.`
+    };
+  }
+  if (withoutScheme.startsWith("/") || withoutScheme.startsWith("\\") || isAbsolute(withoutScheme)) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' is absolute; give a path inside the project, such as 'scenes/main.tscn'.`
+    };
+  }
+  if (withoutScheme.includes(":")) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' contains ':', which no file inside a project is named with.`
+    };
+  }
+  const root = resolve(projectPath);
+  const absolutePath = resolve(root, withoutScheme);
+  if (!isWithinRoot(root, absolutePath)) {
+    return { ok: false, reason: `Path '${trimmed}' resolves outside the project directory.` };
+  }
+  const relativePath = relative(root, absolutePath).split(sep).join("/");
+  if (relativePath === "") {
+    return { ok: false, reason: `Path '${trimmed}' is the project directory itself, not a file in it.` };
+  }
+  return { ok: true, absolutePath, relativePath };
+}
+
+// src/breakpoint-note.ts
+function breakpointNotePath(projectPath) {
+  return join2(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) {
+      rmSync(path, { force: true });
+      return;
+    }
+    const note = {
+      breakpoints: inside.map((one) => ({
+        script: relative2(root, one.scriptPath).replaceAll("\\", "/"),
+        lines: [...one.lines]
+      }))
+    };
+    mkdirSync2(dirname(path), { recursive: true });
+    writeFileSync2(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(readFileSync3(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(join2(projectPath, script)), lines });
+      }
+    }
+    return held;
+  } catch {
+    return [];
+  }
+}
+function withinProject(projectPath, scriptPath) {
+  const rel = relative2(projectPath, scriptPath);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute2(rel);
+}
+
+// src/bridge-announce.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join3 } from "node:path";
 function announcementPath(projectPath) {
-  return join2(projectPath, ".godot", "gdharness-bridge.json");
+  return join3(projectPath, ".godot", "gdharness-bridge.json");
 }
 var BRIDGE_ANNOUNCE_PROTOCOL = 1;
 function readAnnouncement(path) {
   try {
-    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -24779,7 +24898,7 @@ function announcementIsOurs(path) {
 function announceBridge(projectPath, bridge) {
   const path = announcementPath(projectPath);
   try {
-    mkdirSync2(dirname(path), { recursive: true });
+    mkdirSync3(dirname2(path), { recursive: true });
     const announcement = {
       protocol: BRIDGE_ANNOUNCE_PROTOCOL,
       host: bridge.host,
@@ -24788,7 +24907,7 @@ function announceBridge(projectPath, bridge) {
       version: bridge.version,
       startedAt: new Date().toISOString()
     };
-    writeFileSync2(path, `${JSON.stringify(announcement, null, 2)}
+    writeFileSync3(path, `${JSON.stringify(announcement, null, 2)}
 `, "utf8");
     return path;
   } catch (error) {
@@ -24801,31 +24920,31 @@ function withdrawBridge(path) {
     return;
   }
   try {
-    rmSync(path, { force: true });
+    rmSync2(path, { force: true });
   } catch (error) {
     console.error(`[SERVER] Could not withdraw the editor bridge announcement: ${errorMessage(error)}`);
   }
 }
 
 // src/class-cache.ts
-import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync4, statSync } from "node:fs";
-import { join as join3 } from "node:path";
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync5, statSync } from "node:fs";
+import { join as join4 } from "node:path";
 var DECLARATION = /^(?:@[a-z_]+(?:\([^)\n]*\))?\s+)*class_name\s+([A-Za-z_][A-Za-z0-9_]*)/m;
 function declaredClasses(projectPath) {
   const declared = new Map;
   const visit = (directory, prefix) => {
-    if (existsSync2(join3(directory, ".gdignore"))) {
+    if (existsSync2(join4(directory, ".gdignore"))) {
       return;
     }
     for (const entry of readdirSync(directory, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) {
         continue;
       }
-      const path = join3(directory, entry.name);
+      const path = join4(directory, entry.name);
       if (entry.isDirectory()) {
         visit(path, `${prefix}${entry.name}/`);
       } else if (entry.isFile() && entry.name.endsWith(".gd")) {
-        const found = DECLARATION.exec(readFileSync4(path, "utf8"));
+        const found = DECLARATION.exec(readFileSync5(path, "utf8"));
         if (found?.[1]) {
           declared.set(found[1], `res://${prefix}${entry.name}`);
         }
@@ -24836,12 +24955,12 @@ function declaredClasses(projectPath) {
   return declared;
 }
 function cachedClasses(projectPath) {
-  const cache = join3(projectPath, ".godot", "global_script_class_cache.cfg");
+  const cache = join4(projectPath, ".godot", "global_script_class_cache.cfg");
   if (!existsSync2(cache)) {
     return null;
   }
   const listed = new Map;
-  const text = readFileSync4(cache, "utf8");
+  const text = readFileSync5(cache, "utf8");
   for (const entry of text.matchAll(/"class":\s*&"([^"]+)"[\s\S]*?"path":\s*"([^"]+)"/g)) {
     listed.set(entry[1] ?? "", entry[2] ?? "");
   }
@@ -24926,7 +25045,7 @@ function uncachedClassNote(types) {
   return `${types.join(", ")} ${one ? "is declared" : "are declared"} in this project and missing from ` + `.godot/global_script_class_cache.cfg, so a game launched now would not resolve ${one ? "it" : "them"} ` + "either. Try editor_rescan first: it asks the editor already running and starts nothing, and it " + "cleared this in 314ms in a second project with a 31-worker fan-out still importing. It is not " + "always enough, because a file another engine has already imported reads as settled and the " + "walk does not look inside it. project_import refresh_classes rewrites the cache from the " + "declarations on disk and does reach that case, at the cost of a short headless engine, which " + "is worth knowing when something else is already running against this project.";
 }
 function cacheWrittenAt(projectPath) {
-  const cache = join3(projectPath, ".godot", "global_script_class_cache.cfg");
+  const cache = join4(projectPath, ".godot", "global_script_class_cache.cfg");
   try {
     return statSync(cache).mtimeMs;
   } catch {
@@ -24950,17 +25069,17 @@ function unseenByEditor(projectPath, editorHolds) {
 }
 
 // src/config-pin.ts
-import { existsSync as existsSync3, readFileSync as readFileSync5 } from "node:fs";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync6 } from "node:fs";
+import { join as join5 } from "node:path";
 var PINNED = /\bgdharness@(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\b/g;
 function versionsNamedInConfig(projectPath) {
-  const config = join4(projectPath, ".mcp.json");
+  const config = join5(projectPath, ".mcp.json");
   if (!existsSync3(config)) {
     return [];
   }
   let text;
   try {
-    text = readFileSync5(config, "utf8");
+    text = readFileSync6(config, "utf8");
     JSON.parse(text);
   } catch {
     return [];
@@ -25127,7 +25246,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;
@@ -25172,11 +25294,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();
@@ -25192,10 +25310,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) => {
@@ -25215,11 +25330,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) {
@@ -25308,6 +25428,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") {
@@ -25346,6 +25497,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;
@@ -25358,38 +25546,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();
@@ -25488,11 +25734,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.`));
@@ -25571,14 +25813,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}` }]
     };
   }
 }
@@ -25715,65 +25953,6 @@ var import_subprotocol = __toESM(require_subprotocol(), 1);
 var import_websocket = __toESM(require_websocket(), 1);
 var import_websocket_server = __toESM(require_websocket_server(), 1);
 
-// src/paths.ts
-import { realpathSync } from "node:fs";
-import { isAbsolute, relative, resolve, sep } from "node:path";
-var RESOURCE_SCHEME = "res://";
-var OTHER_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]+:\/\//;
-function realPathOr(path) {
-  try {
-    return realpathSync.native(path);
-  } catch {
-    return path;
-  }
-}
-function isSameDirectory(onePath, otherPath) {
-  return relative(realPathOr(resolve(onePath)), realPathOr(resolve(otherPath))) === "";
-}
-function isWithinRoot(rootPath, candidatePath) {
-  const step = relative(resolve(rootPath), resolve(candidatePath));
-  return step !== ".." && !step.startsWith(`..${sep}`) && !isAbsolute(step);
-}
-function resolveWithinProject(projectPath, candidatePath) {
-  const trimmed = candidatePath.trim();
-  if (trimmed === "") {
-    return { ok: false, reason: "Path is empty." };
-  }
-  if (trimmed.includes("\x00")) {
-    return { ok: false, reason: "Path contains a null byte." };
-  }
-  const withoutScheme = trimmed.startsWith(RESOURCE_SCHEME) ? trimmed.slice(RESOURCE_SCHEME.length) : trimmed;
-  const scheme = OTHER_SCHEME.exec(withoutScheme);
-  if (scheme) {
-    return {
-      ok: false,
-      reason: `Path '${trimmed}' uses the '${scheme[0]}' scheme, which names somewhere other than this project.`
-    };
-  }
-  if (withoutScheme.startsWith("/") || withoutScheme.startsWith("\\") || isAbsolute(withoutScheme)) {
-    return {
-      ok: false,
-      reason: `Path '${trimmed}' is absolute; give a path inside the project, such as 'scenes/main.tscn'.`
-    };
-  }
-  if (withoutScheme.includes(":")) {
-    return {
-      ok: false,
-      reason: `Path '${trimmed}' contains ':', which no file inside a project is named with.`
-    };
-  }
-  const root = resolve(projectPath);
-  const absolutePath = resolve(root, withoutScheme);
-  if (!isWithinRoot(root, absolutePath)) {
-    return { ok: false, reason: `Path '${trimmed}' resolves outside the project directory.` };
-  }
-  const relativePath = relative(root, absolutePath).split(sep).join("/");
-  if (relativePath === "") {
-    return { ok: false, reason: `Path '${trimmed}' is the project directory itself, not a file in it.` };
-  }
-  return { ok: true, absolutePath, relativePath };
-}
-
 // src/godot-bridge.ts
 var DEFAULT_PORT = 6505;
 var DEFAULT_HOST = "127.0.0.1";
@@ -25942,6 +26121,7 @@ class GodotBridge extends EventEmitter {
       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
@@ -26084,6 +26264,7 @@ class GodotBridge extends EventEmitter {
           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 });
         }
@@ -26265,7 +26446,7 @@ import { promisify } from "node:util";
 // src/detection.ts
 import { existsSync as existsSync4, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 function resolveHomeDirectory() {
   try {
     return homedir2();
@@ -26289,7 +26470,7 @@ function scanDirectoryForGodotBinaries(directory, platform) {
     if (!pattern.test(name)) {
       continue;
     }
-    const fullPath = join5(directory, name);
+    const fullPath = join6(directory, name);
     try {
       const stat = statSync2(fullPath);
       if (stat.isFile()) {
@@ -26298,7 +26479,7 @@ function scanDirectoryForGodotBinaries(directory, platform) {
     } catch {}
   }
   matches.sort((a, b) => b.mtime - a.mtime);
-  return matches.map((m) => join5(directory, m.name));
+  return matches.map((m) => join6(directory, m.name));
 }
 function conventionalPaths(platform, home) {
   const paths = ["godot"];
@@ -26467,13 +26648,13 @@ class GodotLocator {
 
 // src/headless.ts
 import { execFile as execFile2 } from "node:child_process";
-import { mkdtempSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { mkdtempSync, writeFileSync as writeFileSync4 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 
 // src/scratch.ts
-import { rmSync as rmSync2 } from "node:fs";
+import { rmSync as rmSync3 } from "node:fs";
 var SWEPT = { recursive: true, force: true, maxRetries: 20, retryDelay: 250 };
 function discardWith(remove, paths) {
   const left = [];
@@ -26491,7 +26672,7 @@ function discardWith(remove, paths) {
 }
 function discard(...paths) {
   return discardWith((path) => {
-    rmSync2(path, SWEPT);
+    rmSync3(path, SWEPT);
   }, paths);
 }
 
@@ -26535,12 +26716,12 @@ function reason(stdout, stderr) {
   return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
 }
 async function runImport(godotPath, projectPath) {
-  const logDir = mkdtempSync(join6(tmpdir2(), "gdharness-import-"));
+  const logDir = mkdtempSync(join7(tmpdir2(), "gdharness-import-"));
   try {
     const { stderr } = await run2(godotPath, [
       "--headless",
       "--log-file",
-      join6(logDir, "engine.log"),
+      join7(logDir, "engine.log"),
       "--path",
       projectPath,
       "--import"
@@ -26565,13 +26746,13 @@ async function runImport(godotPath, projectPath) {
   }
 }
 async function runOperation(engine, operation, params, projectPath) {
-  const paramsDir = mkdtempSync(join6(tmpdir2(), "gdharness-params-"));
-  const paramsFile = join6(paramsDir, `${operation}.json`);
-  writeFileSync3(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
+  const paramsDir = mkdtempSync(join7(tmpdir2(), "gdharness-params-"));
+  const paramsFile = join7(paramsDir, `${operation}.json`);
+  writeFileSync4(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
     "--log-file",
-    join6(paramsDir, "engine.log"),
+    join7(paramsDir, "engine.log"),
     "--path",
     projectPath,
     "--script",
@@ -27000,7 +27181,7 @@ function orphansPrinted(printed) {
 import { realpathSync as realpathSync2 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection2 } from "node:net";
-import { dirname as dirname2, resolve as resolve2 } from "node:path";
+import { dirname as dirname3, resolve as resolve2 } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 var DEFAULT_LSP_PORT = 6005;
 var DIAGNOSTICS_TIMEOUT_MS = 5000;
@@ -27130,7 +27311,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname2(resolve2(filePath));
+    const rootPath = this.rootPath ?? dirname3(resolve2(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params) {
@@ -27566,14 +27747,14 @@ function secondsFromClock(printed) {
 }
 
 // src/project-scan.ts
-import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync6 } from "node:fs";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync7 } from "node:fs";
+import { join as join8 } from "node:path";
 var SKIPPED = new Set(["node_modules"]);
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
 function steppedOver(directory) {
-  return existsSync6(join7(directory, ".gdignore"));
+  return existsSync6(join8(directory, ".gdignore"));
 }
 var ASSET_EXTENSIONS = new Set(["png", "jpg", "jpeg", "webp", "svg", "ttf", "otf", "wav", "mp3", "ogg"]);
 function projectStructure(projectPath) {
@@ -27587,7 +27768,7 @@ function projectStructure(projectPath) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join7(directory, entry.name));
+        visit(join8(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (extension === "tscn") {
@@ -27618,14 +27799,14 @@ function scriptsWithoutUid(projectPath) {
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join7(directory, entry.name), spelled);
+        visit(join8(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync6(join7(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync6(join8(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -27660,7 +27841,7 @@ function searchProject(projectPath, options) {
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join7(directory, entry.name);
+      const entryPath = join8(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -27671,7 +27852,7 @@ function searchProject(projectPath, options) {
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync6(entryPath, "utf8").split(`
+      for (const [index, line] of readFileSync7(entryPath, "utf8").split(`
 `).entries()) {
         if (full()) {
           break;
@@ -27694,7 +27875,7 @@ function searchProject(projectPath, options) {
 }
 
 // src/resources.ts
-import { readFileSync as readFileSync7 } from "node:fs";
+import { readFileSync as readFileSync8 } from "node:fs";
 import { extname, resolve as resolve3 } from "node:path";
 var STATIC_RESOURCES = [
   {
@@ -27889,7 +28070,7 @@ function readResourceText(uri, getProjectPath) {
   const parsedUri = parseGodotUri(uri);
   if (parsedUri.kind === "project-info") {
     const projectFilePath = resolveProjectFile(projectPath, "project.godot");
-    const rawProject = readFileSync7(projectFilePath, "utf-8");
+    const rawProject = readFileSync8(projectFilePath, "utf-8");
     const parsedProject = parseProjectGodot(rawProject);
     return {
       mimeType: "application/json",
@@ -27898,7 +28079,7 @@ function readResourceText(uri, getProjectPath) {
   }
   const filePath = resolveProjectFile(projectPath, parsedUri.resourcePath);
   ensureAllowedExtension(parsedUri.kind, filePath);
-  const text = readFileSync7(filePath, "utf-8");
+  const text = readFileSync8(filePath, "utf-8");
   return {
     mimeType: parsedUri.kind === "script" ? "text/x-gdscript" : "text/plain",
     text
@@ -27935,16 +28116,16 @@ function setupResourceHandlers(mcp, getProjectPath) {
 }
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync8, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname3, join as join8 } from "node:path";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync9, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname4, join as join9 } from "node:path";
 function restartNotePath(projectPath) {
-  return join8(projectPath, ".godot", "gdharness-restart.json");
+  return join9(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync3(dirname3(path), { recursive: true });
-    writeFileSync4(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync4(dirname4(path), { recursive: true });
+    writeFileSync5(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
@@ -27952,7 +28133,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync8(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync9(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -27967,7 +28148,7 @@ function restartOwed(projectPath) {
 }
 function restartSettled(projectPath) {
   try {
-    rmSync3(restartNotePath(projectPath), { force: true });
+    rmSync4(restartNotePath(projectPath), { force: true });
   } catch (error) {
     console.error(`[SERVER] Could not clear the restart note: ${errorMessage(error)}`);
   }
@@ -27975,14 +28156,14 @@ function restartSettled(projectPath) {
 
 // src/run-record.ts
 import { execFileSync } from "node:child_process";
-import { mkdirSync as mkdirSync4, openSync, readdirSync as readdirSync5, readFileSync as readFileSync10, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync5 } from "node:fs";
-import { basename, join as join10 } from "node:path";
+import { mkdirSync as mkdirSync5, openSync, readdirSync as readdirSync5, readFileSync as readFileSync11, rmSync as rmSync5, statSync as statSync3, writeFileSync as writeFileSync6 } from "node:fs";
+import { basename, join as join11 } from "node:path";
 
 // src/runtime-client.ts
-import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync9, unlinkSync } from "node:fs";
+import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync10, unlinkSync } from "node:fs";
 import { createConnection as createConnection3 } from "node:net";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join9, resolve as resolve4 } from "node:path";
+import { join as join10, resolve as resolve4 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
 
 // src/tool-args.ts
@@ -28050,13 +28231,13 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join9(perUser ?? tmpdir3(), "gdharness");
+  return join10(perUser ?? tmpdir3(), "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(join9(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+    candidates.push(join10(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
   return [...new Set(candidates.map((path) => resolve4(path)))];
 }
@@ -28071,7 +28252,7 @@ function processAlive(pid) {
 function parseAnnouncement(file, pid) {
   let fields;
   try {
-    fields = asParams(JSON.parse(readFileSync9(file, "utf8")));
+    fields = asParams(JSON.parse(readFileSync10(file, "utf8")));
   } catch {
     return { kind: "rubbish" };
   }
@@ -28115,7 +28296,7 @@ var gone = [];
 function wentAway(file, pid) {
   let project = "";
   try {
-    const fields = asParams(JSON.parse(readFileSync9(file, "utf8")));
+    const fields = asParams(JSON.parse(readFileSync10(file, "utf8")));
     project = readString(readParams(fields, "project") ?? {}, "path") ?? "";
   } catch {
     return;
@@ -28144,7 +28325,7 @@ function announcedIn(directory) {
     if (!match) {
       continue;
     }
-    const file = join9(directory, entry);
+    const file = join10(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
     const alive = processAlive(pid);
     const announced = alive ? parseAnnouncement(file, pid) : { kind: "rubbish" };
@@ -28187,7 +28368,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) };
@@ -28218,14 +28417,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.`
   };
 }
 var nextRequestId = 1;
@@ -28319,33 +28518,33 @@ function runtimeRequest(endpoint, command, params, timeoutMs) {
 
 // src/run-record.ts
 function runsDirectory() {
-  return join10(runtimeDirectory(), "runs");
+  return join11(runtimeDirectory(), "runs");
 }
 function recordPath() {
-  return join10(runsDirectory(), "run.json");
+  return join11(runsDirectory(), "run.json");
 }
 function recordPaths() {
-  return runtimeDirectories().map((directory) => join10(directory, "runs", "run.json"));
+  return runtimeDirectories().map((directory) => join11(directory, "runs", "run.json"));
 }
 function openTranscript(startedAt) {
-  mkdirSync4(runsDirectory(), { recursive: true });
-  const path = join10(runsDirectory(), `run-${startedAt}.log`);
+  mkdirSync5(runsDirectory(), { recursive: true });
+  const path = join11(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync(path, "a") };
 }
 function writeRunRecord(record) {
-  mkdirSync4(runsDirectory(), { recursive: true });
-  writeFileSync5(recordPath(), JSON.stringify(record, null, 2), "utf8");
+  mkdirSync5(runsDirectory(), { recursive: true });
+  writeFileSync6(recordPath(), JSON.stringify(record, null, 2), "utf8");
 }
 function editorNotePath() {
-  return join10(runsDirectory(), "editor-run.json");
+  return join11(runsDirectory(), "editor-run.json");
 }
 function writeEditorRunNote(note) {
-  mkdirSync4(runsDirectory(), { recursive: true });
-  writeFileSync5(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
+  mkdirSync5(runsDirectory(), { recursive: true });
+  writeFileSync6(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
 }
 function readEditorRunNote() {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(join10(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(join11(directory, "runs", "editor-run.json"));
     if (note !== null) {
       return note;
     }
@@ -28355,7 +28554,7 @@ function readEditorRunNote() {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync10(path, "utf8"));
+    parsed = JSON.parse(readFileSync11(path, "utf8"));
   } catch {
     return null;
   }
@@ -28378,7 +28577,7 @@ function recordRunEnded(pid, exitCode) {
     return;
   }
   try {
-    writeFileSync5(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
+    writeFileSync6(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
   } catch {}
 }
 function readRunRecord() {
@@ -28393,7 +28592,7 @@ function readRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync10(path, "utf8"));
+    parsed = JSON.parse(readFileSync11(path, "utf8"));
   } catch {
     return null;
   }
@@ -28438,7 +28637,7 @@ function runningAs(pid) {
     const began = startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync10(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync11(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = execFileSync("ps", ["-p", String(pid), "-o", "args="], {
@@ -28560,7 +28759,7 @@ function clearRunRecord(ours = () => true) {
       continue;
     }
     try {
-      rmSync4(path);
+      rmSync5(path);
     } catch {}
   }
 }
@@ -28584,19 +28783,19 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join10(directory, entry);
+    const path = join11(directory, entry);
     if (path === keep || ageMs(path, now) < keepMs) {
       continue;
     }
     try {
-      rmSync4(path);
+      rmSync5(path);
     } catch {}
   }
 }
 
 // src/setup.ts
-import { cpSync, existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync11, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname4, join as join11 } from "node:path";
+import { cpSync, existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync12, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname5, join as join12 } from "node:path";
 var ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
 var RUNTIME_AUTOLOAD = {
   name: "GdharnessRuntime",
@@ -28604,11 +28803,11 @@ var RUNTIME_AUTOLOAD = {
 };
 var VERSION_MARKER = ".gdharness-version";
 function installedAddonVersion(projectPath) {
-  const marker = join11(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  const marker = join12(projectPath, "addons", ADDONS[0], VERSION_MARKER);
   if (!existsSync8(marker)) {
     return null;
   }
-  const said = readFileSync11(marker, "utf8").trim();
+  const said = readFileSync12(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 
@@ -28636,6 +28835,10 @@ var RUNNING_PROJECT_PATH = {
   type: "string",
   description: "Which game, when more than one is running: the project directory it was started from. Not needed with one game."
 };
+var 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."
+};
 var SCENE_PATH = {
   type: "string",
   description: 'Scene file inside the project, such as "scenes/main.tscn" or "res://scenes/main.tscn".'
@@ -29274,7 +29477,7 @@ var TOOL_SPECS = [
   },
   {
     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",
@@ -29302,7 +29505,7 @@ var TOOL_SPECS = [
   },
   {
     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: []
   },
@@ -29359,6 +29562,7 @@ var TOOL_SPECS = [
     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"],
@@ -29437,6 +29641,7 @@ var TOOL_SPECS = [
     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",
@@ -29476,6 +29681,7 @@ var TOOL_SPECS = [
     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"],
@@ -29496,6 +29702,7 @@ var TOOL_SPECS = [
     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"],
@@ -29592,6 +29799,7 @@ var TOOL_SPECS = [
     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"],
@@ -29627,7 +29835,7 @@ var TOOL_SPECS = [
   },
   {
     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,
@@ -29652,7 +29860,7 @@ var TOOL_SPECS = [
   },
   {
     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",
@@ -29719,12 +29927,33 @@ function buildToolDefinitions() {
 var UPDATE_NOTICE_EVERY = 500;
 var FEEDBACK_NOTICE_EVERY = 250;
 var run4 = promisify4(execFile4);
-var __dirname2 = dirname5(fileURLToPath2(import.meta.url));
+var __dirname2 = dirname6(fileURLToPath2(import.meta.url));
 var EDITOR_RESTART_TIMEOUT_MS = 90000;
+var HOLD_PING_MS = 2000;
 var SLOWEST_FRAME_RATE = 20;
 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;
@@ -29746,6 +29975,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 };
@@ -29915,7 +30157,7 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync9(join12(projectPath, wanted))) {
+  if (wanted === "" || existsSync9(join13(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -29929,11 +30171,11 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync12(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync13(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync12(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync13(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -29949,7 +30191,7 @@ function camelCased(params) {
 class GodotServer {
   mcp;
   locator = new GodotLocator;
-  operationsScript = join12(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join13(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -29961,6 +30203,7 @@ class GodotServer {
   lastGodotVersion = null;
   lspClient = null;
   dapClient = null;
+  breakpointsSeededOn = null;
   bridgeStartupError = null;
   bridgeRetry = null;
   successorWatch = null;
@@ -30485,7 +30728,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
@@ -30494,36 +30737,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") ?? []
@@ -30533,7 +30776,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
@@ -30541,7 +30784,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"] }
@@ -30559,17 +30802,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;
         }
@@ -30592,7 +30848,7 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join12(path, "project.godot");
+    const file = join13(path, "project.godot");
     if (!existsSync9(file)) {
       return {
         ok: false,
@@ -30618,7 +30874,7 @@ class GodotServer {
     }
     return { ok: true, value: given };
   }
-  async debuggedGame() {
+  async debuggedGame(intent) {
     const game = this.activeProcess;
     if (game !== null && game.exitCode !== null) {
       return {
@@ -30635,6 +30891,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,
@@ -30656,6 +30922,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.", [
@@ -30793,7 +31072,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync12(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync13(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -30854,18 +31133,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname5(output.absolutePath);
+    const folder = dirname6(output.absolutePath);
     try {
-      mkdirSync6(folder, { recursive: true });
+      mkdirSync7(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname5(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname6(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
-    const exportLogs = mkdtempSync2(join12(tmpdir4(), "gdharness-export-"));
+    const exportLogs = mkdtempSync2(join13(tmpdir4(), "gdharness-export-"));
     const exportArgs = [
       "--headless",
       "--log-file",
-      join12(exportLogs, "engine.log"),
+      join13(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -30923,7 +31202,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync9(join12(project.value.path, runner))) {
+    if (!existsSync9(join13(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"
       ]);
@@ -30958,7 +31237,7 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync2(join12(tmpdir4(), "gdharness-tests-"));
+    const userData = mkdtempSync2(join13(tmpdir4(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const hung = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -30974,14 +31253,14 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join12(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join13(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
       const written = existsSync9(reportsDir) ? readdirSync6(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(readFileSync12(join12(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync13(join13(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -31121,7 +31400,7 @@ class GodotServer {
         return null;
       }
       try {
-        return readFileSync12(contained.absolutePath, "utf8");
+        return readFileSync13(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -31163,7 +31442,7 @@ class GodotServer {
       return null;
     }
     try {
-      return readFileSync12(contained.absolutePath, "utf8");
+      return readFileSync13(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -31209,9 +31488,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) {
@@ -31268,6 +31576,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,
@@ -31301,8 +31610,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,
@@ -31311,8 +31624,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(),
@@ -31324,8 +31647,9 @@ class GodotServer {
         problem: located.ok ? undefined : GodotLocator.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) => ({
@@ -31343,7 +31667,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync12(join12(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync13(join13(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -31536,10 +31860,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));
@@ -31563,8 +31889,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({
@@ -31575,23 +31901,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 (!existsSync9(join12(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync9(join13(projectPath, RUNTIME_AUTOLOAD.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) {
@@ -31601,7 +31942,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
     });
   }
@@ -31624,6 +31965,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;
@@ -31641,7 +31983,8 @@ class GodotServer {
       startedAt,
       exitCode: null,
       throughEditor: true,
-      brokeOn: null
+      brokeOn: null,
+      announcedBefore: alreadyPlaying
     };
     this.activeProcess = played;
     writeEditorRunNote({ projectPath, transcript: transcript.path, startedAt });
@@ -31652,9 +31995,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) {
@@ -31850,7 +32198,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)}`);
     }
@@ -31872,6 +32220,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)) {
@@ -32000,12 +32360,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();
@@ -32015,7 +32385,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;
     }
@@ -32026,12 +32397,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.`);
@@ -32055,15 +32427,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,
@@ -32084,18 +32456,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)
     });
   }
@@ -32246,16 +32619,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 ? mkdtempSync2(join12(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join12(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? mkdtempSync2(join13(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
+    const screenshotPath = screenshotDir ? join13(screenshotDir, "capture.png") : null;
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs);
       if (!reply.ok) {
@@ -32276,7 +32701,7 @@ class GodotServer {
       return {
         content: [
           { type: "text", text: `Screenshot captured: ${dimensions}` },
-          { type: "image", data: readFileSync12(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync13(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
@@ -32307,7 +32732,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 },
@@ -32318,18 +32743,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"],