gdharness 1.0.15 → 1.0.17

package/build/cli.js

@@ -47,10 +47,233 @@ var __esm = (fn, res, err) => () => {
 };
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/errors.ts
+function errorMessage(error, fallback = "Unknown error") {
+  if (error instanceof Error) {
+    return error.message || fallback;
+  }
+  if (typeof error === "string") {
+    return error || fallback;
+  }
+  if (typeof error === "number" || typeof error === "boolean") {
+    return String(error);
+  }
+  return fallback;
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(errorMessage(error), { cause: error });
+}
+var Refusal;
+var init_errors = __esm(() => {
+  Refusal = class Refusal extends Error {
+  };
+});
+
+// src/process-children.ts
+import { execFile, execFileSync, spawnSync } from "node:child_process";
+import { basename } from "node:path";
+import { promisify } from "node:util";
+function startTimesOf(pids) {
+  const began = new Map;
+  if (pids.length === 0) {
+    return began;
+  }
+  try {
+    if (process.platform === "win32") {
+      const filter = pids.map((pid) => `ProcessId=${pid}`).join(" OR ");
+      const said = execFileSync("powershell", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `Get-CimInstance Win32_Process -Filter "${filter}" | ForEach-Object { "$($_.ProcessId) $(([DateTimeOffset]$_.CreationDate).ToUnixTimeMilliseconds())" }`
+      ], { encoding: "utf8", timeout: ASK_TIMEOUT_MS, windowsHide: true });
+      for (const line of said.split(`
+`)) {
+        const found = /^\s*(\d+)\s+(\d+)\s*$/.exec(line);
+        if (found?.[1] !== undefined && found[2] !== undefined) {
+          began.set(Number(found[1]), Number(found[2]));
+        }
+      }
+      return began;
+    }
+    const said = spawnSync("ps", ["-p", pids.join(","), "-o", "pid=,lstart="], {
+      encoding: "utf8",
+      timeout: ASK_TIMEOUT_MS,
+      env: { ...process.env, LC_ALL: "C" }
+    }).stdout;
+    for (const line of said.split(`
+`)) {
+      const found = /^\s*(\d+)\s+(.+)$/.exec(line);
+      const at = Date.parse(found?.[2]?.trim() ?? "");
+      if (found?.[1] !== undefined && !Number.isNaN(at)) {
+        began.set(Number(found[1]), at);
+      }
+    }
+  } catch {}
+  return began;
+}
+async function processTree() {
+  try {
+    if (process.platform === "win32") {
+      return parseProcessTable(await askWindows(), true);
+    }
+    return parseProcessTable(await askPosix());
+  } catch {
+    return;
+  }
+}
+function parseProcessTable(printed, started = false) {
+  const tree = new Map;
+  for (const line of printed.split(/\r?\n/)) {
+    const fields = /^\s*(\d+)\s+(\d+)(?:\s+(.*))?$/.exec(line);
+    if (fields === null) {
+      continue;
+    }
+    const pid = Number(fields[1]);
+    const parent = Number(fields[2]);
+    const rest = (fields[3] ?? "").trim();
+    if (pid <= 0) {
+      continue;
+    }
+    if (!started) {
+      tree.set(pid, { parent, command: rest });
+      continue;
+    }
+    const timed = /^(\d+)(?:\s+(.*))?$/.exec(rest);
+    if (timed === null) {
+      continue;
+    }
+    const began = Number(timed[1]);
+    tree.set(pid, { parent, command: (timed[2] ?? "").trim(), ...began > 0 ? { startedAt: began } : {} });
+  }
+  return tree;
+}
+function linked(tree, child, parent) {
+  const from = tree.get(child);
+  const to = tree.get(parent);
+  if (from === undefined || from.parent !== parent) {
+    return false;
+  }
+  if (from.startedAt === undefined || to?.startedAt === undefined) {
+    return true;
+  }
+  return from.startedAt >= to.startedAt;
+}
+function childrenIn(tree, pid) {
+  const children = [];
+  for (const child of tree.keys()) {
+    if (linked(tree, child, pid)) {
+      children.push(child);
+    }
+  }
+  return children;
+}
+function descendantsIn(tree, pid) {
+  const found = [];
+  const queue = [pid];
+  const seen = new Set([pid]);
+  while (queue.length > 0) {
+    const next = queue.shift();
+    if (next === undefined) {
+      break;
+    }
+    for (const child of childrenIn(tree, next)) {
+      if (!seen.has(child)) {
+        seen.add(child);
+        found.push(child);
+        queue.push(child);
+      }
+    }
+  }
+  return found;
+}
+function ancestorsIn(tree, pid, root) {
+  const chain = [];
+  const seen = new Set([pid]);
+  let child = pid;
+  let parent = tree.get(pid)?.parent;
+  while (parent !== undefined && !seen.has(parent) && linked(tree, child, parent)) {
+    chain.push(parent);
+    if (parent === root) {
+      break;
+    }
+    seen.add(parent);
+    child = parent;
+    parent = tree.get(parent)?.parent;
+  }
+  return chain;
+}
+function readCommandLine(command) {
+  const words = commandWords(command);
+  const executable = words[0] === undefined ? "" : basename(words[0].replaceAll("\\", "/"));
+  const at = words.indexOf("--path");
+  let projectPath = null;
+  if (at !== -1 && at + 1 < words.length) {
+    const taken = [];
+    for (const word of words.slice(at + 1)) {
+      if (taken.length > 0 && (word.startsWith("-") || /^[a-z]+:\/\//.test(word))) {
+        break;
+      }
+      taken.push(word);
+    }
+    projectPath = taken.join(" ");
+  }
+  return {
+    executable,
+    projectPath,
+    editor: words.some((word) => word === "-e" || word === "--editor")
+  };
+}
+function commandWords(command) {
+  const words = [];
+  let word = "";
+  let quoted = false;
+  let started = false;
+  for (const char of command) {
+    if (char === '"') {
+      quoted = !quoted;
+      started = true;
+    } else if (!quoted && /\s/.test(char)) {
+      if (started) {
+        words.push(word);
+        word = "";
+        started = false;
+      }
+    } else {
+      word += char;
+      started = true;
+    }
+  }
+  if (started) {
+    words.push(word);
+  }
+  return words;
+}
+async function askWindows() {
+  const { stdout } = await run("powershell.exe", [
+    "-NoProfile",
+    "-NonInteractive",
+    "-Command",
+    `${POWERSHELL_UTF8}Get-CimInstance Win32_Process | ForEach-Object { $began = 0; if ($_.CreationDate) { $began = ([DateTimeOffset]$_.CreationDate).ToUnixTimeMilliseconds() }; "$($_.ProcessId) $($_.ParentProcessId) $began $($_.CommandLine)" }`
+  ], { timeout: ASK_TIMEOUT_MS, windowsHide: true, maxBuffer: 16 * 1024 * 1024 });
+  return stdout;
+}
+async function askPosix() {
+  const { stdout } = await run("ps", ["-e", "-o", "pid=,ppid=,args="], {
+    timeout: ASK_TIMEOUT_MS,
+    maxBuffer: 16 * 1024 * 1024
+  });
+  return stdout;
+}
+var run, POWERSHELL_UTF8 = "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; ", ASK_TIMEOUT_MS = 15000;
+var init_process_children = __esm(() => {
+  run = promisify(execFile);
+});
+
 // src/detection.ts
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 function resolveHomeDirectory() {
   try {
     return homedir();
@@ -74,7 +297,7 @@ function scanDirectoryForGodotBinaries(directory, platform) {
     if (!pattern.test(name)) {
       continue;
     }
-    const fullPath = join(directory, name);
+    const fullPath = join2(directory, name);
     try {
       const stat = statSync(fullPath);
       if (stat.isFile()) {
@@ -83,7 +306,7 @@ function scanDirectoryForGodotBinaries(directory, platform) {
     } catch {}
   }
   matches.sort((a, b) => b.mtime - a.mtime);
-  return matches.map((m) => join(directory, m.name));
+  return matches.map((m) => join2(directory, m.name));
 }
 function conventionalPaths(platform, home) {
   const paths = ["godot"];
@@ -133,28 +356,6 @@ function godotCandidates(platform, home) {
 }
 var init_detection = () => {};
 
-// src/errors.ts
-function errorMessage(error, fallback = "Unknown error") {
-  if (error instanceof Error) {
-    return error.message || fallback;
-  }
-  if (typeof error === "string") {
-    return error || fallback;
-  }
-  if (typeof error === "number" || typeof error === "boolean") {
-    return String(error);
-  }
-  return fallback;
-}
-function toError(error) {
-  return error instanceof Error ? error : new Error(errorMessage(error), { cause: error });
-}
-var Refusal2;
-var init_errors = __esm(() => {
-  Refusal2 = class Refusal2 extends Error {
-  };
-});
-
 // src/launch.ts
 function envValue(name, variables = process.env) {
   const value = variables[name];
@@ -7161,7 +7362,7 @@ var require_public_api = __commonJS(function(exports) {
 
 // src/runner.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { dirname, join as join2 } from "node:path";
+import { dirname as dirname2, join as join3 } from "node:path";
 import process2 from "node:process";
 function currentRunner() {
   const versions = process2.versions;
@@ -7182,11 +7383,24 @@ function spawnFor(runner, version, execPath = process2.execPath) {
   return { command: alongside(execPath, "npx") ?? "npx", args: ["-y", spec] };
 }
 function alongside(execPath, name) {
-  const runner = join2(dirname(execPath), process2.platform === "win32" ? `${name}.cmd` : name);
+  const runner = join3(dirname2(execPath), process2.platform === "win32" ? `${name}.cmd` : name);
   return existsSync3(runner) ? runner : undefined;
 }
 var init_runner = () => {};
 
+// src/call-signal.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+function withCallSignal(signal, answer) {
+  return signal === undefined ? answer() : current.run(signal, answer);
+}
+function callSignal() {
+  return current.getStore();
+}
+var current;
+var init_call_signal = __esm(() => {
+  current = new AsyncLocalStorage;
+});
+
 // src/dictionary.ts
 function emptyRecord() {
   return Object.create(null);
@@ -7311,7 +7525,7 @@ var init_game_log = __esm(() => {
 });
 
 // src/scratch.ts
-import { rmSync as rmSync2 } from "node:fs";
+import { rmSync as rmSync3 } from "node:fs";
 function discardWith(remove, paths) {
   const left = [];
   for (const path of paths) {
@@ -7328,7 +7542,7 @@ function discardWith(remove, paths) {
 }
 function discard(...paths) {
   return discardWith((path) => {
-    rmSync2(path, SWEPT);
+    rmSync3(path, SWEPT);
   }, paths);
 }
 var SWEPT;
@@ -7337,9 +7551,9 @@ var init_scratch = __esm(() => {
 });
 
 // src/update-check.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 function packageUrl(root) {
   return `${root.replace(/\/+$/, "")}/gdharness/latest`;
 }
@@ -7361,20 +7575,20 @@ function cacheDirectory(environment) {
   };
   const home = set("HOME") ?? homedir3();
   if (process.platform === "win32") {
-    return join5(set("LOCALAPPDATA") ?? home, "gdharness");
+    return join6(set("LOCALAPPDATA") ?? home, "gdharness");
   }
   if (process.platform === "darwin") {
-    return join5(home, "Library", "Caches", "gdharness");
+    return join6(home, "Library", "Caches", "gdharness");
   }
-  return join5(set("XDG_CACHE_HOME") ?? join5(home, ".cache"), "gdharness");
+  return join6(set("XDG_CACHE_HOME") ?? join6(home, ".cache"), "gdharness");
 }
 function cacheFile(environment = process.env) {
   try {
     const directory = cacheDirectory(environment);
-    mkdirSync2(directory, { recursive: true, mode: 448 });
-    return join5(directory, "update-check.json");
+    mkdirSync3(directory, { recursive: true, mode: 448 });
+    return join6(directory, "update-check.json");
   } catch {
-    return join5(tmpdir2(), "gdharness-update-check.json");
+    return join6(tmpdir2(), "gdharness-update-check.json");
   }
 }
 function readCache(path) {
@@ -7382,7 +7596,7 @@ function readCache(path) {
     if (!existsSync5(path)) {
       return null;
     }
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -7399,7 +7613,7 @@ function readCache(path) {
 }
 function writeCache(path, entry) {
   try {
-    writeFileSync3(path, JSON.stringify(entry), { encoding: "utf8", mode: 384 });
+    writeFileSync4(path, JSON.stringify(entry), { encoding: "utf8", mode: 384 });
   } catch {}
 }
 function parts(version) {
@@ -7530,7 +7744,7 @@ var init_update_check = __esm(() => {
 });
 
 // src/server-version.ts
-import { readFileSync as readFileSync3 } from "node:fs";
+import { readFileSync as readFileSync4 } from "node:fs";
 function editorIsStale(addonVersion, serverVersion, addonDigest, shippedDigest) {
   if (addonDigest !== undefined && addonDigest !== "" && shippedDigest !== undefined) {
     return addonDigest !== shippedDigest;
@@ -7566,7 +7780,7 @@ var init_server_version = __esm(() => {
   GODOT_DEBUG_MODE_DEFAULT = process.env["GODOT_DEBUG"] === "true" || DEBUG_MODE;
   SERVER_VERSION = (() => {
     try {
-      const pkg = JSON.parse(readFileSync3(new URL("../package.json", import.meta.url), "utf8"));
+      const pkg = JSON.parse(readFileSync4(new URL("../package.json", import.meta.url), "utf8"));
       return typeof pkg.version === "string" ? pkg.version : "0.0.0";
     } catch {
       return "0.0.0";
@@ -7575,23 +7789,23 @@ var init_server_version = __esm(() => {
 });
 
 // src/class-cache.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync2 } from "node:fs";
-import { join as join6 } from "node:path";
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync6, statSync as statSync2 } from "node:fs";
+import { join as join7 } from "node:path";
 function declaredClasses(projectPath) {
   const declared = new Map;
   const visit = (directory, prefix) => {
-    if (existsSync6(join6(directory, ".gdignore"))) {
+    if (existsSync6(join7(directory, ".gdignore"))) {
       return;
     }
     for (const entry of readdirSync2(directory, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) {
         continue;
       }
-      const path = join6(directory, entry.name);
+      const path = join7(directory, entry.name);
       if (entry.isDirectory()) {
         visit(path, `${prefix}${entry.name}/`);
       } else if (entry.isFile() && entry.name.endsWith(".gd")) {
-        const found = DECLARATION.exec(readFileSync5(path, "utf8"));
+        const found = DECLARATION.exec(readFileSync6(path, "utf8"));
         if (found?.[1]) {
           declared.set(found[1], `res://${prefix}${entry.name}`);
         }
@@ -7602,12 +7816,12 @@ function declaredClasses(projectPath) {
   return declared;
 }
 function cachedClasses(projectPath) {
-  const cache = join6(projectPath, ".godot", "global_script_class_cache.cfg");
+  const cache = join7(projectPath, ".godot", "global_script_class_cache.cfg");
   if (!existsSync6(cache)) {
     return null;
   }
   const listed = new Map;
-  const text = readFileSync5(cache, "utf8");
+  const text = readFileSync6(cache, "utf8");
   for (const entry of text.matchAll(/"class":\s*&"([^"]+)"[\s\S]*?"path":\s*"([^"]+)"/g)) {
     listed.set(entry[1] ?? "", entry[2] ?? "");
   }
@@ -7692,7 +7906,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 = join6(projectPath, ".godot", "global_script_class_cache.cfg");
+  const cache = join7(projectPath, ".godot", "global_script_class_cache.cfg");
   try {
     return statSync2(cache).mtimeMs;
   } catch {
@@ -7706,14 +7920,14 @@ function declaredSince(projectPath, paths, names, since) {
       return false;
     }
     try {
-      return statSync2(join6(projectPath, path.slice("res://".length))).mtimeMs > since;
+      return statSync2(join7(projectPath, path.slice("res://".length))).mtimeMs > since;
     } catch {
       return false;
     }
   });
 }
 function cachedAtMissingPaths(cached, projectPath) {
-  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync6(join6(projectPath, path.slice("res://".length)))).map(([name]) => name).sort();
+  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync6(join7(projectPath, path.slice("res://".length)))).map(([name]) => name).sort();
 }
 function staleAgainst(cached, projectPath) {
   return [...declaredClasses(projectPath)].filter(([name, path]) => cached.get(name) !== path).map(([name]) => name);
@@ -7736,11 +7950,11 @@ var init_class_cache = __esm(() => {
 });
 
 // src/headless.ts
-import { execFile as execFile3 } from "node:child_process";
-import { mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { execFile as execFile4 } from "node:child_process";
+import { mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync5 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join7 } from "node:path";
-import { promisify as promisify3 } from "node:util";
+import { join as join8 } from "node:path";
+import { promisify as promisify4 } from "node:util";
 function snakeCased2(params) {
   const result = emptyRecord();
   for (const [key, value] of Object.entries(params)) {
@@ -7779,16 +7993,9 @@ function reason2(stdout, stderr) {
   return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
 }
 async function runImport(godotPath, projectPath) {
-  const logDir = mkdtempSync2(join7(tmpdir3(), "gdharness-import-"));
+  const logDir = mkdtempSync2(join8(tmpdir3(), "gdharness-import-"));
   try {
-    const { stderr } = await run3(godotPath, [
-      "--headless",
-      "--log-file",
-      join7(logDir, "engine.log"),
-      "--path",
-      projectPath,
-      "--import"
-    ]);
+    const { stderr } = await run4(godotPath, ["--headless", "--log-file", join8(logDir, "engine.log"), "--path", projectPath, "--import"], { signal: callSignal() });
     return { ok: true, messages: problems2(stderr) };
   } catch (error) {
     if (error instanceof Error && "stdout" in error && "stderr" in error) {
@@ -7809,13 +8016,13 @@ async function runImport(godotPath, projectPath) {
   }
 }
 async function runOperation2(engine, operation, params, projectPath) {
-  const paramsDir = mkdtempSync2(join7(tmpdir3(), "gdharness-params-"));
-  const paramsFile = join7(paramsDir, `${operation}.json`);
-  writeFileSync4(paramsFile, JSON.stringify(snakeCased2(params)), "utf8");
+  const paramsDir = mkdtempSync2(join8(tmpdir3(), "gdharness-params-"));
+  const paramsFile = join8(paramsDir, `${operation}.json`);
+  writeFileSync5(paramsFile, JSON.stringify(snakeCased2(params)), "utf8");
   const args = [
     "--headless",
     "--log-file",
-    join7(paramsDir, "engine.log"),
+    join8(paramsDir, "engine.log"),
     "--path",
     projectPath,
     "--script",
@@ -7827,7 +8034,7 @@ async function runOperation2(engine, operation, params, projectPath) {
   let stdout;
   let stderr;
   try {
-    ({ stdout, stderr } = await run3(engine.godotPath, args));
+    ({ stdout, stderr } = await run4(engine.godotPath, args, { signal: callSignal() }));
   } catch (error) {
     if (error instanceof Error && "stdout" in error && "stderr" in error) {
       const failed = error;
@@ -7855,11 +8062,12 @@ async function runOperation2(engine, operation, params, projectPath) {
   }
   return { ok: true, payload, messages: problems2(stderr) };
 }
-var run3;
+var run4;
 var init_headless = __esm(() => {
+  init_call_signal();
   init_game_log();
   init_scratch();
-  run3 = promisify3(execFile3);
+  run4 = promisify4(execFile4);
 });
 
 // node_modules/zod/v4/core/util.js
@@ -15027,26 +15235,26 @@ var init_paths = __esm(() => {
 });
 
 // src/resources.ts
-import { readFileSync as readFileSync6 } from "node:fs";
+import { readFileSync as readFileSync7 } from "node:fs";
 import { extname, resolve as resolve2 } from "node:path";
 function ensureProjectPath(getProjectPath) {
   const projectPath = getProjectPath();
   if (!projectPath) {
-    throw new Refusal2("Project path is not set. Set a Godot project path first.");
+    throw new Refusal("Project path is not set. Set a Godot project path first.");
   }
   return resolve2(projectPath);
 }
 function uriPathToProjectPath(inputPath) {
   const normalized = inputPath.replace(/\\/g, "/").trim();
   if (normalized.replace(/\//g, "") === "") {
-    throw new Refusal2("Resource path is empty.");
+    throw new Refusal("Resource path is empty.");
   }
   return normalized.replace(/^\/+/, "");
 }
 function resolveProjectFile(projectPath, resourcePath) {
   const contained = resolveWithinProject(projectPath, resourcePath);
   if (!contained.ok) {
-    throw new Refusal2(contained.reason);
+    throw new Refusal(contained.reason);
   }
   return contained.absolutePath;
 }
@@ -15058,14 +15266,14 @@ function parseGodotUri(uri) {
   try {
     parsed = new URL(uri);
   } catch {
-    throw new Refusal2(`Invalid URI: ${uri}`);
+    throw new Refusal(`Invalid URI: ${uri}`);
   }
   if (parsed.protocol !== "godot:") {
-    throw new Refusal2(`Unsupported URI scheme: ${parsed.protocol}`);
+    throw new Refusal(`Unsupported URI scheme: ${parsed.protocol}`);
   }
   const host = parsed.hostname;
   if (host !== "scene" && host !== "script" && host !== "resource") {
-    throw new Refusal2(`Unsupported Godot resource type: ${host}`);
+    throw new Refusal(`Unsupported Godot resource type: ${host}`);
   }
   const resourcePath = uriPathToProjectPath(decodeURIComponent(parsed.pathname));
   return { kind: host, resourcePath };
@@ -15073,13 +15281,13 @@ function parseGodotUri(uri) {
 function ensureAllowedExtension(kind, filePath) {
   const extension = extname(filePath).toLowerCase();
   if (kind === "scene" && extension !== ".tscn") {
-    throw new Refusal2("Scene resources must use .tscn extension.");
+    throw new Refusal("Scene resources must use .tscn extension.");
   }
   if (kind === "script" && extension !== ".gd") {
-    throw new Refusal2("Script resources must use .gd extension.");
+    throw new Refusal("Script resources must use .gd extension.");
   }
   if (kind === "resource" && ![".tres", ".tscn", ".gd"].includes(extension)) {
-    throw new Refusal2("Resource URIs support only .tres, .tscn, and .gd files.");
+    throw new Refusal("Resource URIs support only .tres, .tscn, and .gd files.");
   }
 }
 function isValueComplete(value) {
@@ -15193,7 +15401,7 @@ function readResourceText(uri, getProjectPath) {
   const parsedUri = parseGodotUri(uri);
   if (parsedUri.kind === "project-info") {
     const projectFilePath = resolveProjectFile(projectPath, "project.godot");
-    const rawProject = readFileSync6(projectFilePath, "utf-8");
+    const rawProject = readFileSync7(projectFilePath, "utf-8");
     const parsedProject = parseProjectGodot(rawProject);
     return {
       mimeType: "application/json",
@@ -15202,7 +15410,7 @@ function readResourceText(uri, getProjectPath) {
   }
   const filePath = resolveProjectFile(projectPath, parsedUri.resourcePath);
   ensureAllowedExtension(parsedUri.kind, filePath);
-  const text = readFileSync6(filePath, "utf-8");
+  const text = readFileSync7(filePath, "utf-8");
   return {
     mimeType: parsedUri.kind === "script" ? "text/x-gdscript" : "text/plain",
     text
@@ -15231,9 +15439,9 @@ function setupResourceHandlers(mcp, getProjectPath) {
       };
     } catch (error) {
       if (error instanceof Error) {
-        throw new Refusal2(`Failed to read resource '${uri}': ${error.message}`, { cause: error });
+        throw new Refusal(`Failed to read resource '${uri}': ${error.message}`, { cause: error });
       }
-      throw new Refusal2(`Failed to read resource '${uri}'.`, { cause: error });
+      throw new Refusal(`Failed to read resource '${uri}'.`, { cause: error });
     }
   });
 }
@@ -15334,14 +15542,14 @@ import { createHash as createHash3 } from "node:crypto";
 import {
   cpSync as cpSync2,
   existsSync as existsSync8,
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync5,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync8,
-  rmSync as rmSync4,
+  readFileSync as readFileSync9,
+  rmSync as rmSync5,
   statSync as statSync4,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "node:fs";
-import { dirname as dirname4, join as join9 } from "node:path";
+import { dirname as dirname5, join as join10 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function editorAddonDigest2(from = shippedAddonsDirectory2()) {
   const hash = createHash3("sha256");
@@ -15350,21 +15558,21 @@ function editorAddonDigest2(from = shippedAddonsDirectory2()) {
       if (name === VERSION_MARKER2 || name === DIGEST_MARKER2) {
         continue;
       }
-      const path = join9(directory, name);
+      const path = join10(directory, name);
       const inside = `${relative}/${name}`;
       if (statSync4(path).isDirectory()) {
         walk(path, inside);
       } else {
         hash.update(`${inside}
 `);
-        hash.update(readFileSync8(path));
+        hash.update(readFileSync9(path));
         hash.update(`
 `);
       }
     }
   };
   for (const name of EDITOR_PLUGINS2) {
-    walk(join9(from, name), name);
+    walk(join10(from, name), name);
   }
   return hash.digest("hex");
 }
@@ -15379,14 +15587,14 @@ function shippedEditorDigest() {
   return shippedDigest ?? undefined;
 }
 function shippedAddonsDirectory2() {
-  return join9(dirname4(fileURLToPath2(import.meta.url)), "godot", "addons");
+  return join10(dirname5(fileURLToPath2(import.meta.url)), "godot", "addons");
 }
 function installedAddonVersion(projectPath) {
-  const marker = join9(projectPath, "addons", ADDONS2[0], VERSION_MARKER2);
+  const marker = join10(projectPath, "addons", ADDONS2[0], VERSION_MARKER2);
   if (!existsSync8(marker)) {
     return null;
   }
-  const said = readFileSync8(marker, "utf8").trim();
+  const said = readFileSync9(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 var ADDONS2, EDITOR_PLUGINS2, RUNTIME_AUTOLOAD2, SCRIPT_RUNS_SETTING = "gdharness/runtime/serve_script_runs", BIND_ADDRESS_SETTING = "gdharness/runtime/bind_address", PORT_SETTING = "gdharness/runtime/port", VERSION_MARKER2 = ".gdharness-version", DIGEST_MARKER2 = ".gdharness-digest", shippedDigest;
@@ -31368,212 +31576,11 @@ var init_stdio2 = __esm(() => {
   init_stdio();
 });
 
-// src/process-children.ts
-import { execFile as execFile4, execFileSync, spawnSync as spawnSync2 } from "node:child_process";
-import { basename as basename2 } from "node:path";
-import { promisify as promisify4 } from "node:util";
-function startTimesOf(pids) {
-  const began = new Map;
-  if (pids.length === 0) {
-    return began;
-  }
-  try {
-    if (process.platform === "win32") {
-      const filter = pids.map((pid) => `ProcessId=${pid}`).join(" OR ");
-      const said = execFileSync("powershell", [
-        "-NoProfile",
-        "-NonInteractive",
-        "-Command",
-        `Get-CimInstance Win32_Process -Filter "${filter}" | ForEach-Object { "$($_.ProcessId) $(([DateTimeOffset]$_.CreationDate).ToUnixTimeMilliseconds())" }`
-      ], { encoding: "utf8", timeout: ASK_TIMEOUT_MS, windowsHide: true });
-      for (const line of said.split(`
-`)) {
-        const found = /^\s*(\d+)\s+(\d+)\s*$/.exec(line);
-        if (found?.[1] !== undefined && found[2] !== undefined) {
-          began.set(Number(found[1]), Number(found[2]));
-        }
-      }
-      return began;
-    }
-    const said = spawnSync2("ps", ["-p", pids.join(","), "-o", "pid=,lstart="], {
-      encoding: "utf8",
-      timeout: ASK_TIMEOUT_MS,
-      env: { ...process.env, LC_ALL: "C" }
-    }).stdout;
-    for (const line of said.split(`
-`)) {
-      const found = /^\s*(\d+)\s+(.+)$/.exec(line);
-      const at = Date.parse(found?.[2]?.trim() ?? "");
-      if (found?.[1] !== undefined && !Number.isNaN(at)) {
-        began.set(Number(found[1]), at);
-      }
-    }
-  } catch {}
-  return began;
-}
-async function processTree() {
-  try {
-    if (process.platform === "win32") {
-      return parseProcessTable(await askWindows(), true);
-    }
-    return parseProcessTable(await askPosix());
-  } catch {
-    return;
-  }
-}
-function parseProcessTable(printed, started = false) {
-  const tree = new Map;
-  for (const line of printed.split(/\r?\n/)) {
-    const fields = /^\s*(\d+)\s+(\d+)(?:\s+(.*))?$/.exec(line);
-    if (fields === null) {
-      continue;
-    }
-    const pid = Number(fields[1]);
-    const parent = Number(fields[2]);
-    const rest = (fields[3] ?? "").trim();
-    if (pid <= 0) {
-      continue;
-    }
-    if (!started) {
-      tree.set(pid, { parent, command: rest });
-      continue;
-    }
-    const timed = /^(\d+)(?:\s+(.*))?$/.exec(rest);
-    if (timed === null) {
-      continue;
-    }
-    const began = Number(timed[1]);
-    tree.set(pid, { parent, command: (timed[2] ?? "").trim(), ...began > 0 ? { startedAt: began } : {} });
-  }
-  return tree;
-}
-function linked(tree, child, parent) {
-  const from = tree.get(child);
-  const to = tree.get(parent);
-  if (from === undefined || from.parent !== parent) {
-    return false;
-  }
-  if (from.startedAt === undefined || to?.startedAt === undefined) {
-    return true;
-  }
-  return from.startedAt >= to.startedAt;
-}
-function childrenIn(tree, pid) {
-  const children = [];
-  for (const child of tree.keys()) {
-    if (linked(tree, child, pid)) {
-      children.push(child);
-    }
-  }
-  return children;
-}
-function descendantsIn(tree, pid) {
-  const found = [];
-  const queue = [pid];
-  const seen = new Set([pid]);
-  while (queue.length > 0) {
-    const next = queue.shift();
-    if (next === undefined) {
-      break;
-    }
-    for (const child of childrenIn(tree, next)) {
-      if (!seen.has(child)) {
-        seen.add(child);
-        found.push(child);
-        queue.push(child);
-      }
-    }
-  }
-  return found;
-}
-function ancestorsIn(tree, pid, root) {
-  const chain = [];
-  const seen = new Set([pid]);
-  let child = pid;
-  let parent = tree.get(pid)?.parent;
-  while (parent !== undefined && !seen.has(parent) && linked(tree, child, parent)) {
-    chain.push(parent);
-    if (parent === root) {
-      break;
-    }
-    seen.add(parent);
-    child = parent;
-    parent = tree.get(parent)?.parent;
-  }
-  return chain;
-}
-function readCommandLine(command) {
-  const words = commandWords(command);
-  const executable = words[0] === undefined ? "" : basename2(words[0].replaceAll("\\", "/"));
-  const at = words.indexOf("--path");
-  let projectPath = null;
-  if (at !== -1 && at + 1 < words.length) {
-    const taken = [];
-    for (const word of words.slice(at + 1)) {
-      if (taken.length > 0 && (word.startsWith("-") || /^[a-z]+:\/\//.test(word))) {
-        break;
-      }
-      taken.push(word);
-    }
-    projectPath = taken.join(" ");
-  }
-  return {
-    executable,
-    projectPath,
-    editor: words.some((word) => word === "-e" || word === "--editor")
-  };
-}
-function commandWords(command) {
-  const words = [];
-  let word = "";
-  let quoted = false;
-  let started = false;
-  for (const char of command) {
-    if (char === '"') {
-      quoted = !quoted;
-      started = true;
-    } else if (!quoted && /\s/.test(char)) {
-      if (started) {
-        words.push(word);
-        word = "";
-        started = false;
-      }
-    } else {
-      word += char;
-      started = true;
-    }
-  }
-  if (started) {
-    words.push(word);
-  }
-  return words;
-}
-async function askWindows() {
-  const { stdout } = await run4("powershell.exe", [
-    "-NoProfile",
-    "-NonInteractive",
-    "-Command",
-    `${POWERSHELL_UTF8}Get-CimInstance Win32_Process | ForEach-Object { $began = 0; if ($_.CreationDate) { $began = ([DateTimeOffset]$_.CreationDate).ToUnixTimeMilliseconds() }; "$($_.ProcessId) $($_.ParentProcessId) $began $($_.CommandLine)" }`
-  ], { timeout: ASK_TIMEOUT_MS, windowsHide: true, maxBuffer: 16 * 1024 * 1024 });
-  return stdout;
-}
-async function askPosix() {
-  const { stdout } = await run4("ps", ["-e", "-o", "pid=,ppid=,args="], {
-    timeout: ASK_TIMEOUT_MS,
-    maxBuffer: 16 * 1024 * 1024
-  });
-  return stdout;
-}
-var run4, POWERSHELL_UTF8 = "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; ", ASK_TIMEOUT_MS = 15000;
-var init_process_children = __esm(() => {
-  run4 = promisify4(execFile4);
-});
-
 // src/runtime-client.ts
-import { existsSync as existsSync10, readdirSync as readdirSync6, readFileSync as readFileSync10, statSync as statSync5, unlinkSync } from "node:fs";
+import { existsSync as existsSync10, readdirSync as readdirSync6, readFileSync as readFileSync11, statSync as statSync5, unlinkSync } from "node:fs";
 import { createConnection } from "node:net";
 import { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname7, join as join12, resolve as resolve3 } from "node:path";
+import { dirname as dirname8, join as join13, resolve as resolve3 } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 function runtimeDirectory(variables = process.env) {
   const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
@@ -31581,19 +31588,19 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join12(perUser ?? tmpdir4(), "gdharness");
+  return join13(perUser ?? tmpdir4(), "gdharness");
 }
 function runtimeDirectories(variables = process.env) {
   const candidates = [runtimeDirectory(variables)];
   const fallbacks = process.platform === "win32" ? [envValue("SystemRoot", variables) ?? envValue("windir", variables) ?? "C:\\Windows"] : ["/tmp", "/var/tmp"];
   for (const base of fallbacks) {
-    candidates.push(join12(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+    candidates.push(join13(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
   return [...new Set(candidates.map((path) => resolve3(path)))];
 }
 function errorReportOf(pid, directories = runtimeDirectories()) {
   for (const directory of directories) {
-    const path = join12(directory, `runtime-${pid}.log`);
+    const path = join13(directory, `runtime-${pid}.log`);
     if (existsSync10(path)) {
       return path;
     }
@@ -31611,7 +31618,7 @@ function processAlive(pid) {
 function parseAnnouncement(file, pid) {
   let fields;
   try {
-    fields = asParams(JSON.parse(readFileSync10(file, "utf8")));
+    fields = asParams(JSON.parse(readFileSync11(file, "utf8")));
   } catch {
     return { kind: "rubbish" };
   }
@@ -31663,7 +31670,7 @@ function discoverRuntimes(directories = runtimeDirectories()) {
 function wentAway(file, pid) {
   let project = "";
   try {
-    const fields = asParams(JSON.parse(readFileSync10(file, "utf8")));
+    const fields = asParams(JSON.parse(readFileSync11(file, "utf8")));
     project = readString(readParams(fields, "project") ?? {}, "path") ?? "";
   } catch {
     return;
@@ -31709,14 +31716,14 @@ function announcedIn(directory) {
   for (const entry of readdirSync6(directory)) {
     const report = ERROR_REPORT_PATTERN.exec(entry);
     if (report) {
-      sweepErrorReport(join12(directory, entry), Number.parseInt(report[1] ?? "", 10));
+      sweepErrorReport(join13(directory, entry), Number.parseInt(report[1] ?? "", 10));
       continue;
     }
     const match = ANNOUNCEMENT_PATTERN.exec(entry);
     if (!match) {
       continue;
     }
-    const file = join12(directory, entry);
+    const file = join13(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
     const alive = processAlive(pid);
     entries.push({ file, pid, alive });
@@ -31744,16 +31751,16 @@ function announcedIn(directory) {
     found.push(announced);
   }
   const held = new Set(entries.map((one) => one.file));
-  const here = join12(directory, ".");
+  const here = join13(directory, ".");
   for (const file of verdicts.keys()) {
-    if (dirname7(file) === here && !held.has(file)) {
+    if (dirname8(file) === here && !held.has(file)) {
       verdicts.delete(file);
     }
   }
   return found;
 }
 async function announcementEnded(pid, directories = runtimeDirectories()) {
-  const files = directories.map((directory) => join12(directory, `runtime-${pid}.json`)).filter((file) => existsSync10(file));
+  const files = directories.map((directory) => join13(directory, `runtime-${pid}.json`)).filter((file) => existsSync10(file));
   const first = files[0];
   if (first === undefined) {
     return;
@@ -32002,14 +32009,14 @@ var init_runtime_client = __esm(() => {
 });
 
 // src/boot-note.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname8, join as join13 } from "node:path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname9, join as join14 } from "node:path";
 function bootNotePath(projectPath) {
-  return join13(projectPath, ".godot", "gdharness-boot.json");
+  return join14(projectPath, ".godot", "gdharness-boot.json");
 }
 function readBootNote(projectPath) {
   try {
-    const noted = readNumber(asParams(JSON.parse(readFileSync11(bootNotePath(projectPath), "utf8"))), "announcedAfterMs");
+    const noted = readNumber(asParams(JSON.parse(readFileSync12(bootNotePath(projectPath), "utf8"))), "announcedAfterMs");
     return noted !== undefined && Number.isFinite(noted) && noted > 0 ? noted : null;
   } catch {
     return null;
@@ -32018,8 +32025,8 @@ function readBootNote(projectPath) {
 function writeBootNote(projectPath, announcedAfterMs) {
   try {
     const path = bootNotePath(projectPath);
-    mkdirSync6(dirname8(path), { recursive: true });
-    writeFileSync8(path, JSON.stringify({ announcedAfterMs: Math.round(announcedAfterMs), at: new Date().toISOString() }, null, 2), "utf8");
+    mkdirSync7(dirname9(path), { recursive: true });
+    writeFileSync9(path, JSON.stringify({ announcedAfterMs: Math.round(announcedAfterMs), at: new Date().toISOString() }, null, 2), "utf8");
   } catch {}
 }
 function halfAsLongAgain(lastBootMs) {
@@ -32037,10 +32044,10 @@ var init_boot_note = __esm(() => {
 });
 
 // src/breakpoint-note.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync12, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname9, isAbsolute as isAbsolute2, join as join14, relative as relative2 } from "node:path";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync13, rmSync as rmSync7, writeFileSync as writeFileSync10 } from "node:fs";
+import { dirname as dirname10, isAbsolute as isAbsolute2, join as join15, relative as relative2 } from "node:path";
 function breakpointNotePath(projectPath) {
-  return join14(projectPath, ".godot", "gdharness-breakpoints.json");
+  return join15(projectPath, ".godot", "gdharness-breakpoints.json");
 }
 function writeBreakpointNote(projectPath, held) {
   const path = breakpointNotePath(projectPath);
@@ -32048,7 +32055,7 @@ function writeBreakpointNote(projectPath, held) {
   const inside = held.map((one) => ({ scriptPath: realPathOr(one.scriptPath), lines: one.lines })).filter((one) => one.lines.length > 0 && withinProject(root, one.scriptPath));
   try {
     if (inside.length === 0) {
-      rmSync6(path, { force: true });
+      rmSync7(path, { force: true });
       return;
     }
     const note = {
@@ -32057,8 +32064,8 @@ function writeBreakpointNote(projectPath, held) {
         lines: [...one.lines]
       }))
     };
-    mkdirSync7(dirname9(path), { recursive: true });
-    writeFileSync9(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync8(dirname10(path), { recursive: true });
+    writeFileSync10(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the breakpoints at ${path}: ${errorMessage(error)}`);
@@ -32066,7 +32073,7 @@ function writeBreakpointNote(projectPath, held) {
 }
 function readBreakpointNote(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync12(breakpointNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync13(breakpointNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.breakpoints)) {
       return [];
     }
@@ -32081,7 +32088,7 @@ function readBreakpointNote(projectPath) {
       }
       const lines = Array.isArray(listed) ? listed.filter((line) => Number.isInteger(line) && line > 0) : [];
       if (lines.length > 0) {
-        held.push({ scriptPath: realPathOr(join14(projectPath, script)), lines });
+        held.push({ scriptPath: realPathOr(join15(projectPath, script)), lines });
       }
     }
     return held;
@@ -32099,14 +32106,14 @@ var init_breakpoint_note = __esm(() => {
 });
 
 // src/bridge-announce.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync13, rmSync as rmSync7, writeFileSync as writeFileSync10 } from "node:fs";
-import { dirname as dirname10, join as join15 } from "node:path";
-function announcementPath(projectPath) {
-  return join15(projectPath, ".godot", "gdharness-bridge.json");
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync14, rmSync as rmSync8, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname11, join as join16 } from "node:path";
+function announcementPath2(projectPath) {
+  return join16(projectPath, ".godot", "gdharness-bridge.json");
 }
-function readAnnouncement(path) {
+function readAnnouncement2(path) {
   try {
-    const parsed = JSON.parse(readFileSync13(path, "utf8"));
+    const parsed = JSON.parse(readFileSync14(path, "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -32120,12 +32127,12 @@ function readAnnouncement(path) {
   }
 }
 function announcementIsOurs(path) {
-  return readAnnouncement(path)?.pid === process.pid;
+  return readAnnouncement2(path)?.pid === process.pid;
 }
 function announceBridge(projectPath, bridge) {
-  const path = announcementPath(projectPath);
+  const path = announcementPath2(projectPath);
   try {
-    mkdirSync8(dirname10(path), { recursive: true });
+    mkdirSync9(dirname11(path), { recursive: true });
     const announcement = {
       protocol: BRIDGE_ANNOUNCE_PROTOCOL,
       host: bridge.host,
@@ -32134,7 +32141,7 @@ function announceBridge(projectPath, bridge) {
       version: bridge.version,
       startedAt: new Date().toISOString()
     };
-    writeFileSync10(path, `${JSON.stringify(announcement, null, 2)}
+    writeFileSync11(path, `${JSON.stringify(announcement, null, 2)}
 `, "utf8");
     return path;
   } catch (error) {
@@ -32147,7 +32154,7 @@ function withdrawBridge(path) {
     return;
   }
   try {
-    rmSync7(path, { force: true });
+    rmSync8(path, { force: true });
   } catch (error) {
     console.error(`[SERVER] Could not withdraw the editor bridge announcement: ${errorMessage(error)}`);
   }
@@ -32155,17 +32162,18 @@ function withdrawBridge(path) {
 var BRIDGE_ANNOUNCE_PROTOCOL = 1;
 var init_bridge_announce = __esm(() => {
   init_errors();
+  init_process_children();
 });
 
 // src/class-note.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname11, join as join16 } from "node:path";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync15, writeFileSync as writeFileSync12 } from "node:fs";
+import { dirname as dirname12, join as join17 } from "node:path";
 function classNotePath(projectPath) {
-  return join16(projectPath, ".godot", "gdharness-classes.json");
+  return join17(projectPath, ".godot", "gdharness-classes.json");
 }
 function readClassNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync14(classNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync15(classNotePath(projectPath), "utf8")));
     const rebuiltWith = readArray(fields, "rebuiltWith");
     if (rebuiltWith === undefined || !rebuiltWith.every((name) => typeof name === "string")) {
       return null;
@@ -32182,24 +32190,24 @@ function readClassNote(projectPath) {
 function writeClassNote(projectPath, note) {
   try {
     const path = classNotePath(projectPath);
-    mkdirSync9(dirname11(path), { recursive: true });
-    writeFileSync11(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync10(dirname12(path), { recursive: true });
+    writeFileSync12(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch {}
 }
 var init_class_note = () => {};
 
 // src/config-pin.ts
-import { existsSync as existsSync11, readFileSync as readFileSync15 } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync16 } from "node:fs";
+import { join as join18 } from "node:path";
 function versionsNamedInConfig(projectPath) {
-  const config = join17(projectPath, ".mcp.json");
+  const config = join18(projectPath, ".mcp.json");
   if (!existsSync11(config)) {
     return [];
   }
   let text;
   try {
-    text = readFileSync15(config, "utf8");
+    text = readFileSync16(config, "utf8");
     JSON.parse(text);
   } catch {
     return [];
@@ -32307,7 +32315,7 @@ function portFromEnvOrNull(variable) {
   }
   const parsed = Number.parseInt(raw, 10);
   if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535 || String(parsed) !== raw) {
-    throw new Refusal2(`${variable} is "${raw}", not a port between 1 and 65535.`);
+    throw new Refusal(`${variable} is "${raw}", not a port between 1 and 65535.`);
   }
   return parsed;
 }
@@ -32321,7 +32329,7 @@ async function freePort(preferred, host = "127.0.0.1") {
   }
   const spare = await bindable(0, host);
   if (spare === null) {
-    throw new Refusal2(`No port could be bound on ${host}.`);
+    throw new Refusal(`No port could be bound on ${host}.`);
   }
   return spare;
 }
@@ -32471,7 +32479,7 @@ class GodotDAPClient {
   async sendRequest(command, args, timeoutMs = DAP_REQUEST_TIMEOUT_MS) {
     await this.ensureConnected();
     if (!this.socket) {
-      throw new Refusal2("DAP socket is not available");
+      throw new Refusal("DAP socket is not available");
     }
     const requestSeq = this.seq++;
     const request = {
@@ -32881,7 +32889,7 @@ async function handleDAPTool(client, toolName, args) {
       }
       case "dap_set_breakpoint": {
         if (typeof safeArgs.scriptPath !== "string" || typeof safeArgs.line !== "number") {
-          throw new Refusal2("dap_set_breakpoint requires { scriptPath: string, line: number }");
+          throw new Refusal("dap_set_breakpoint requires { scriptPath: string, line: number }");
         }
         const result = await client.setBreakpoint(safeArgs.scriptPath, safeArgs.line);
         return {
@@ -32890,7 +32898,7 @@ async function handleDAPTool(client, toolName, args) {
       }
       case "dap_remove_breakpoint": {
         if (typeof safeArgs.scriptPath !== "string" || typeof safeArgs.line !== "number") {
-          throw new Refusal2("dap_remove_breakpoint requires { scriptPath: string, line: number }");
+          throw new Refusal("dap_remove_breakpoint requires { scriptPath: string, line: number }");
         }
         const result = await client.removeBreakpoint(safeArgs.scriptPath, safeArgs.line);
         return {
@@ -32953,24 +32961,24 @@ var init_dap_client = __esm(() => {
 import {
   closeSync,
   existsSync as existsSync12,
-  mkdirSync as mkdirSync10,
+  mkdirSync as mkdirSync11,
   openSync,
-  readFileSync as readFileSync16,
+  readFileSync as readFileSync17,
   readSync,
-  rmSync as rmSync8,
+  rmSync as rmSync9,
   statSync as statSync6,
-  writeFileSync as writeFileSync12
+  writeFileSync as writeFileSync13
 } from "node:fs";
-import { dirname as dirname12, join as join18 } from "node:path";
+import { dirname as dirname13, join as join19 } from "node:path";
 function editorLogPath(projectPath) {
-  return join18(projectPath, ".godot", "gdharness-editor.log");
+  return join19(projectPath, ".godot", "gdharness-editor.log");
 }
 function editorLogNotePath(projectPath) {
-  return join18(projectPath, ".godot", "gdharness-editor.json");
+  return join19(projectPath, ".godot", "gdharness-editor.json");
 }
 function readEditorLogNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync16(editorLogNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync17(editorLogNotePath(projectPath), "utf8")));
     const pid = readNumber(fields, "pid");
     const startedAt = readString(fields, "startedAt");
     return pid !== undefined && Number.isInteger(pid) && pid > 0 && startedAt !== undefined ? { pid, startedAt } : null;
@@ -32981,16 +32989,16 @@ function readEditorLogNote(projectPath) {
 function clearEditorLog(projectPath) {
   try {
     const path = editorLogPath(projectPath);
-    mkdirSync10(dirname12(path), { recursive: true });
-    rmSync8(path, { force: true });
-    rmSync8(editorLogNotePath(projectPath), { force: true });
+    mkdirSync11(dirname13(path), { recursive: true });
+    rmSync9(path, { force: true });
+    rmSync9(editorLogNotePath(projectPath), { force: true });
   } catch {}
 }
 function writeEditorLogNote(projectPath, pid) {
   try {
     const path = editorLogNotePath(projectPath);
-    mkdirSync10(dirname12(path), { recursive: true });
-    writeFileSync12(path, JSON.stringify({ pid, startedAt: new Date().toISOString() }, null, 2), "utf8");
+    mkdirSync11(dirname13(path), { recursive: true });
+    writeFileSync13(path, JSON.stringify({ pid, startedAt: new Date().toISOString() }, null, 2), "utf8");
   } catch {}
 }
 function theConsoleWasNotCaptured(why, projectPath) {
@@ -33023,7 +33031,7 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
 function theFirstOf(path) {
   const whole = statSync6(path).size;
   if (whole <= MOST_CONSOLE_BYTES) {
-    return { text: readFileSync16(path, "utf8") };
+    return { text: readFileSync17(path, "utf8") };
   }
   const handle = openSync(path, "r");
   try {
@@ -36441,7 +36449,7 @@ var init_godot_bridge = __esm(() => {
     }
     sendMessage(message) {
       if (this.socket?.readyState !== import_websocket.default.OPEN) {
-        throw new Refusal2("Godot is not connected");
+        throw new Refusal("Godot is not connected");
       }
       this.socket.send(JSON.stringify(message));
     }
@@ -36991,7 +36999,7 @@ var init_junit = __esm(() => {
 import { realpathSync as realpathSync2 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname13, resolve as resolve4 } from "node:path";
+import { dirname as dirname14, resolve as resolve4 } from "node:path";
 import { fileURLToPath as fileURLToPath4, pathToFileURL } from "node:url";
 function diagnosticsKey(uri) {
   let decoded;
@@ -37119,13 +37127,13 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname13(resolve4(filePath));
+    const rootPath = this.rootPath ?? dirname14(resolve4(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params) {
     await this.ensureConnected();
     if (!this.socket) {
-      throw new Refusal2("Not connected to Godot LSP");
+      throw new Refusal("Not connected to Godot LSP");
     }
     this.requestId += 1;
     const id = this.requestId;
@@ -37164,7 +37172,7 @@ class GodotLSPClient {
   }
   sendNotification(method, params) {
     if (!this.connected || !this.socket) {
-      throw new Refusal2("Not connected to Godot LSP");
+      throw new Refusal("Not connected to Godot LSP");
     }
     const payload = {
       jsonrpc: "2.0",
@@ -37446,36 +37454,36 @@ async function resolveLSPPaths(projectPathValue, scriptPathValue) {
   try {
     projectPath = await realpath(requestedProjectPath);
   } catch {
-    throw new Refusal2(`Project path does not exist: ${requestedProjectPath}`);
+    throw new Refusal(`Project path does not exist: ${requestedProjectPath}`);
   }
   const contained = resolveWithinProject(projectPath, scriptPathValue);
   if (!contained.ok) {
-    throw new Refusal2(contained.reason);
+    throw new Refusal(contained.reason);
   }
   let scriptPath;
   try {
     scriptPath = await realpath(contained.absolutePath);
   } catch {
-    throw new Refusal2(`Script file does not exist: ${contained.absolutePath}`);
+    throw new Refusal(`Script file does not exist: ${contained.absolutePath}`);
   }
   if (!isWithinRoot(projectPath, scriptPath)) {
-    throw new Refusal2("scriptPath resolves outside the project root boundary.");
+    throw new Refusal("scriptPath resolves outside the project root boundary.");
   }
   return { projectPath, scriptPath };
 }
 async function handleLSPTool(client, toolName, args) {
   try {
     if (!args || typeof args !== "object") {
-      throw new Refusal2("Tool arguments must be an object.");
+      throw new Refusal("Tool arguments must be an object.");
     }
     const parsedArgs = args;
     const projectPathValue = parsedArgs["projectPath"];
     const scriptPathValue = parsedArgs["scriptPath"];
     if (typeof projectPathValue !== "string" || projectPathValue.length === 0) {
-      throw new Refusal2("Missing required argument: projectPath");
+      throw new Refusal("Missing required argument: projectPath");
     }
     if (typeof scriptPathValue !== "string" || scriptPathValue.length === 0) {
-      throw new Refusal2("Missing required argument: scriptPath");
+      throw new Refusal("Missing required argument: scriptPath");
     }
     const { projectPath, scriptPath } = await resolveLSPPaths(projectPathValue, scriptPathValue);
     const content = await readFile(scriptPath, "utf8");
@@ -37489,7 +37497,7 @@ async function handleLSPTool(client, toolName, args) {
         const line = Number(parsedArgs["line"]);
         const character = Number(parsedArgs["character"]);
         if (!Number.isFinite(line) || !Number.isFinite(character)) {
-          throw new Refusal2("Arguments line and character must be numbers.");
+          throw new Refusal("Arguments line and character must be numbers.");
         }
         const completions = await client.getCompletions(scriptPath, content, line, character);
         return asToolResponse({ completions });
@@ -37498,7 +37506,7 @@ async function handleLSPTool(client, toolName, args) {
         const line = Number(parsedArgs["line"]);
         const character = Number(parsedArgs["character"]);
         if (!Number.isFinite(line) || !Number.isFinite(character)) {
-          throw new Refusal2("Arguments line and character must be numbers.");
+          throw new Refusal("Arguments line and character must be numbers.");
         }
         const hover = await client.getHover(scriptPath, content, line, character);
         return asToolResponse({ hover });
@@ -37564,13 +37572,13 @@ var init_process_time = __esm(() => {
 });
 
 // src/project-scan.ts
-import { existsSync as existsSync14, readdirSync as readdirSync7, readFileSync as readFileSync17 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync14, readdirSync as readdirSync7, readFileSync as readFileSync18 } from "node:fs";
+import { join as join20 } from "node:path";
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
 function steppedOver(directory) {
-  return existsSync14(join19(directory, ".gdignore"));
+  return existsSync14(join20(directory, ".gdignore"));
 }
 function projectStructure(projectPath) {
   const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
@@ -37583,7 +37591,7 @@ function projectStructure(projectPath) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join19(directory, entry.name));
+        visit(join20(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (extension === "tscn") {
@@ -37613,14 +37621,14 @@ function scriptsWithoutUid(projectPath) {
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join19(directory, entry.name), spelled);
+        visit(join20(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync14(join19(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync14(join20(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -37655,7 +37663,7 @@ function searchProject(projectPath, options) {
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join19(directory, entry.name);
+      const entryPath = join20(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -37666,7 +37674,7 @@ function searchProject(projectPath, options) {
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync17(entryPath, "utf8").split(`
+      for (const [index, line] of readFileSync18(entryPath, "utf8").split(`
 `).entries()) {
         if (full()) {
           break;
@@ -37695,16 +37703,16 @@ var init_project_scan = __esm(() => {
 });
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync11, readFileSync as readFileSync18, rmSync as rmSync9, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname14, join as join20 } from "node:path";
+import { mkdirSync as mkdirSync12, readFileSync as readFileSync19, rmSync as rmSync10, writeFileSync as writeFileSync14 } from "node:fs";
+import { dirname as dirname15, join as join21 } from "node:path";
 function restartNotePath(projectPath) {
-  return join20(projectPath, ".godot", "gdharness-restart.json");
+  return join21(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync11(dirname14(path), { recursive: true });
-    writeFileSync13(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync12(dirname15(path), { recursive: true });
+    writeFileSync14(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
@@ -37712,7 +37720,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync18(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync19(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -37727,7 +37735,7 @@ function restartOwed(projectPath) {
 }
 function restartSettled(projectPath) {
   try {
-    rmSync9(restartNotePath(projectPath), { force: true });
+    rmSync10(restartNotePath(projectPath), { force: true });
   } catch (error) {
     console.error(`[SERVER] Could not clear the restart note: ${errorMessage(error)}`);
   }
@@ -37738,36 +37746,36 @@ var init_restart_note = __esm(() => {
 
 // src/run-record.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { mkdirSync as mkdirSync12, openSync as openSync2, readdirSync as readdirSync8, readFileSync as readFileSync19, rmSync as rmSync10, statSync as statSync7, writeFileSync as writeFileSync14 } from "node:fs";
-import { basename as basename3, join as join21 } from "node:path";
+import { mkdirSync as mkdirSync13, openSync as openSync2, readdirSync as readdirSync8, readFileSync as readFileSync20, rmSync as rmSync11, statSync as statSync7, writeFileSync as writeFileSync15 } from "node:fs";
+import { basename as basename3, join as join22 } from "node:path";
 function runsDirectory() {
-  return join21(runtimeDirectory(), "runs");
+  return join22(runtimeDirectory(), "runs");
 }
 function recordPath() {
-  return join21(runsDirectory(), "run.json");
+  return join22(runsDirectory(), "run.json");
 }
 function recordPaths() {
-  return runtimeDirectories().map((directory) => join21(directory, "runs", "run.json"));
+  return runtimeDirectories().map((directory) => join22(directory, "runs", "run.json"));
 }
 function openTranscript(startedAt) {
-  mkdirSync12(runsDirectory(), { recursive: true });
-  const path = join21(runsDirectory(), `run-${startedAt}.log`);
+  mkdirSync13(runsDirectory(), { recursive: true });
+  const path = join22(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync2(path, "a") };
 }
 function writeRunRecord(record) {
-  mkdirSync12(runsDirectory(), { recursive: true });
-  writeFileSync14(recordPath(), JSON.stringify(record, null, 2), "utf8");
+  mkdirSync13(runsDirectory(), { recursive: true });
+  writeFileSync15(recordPath(), JSON.stringify(record, null, 2), "utf8");
 }
 function editorNotePath() {
-  return join21(runsDirectory(), "editor-run.json");
+  return join22(runsDirectory(), "editor-run.json");
 }
 function writeEditorRunNote(note) {
-  mkdirSync12(runsDirectory(), { recursive: true });
-  writeFileSync14(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
+  mkdirSync13(runsDirectory(), { recursive: true });
+  writeFileSync15(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
 }
 function readEditorRunNote() {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(join21(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(join22(directory, "runs", "editor-run.json"));
     if (note !== null) {
       return note;
     }
@@ -37777,7 +37785,7 @@ function readEditorRunNote() {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync19(path, "utf8"));
+    parsed = JSON.parse(readFileSync20(path, "utf8"));
   } catch {
     return null;
   }
@@ -37800,7 +37808,7 @@ function recordRunEnded(pid, exitCode) {
     return;
   }
   try {
-    writeFileSync14(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
+    writeFileSync15(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
   } catch {}
 }
 function readRunRecord() {
@@ -37815,7 +37823,7 @@ function readRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync19(path, "utf8"));
+    parsed = JSON.parse(readFileSync20(path, "utf8"));
   } catch {
     return null;
   }
@@ -37860,7 +37868,7 @@ function runningAs(pid) {
     const began = startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync19(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync20(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = execFileSync2("ps", ["-p", String(pid), "-o", "args="], {
@@ -37987,7 +37995,7 @@ function clearRunRecord(ours = () => true) {
       continue;
     }
     try {
-      rmSync10(path);
+      rmSync11(path);
     } catch {}
   }
 }
@@ -38011,12 +38019,12 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join21(directory, entry);
+    const path = join22(directory, entry);
     if (path === keep || ageMs(path, now) < keepMs) {
       continue;
     }
     try {
-      rmSync10(path);
+      rmSync11(path);
     } catch {}
   }
 }
@@ -38037,17 +38045,17 @@ import {
   copyFileSync,
   existsSync as existsSync15,
   fstatSync,
-  mkdirSync as mkdirSync13,
+  mkdirSync as mkdirSync14,
   mkdtempSync as mkdtempSync3,
   openSync as openSync3,
   readdirSync as readdirSync9,
-  readFileSync as readFileSync20,
+  readFileSync as readFileSync21,
   readSync as readSync2,
   rmdirSync,
   statSync as statSync8
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename4, dirname as dirname15, extname as extname2, isAbsolute as isAbsolute3, join as join22, normalize as normalize3, relative as relative3 } from "node:path";
+import { basename as basename4, dirname as dirname16, extname as extname2, isAbsolute as isAbsolute3, join as join23, normalize as normalize3, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { promisify as promisify7 } from "node:util";
@@ -38061,11 +38069,11 @@ function captureDestinationRefusal(outputPath, projects) {
   if (extname2(outputPath).toLowerCase() !== ".png") {
     return `outputPath ${outputPath} does not end in .png, which is what a capture is.`;
   }
-  const directory = realPathOr(dirname15(outputPath));
+  const directory = realPathOr(dirname16(outputPath));
   if (!existsSync15(directory)) {
-    return `outputPath's directory ${dirname15(outputPath)} does not exist; a capture creates no directories.`;
+    return `outputPath's directory ${dirname16(outputPath)} does not exist; a capture creates no directories.`;
   }
-  const where = join22(directory, basename4(outputPath));
+  const where = join23(directory, basename4(outputPath));
   const inside = projects.find((project) => project !== "" && isWithinRoot(realPathOr(project), where));
   if (inside !== undefined) {
     return `outputPath ${outputPath} is inside the project at ${inside}; a capture is saved outside it, so it never becomes part of the game.`;
@@ -38313,7 +38321,7 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync15(join22(projectPath, wanted))) {
+  if (wanted === "" || existsSync15(join23(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -38327,7 +38335,7 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync20(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync21(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function runtimeAddonAnnouncesEditors(projectPath) {
@@ -38335,13 +38343,13 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync20(join22(projectPath, RUNTIME_AUTOLOAD2.path), "utf8").includes('"editor_pid"');
+    return readFileSync21(join23(projectPath, RUNTIME_AUTOLOAD2.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync20(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync21(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -38360,7 +38368,7 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   mcp;
   locator = new GodotLocator2;
-  operationsScript = join22(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join23(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -38504,7 +38512,7 @@ class GodotServer {
     if (this.ownProject === null) {
       return null;
     }
-    const announced = readAnnouncement(announcementPath(this.ownProject));
+    const announced = readAnnouncement2(announcementPath2(this.ownProject));
     if (announced === null || announced.pid === process.pid) {
       return null;
     }
@@ -38591,7 +38599,7 @@ class GodotServer {
   }
   setupToolHandlers() {
     this.mcp.server.setRequestHandler(ListToolsRequestSchema, () => ({ tools: this.tools }));
-    this.mcp.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    this.mcp.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
       this.logDebug(`Handling tool request: ${request.params.name}`);
       const spec = toolSpec(request.params.name);
       if (!spec) {
@@ -38606,7 +38614,7 @@ class GodotServer {
         this.lastProjectPath = args["projectPath"];
       }
       this.updates.refresh();
-      const answer = await this.answered(spec.name, checked.op ?? "", args);
+      const answer = await withCallSignal(extra.signal, () => this.answered(spec.name, checked.op ?? "", args));
       return this.withFeedbackNotice(this.withUpdateNotice(answer));
     });
   }
@@ -38614,7 +38622,7 @@ class GodotServer {
     try {
       return await this.dispatch(tool, op, args);
     } catch (error) {
-      if (error instanceof McpError || error instanceof Refusal2) {
+      if (error instanceof McpError || error instanceof Refusal) {
         throw error;
       }
       const where = op === "" ? tool : `${tool} op=${op}`;
@@ -39025,7 +39033,7 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join22(path, "project.godot");
+    const file = join23(path, "project.godot");
     if (!existsSync15(file)) {
       return {
         ok: false,
@@ -39294,7 +39302,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync20(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync21(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -39355,18 +39363,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname15(output.absolutePath);
+    const folder = dirname16(output.absolutePath);
     try {
-      mkdirSync13(folder, { recursive: true });
+      mkdirSync14(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname15(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname16(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
-    const exportLogs = mkdtempSync3(join22(tmpdir5(), "gdharness-export-"));
+    const exportLogs = mkdtempSync3(join23(tmpdir5(), "gdharness-export-"));
     const exportArgs = [
       "--headless",
       "--log-file",
-      join22(exportLogs, "engine.log"),
+      join23(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -39377,7 +39385,10 @@ class GodotServer {
     const log = new GameLog;
     let exitCode = 0;
     try {
-      const { stdout, stderr } = await run7(engine.value, exportArgs, { timeout: 300000 });
+      const { stdout, stderr } = await run7(engine.value, exportArgs, {
+        timeout: 300000,
+        signal: callSignal()
+      });
       log.append("stdout", stdout);
       log.append("stderr", stderr);
     } catch (error) {
@@ -39424,7 +39435,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync15(join22(project.value.path, runner))) {
+    if (!existsSync15(join23(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"
       ]);
@@ -39459,7 +39470,7 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync3(join22(tmpdir5(), "gdharness-tests-"));
+    const userData = mkdtempSync3(join23(tmpdir5(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const hung = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -39475,21 +39486,21 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join22(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join23(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
       const written = existsSync15(reportsDir) ? readdirSync9(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(readFileSync20(join22(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync21(join23(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
     } finally {
       discard(reportsDir, userData);
       try {
-        rmdirSync(dirname15(reportsDir));
+        rmdirSync(dirname16(reportsDir));
       } catch {}
     }
     const engineEntries = run.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries.map(aboveTheRunner);
@@ -39625,7 +39636,7 @@ class GodotServer {
         return null;
       }
       try {
-        return readFileSync20(contained.absolutePath, "utf8");
+        return readFileSync21(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -39679,7 +39690,7 @@ class GodotServer {
       return null;
     }
     try {
-      return readFileSync20(contained.absolutePath, "utf8");
+      return readFileSync21(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -39908,7 +39919,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync20(join22(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync21(join23(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -40159,7 +40170,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync15(join22(projectPath, RUNTIME_AUTOLOAD2.path))) {
+    if (!existsSync15(join23(projectPath, RUNTIME_AUTOLOAD2.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
     }
     let asking = null;
@@ -40393,6 +40404,23 @@ class GodotServer {
   }
   spawnGame(godotPath, cmdArgs, env) {
     const child = spawn(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
+    const cancelled = callSignal();
+    if (cancelled !== undefined) {
+      const end = () => {
+        if (child.exitCode === null && child.signalCode === null) {
+          this.logDebug(`The call waiting on pid ${child.pid ?? "unknown"} was cancelled; ending it.`);
+          child.kill();
+        }
+      };
+      if (cancelled.aborted) {
+        end();
+      } else {
+        cancelled.addEventListener("abort", end, { once: true });
+        child.once("exit", () => {
+          cancelled.removeEventListener("abort", end);
+        });
+      }
+    }
     const log = new GameLog;
     const started = {
       process: child,
@@ -41325,7 +41353,7 @@ class GodotServer {
   async ownRunOnItsWay(projectPath, budgetMs) {
     const run = this.currentRun();
     const project = projectPath ?? run?.projectPath ?? null;
-    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync15(join22(project, RUNTIME_AUTOLOAD2.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync15(join23(project, RUNTIME_AUTOLOAD2.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -41404,8 +41432,8 @@ class GodotServer {
         return this.createErrorResponse(refusal);
       }
     }
-    const screenshotDir = expectsScreenshot ? mkdtempSync3(join22(tmpdir5(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join22(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? mkdtempSync3(join23(tmpdir5(), "gdharness-runtime-screenshot-")) : null;
+    const screenshotPath = screenshotDir ? join23(screenshotDir, "capture.png") : null;
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs);
       if (!reply.ok) {
@@ -41436,7 +41464,7 @@ class GodotServer {
             type: "text",
             text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}${saveTo === null ? "" : `. Saved to ${saveTo}`}`
           },
-          { type: "image", data: readFileSync20(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync21(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
@@ -41515,6 +41543,7 @@ var init_server3 = __esm(() => {
   init_boot_note();
   init_breakpoint_note();
   init_bridge_announce();
+  init_call_signal();
   init_class_cache();
   init_class_note();
   init_config_pin();
@@ -41544,7 +41573,7 @@ var init_server3 = __esm(() => {
   init_tool_definitions();
   init_update_check();
   run7 = promisify7(execFile7);
-  __dirname2 = dirname15(fileURLToPath5(import.meta.url));
+  __dirname2 = dirname16(fileURLToPath5(import.meta.url));
   CONSOLE_WRAPPER = /_console(\.exe)?$/i;
   LONGEST_BOOT_NOTED_MS = 5 * 60000;
   VALUE_NAMES = {
@@ -41585,20 +41614,61 @@ var init_server3 = __esm(() => {
 
 // src/cli.ts
 import { existsSync as existsSync16 } from "fs";
-import { join as join23, resolve as resolve5 } from "path";
+import { join as join24, resolve as resolve5 } from "path";
+
+// src/bridge-announce.ts
+init_errors();
+init_process_children();
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+function announcementPath(projectPath) {
+  return join(projectPath, ".godot", "gdharness-bridge.json");
+}
+function readAnnouncement(path) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    const said = parsed;
+    if (typeof said.port !== "number" || typeof said.pid !== "number") {
+      return null;
+    }
+    return said;
+  } catch {
+    return null;
+  }
+}
+function serverBehind(announcement, startedAt) {
+  if (announcement === null || typeof announcement.version !== "string" || startedAt === undefined) {
+    return null;
+  }
+  const announcedAt = Date.parse(announcement.startedAt);
+  if (Number.isNaN(announcedAt) || startedAt > announcedAt + 1000) {
+    return null;
+  }
+  return { version: announcement.version, pid: announcement.pid };
+}
+function serverServing(projectPath) {
+  const announcement = readAnnouncement(announcementPath(projectPath));
+  if (announcement === null) {
+    return null;
+  }
+  return serverBehind(announcement, startTimesOf([announcement.pid]).get(announcement.pid));
+}
 
 // src/errors.ts
-class Refusal extends Error {
+class Refusal2 extends Error {
 }
 
 // src/godot-path.ts
 init_detection();
 init_errors();
-import { execFile } from "node:child_process";
+import { execFile as execFile2 } from "node:child_process";
 import { existsSync as existsSync2 } from "node:fs";
 import { normalize } from "node:path";
-import { promisify } from "node:util";
-var run = promisify(execFile);
+import { promisify as promisify2 } from "node:util";
+var run2 = promisify2(execFile2);
 
 class GodotLocator {
   answered = new Map;
@@ -41655,7 +41725,7 @@ class GodotLocator {
       reason = "does not exist";
     } else {
       try {
-        await run(path, ["--version"]);
+        await run2(path, ["--version"]);
         reason = null;
       } catch (error) {
         reason = `does not answer --version: ${errorMessage(error)}`;
@@ -41667,9 +41737,9 @@ class GodotLocator {
 }
 
 // src/harnesses.ts
-import { existsSync as existsSync4, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { dirname as dirname3, join as join4 } from "node:path";
 import process3 from "node:process";
 
 // node_modules/yaml/dist/index.js
@@ -41842,7 +41912,7 @@ var HARNESSES = [
     shape: "plain",
     home: ".claude",
     marker: ".claude",
-    skills: { dir: join3(".claude", "skills"), shared: false }
+    skills: { dir: join4(".claude", "skills"), shared: false }
   },
   {
     id: "copilot-cli",
@@ -41852,7 +41922,7 @@ var HARNESSES = [
     container: "mcpServers",
     shape: "plain",
     home: ".copilot",
-    skills: { dir: join3(".github", "skills"), shared: true },
+    skills: { dir: join4(".github", "skills"), shared: true },
     manual: "Trust the folder when Copilot CLI first asks, or it reads no config here."
   },
   {
@@ -41878,22 +41948,22 @@ var HARNESSES = [
     id: "cursor",
     name: "Cursor",
     scope: "project",
-    file: join3(".cursor", "mcp.json"),
+    file: join4(".cursor", "mcp.json"),
     container: "mcpServers",
     shape: "plain",
     home: ".cursor",
-    skills: { dir: join3(".cursor", "skills"), shared: true },
+    skills: { dir: join4(".cursor", "skills"), shared: true },
     manual: "Cursor asks before each tool call by default, and the server can be toggled off."
   },
   {
     id: "vscode",
     name: "VS Code",
     scope: "project",
-    file: join3(".vscode", "mcp.json"),
+    file: join4(".vscode", "mcp.json"),
     container: "servers",
     shape: "typed",
     home: ".vscode",
-    skills: { dir: join3(".github", "skills"), shared: true },
+    skills: { dir: join4(".github", "skills"), shared: true },
     manual: "VS Code asks you to trust a server the first time it starts one."
   },
   {
@@ -41903,45 +41973,45 @@ var HARNESSES = [
     file: "opencode.json",
     container: "mcp",
     shape: "opencode",
-    home: join3(".config", "opencode"),
+    home: join4(".config", "opencode"),
     marker: ".opencode",
-    skills: { dir: join3(".opencode", "skills"), shared: true }
+    skills: { dir: join4(".opencode", "skills"), shared: true }
   },
   {
     id: "junie",
     name: "Junie",
     scope: "project",
-    file: join3(".junie", "mcp", "mcp.json"),
+    file: join4(".junie", "mcp", "mcp.json"),
     container: "mcpServers",
     shape: "plain",
     home: ".junie",
-    skills: { dir: join3(".junie", "skills"), shared: true }
+    skills: { dir: join4(".junie", "skills"), shared: true }
   },
   {
     id: "kiro",
     name: "Kiro",
     scope: "project",
-    file: join3(".kiro", "settings", "mcp.json"),
+    file: join4(".kiro", "settings", "mcp.json"),
     container: "mcpServers",
     shape: "plain",
     home: ".kiro",
-    skills: { dir: join3(".kiro", "skills"), shared: false }
+    skills: { dir: join4(".kiro", "skills"), shared: false }
   },
   {
     id: "gemini",
     name: "Gemini CLI",
     scope: "project",
-    file: join3(".gemini", "settings.json"),
+    file: join4(".gemini", "settings.json"),
     container: "mcpServers",
     shape: "plain",
     home: ".gemini",
-    skills: { dir: join3(".gemini", "skills"), shared: true }
+    skills: { dir: join4(".gemini", "skills"), shared: true }
   },
   {
     id: "roo",
     name: "Roo Code",
     scope: "project",
-    file: join3(".roo", "mcp.json"),
+    file: join4(".roo", "mcp.json"),
     container: "mcpServers",
     shape: "plain"
   },
@@ -41949,7 +42019,7 @@ var HARNESSES = [
     id: "kilo",
     name: "Kilo Code",
     scope: "project",
-    file: join3(".kilocode", "mcp.json"),
+    file: join4(".kilocode", "mcp.json"),
     container: "mcpServers",
     shape: "plain"
   },
@@ -41957,16 +42027,16 @@ var HARNESSES = [
     id: "amazon-q",
     name: "Amazon Q Developer CLI",
     scope: "project",
-    file: join3(".amazonq", "mcp.json"),
+    file: join4(".amazonq", "mcp.json"),
     container: "mcpServers",
     shape: "plain",
-    home: join3(".aws", "amazonq")
+    home: join4(".aws", "amazonq")
   },
   {
     id: "zed",
     name: "Zed",
     scope: "project",
-    file: join3(".zed", "settings.json"),
+    file: join4(".zed", "settings.json"),
     container: "context_servers",
     shape: "plain"
   },
@@ -41974,16 +42044,16 @@ var HARNESSES = [
     id: "amp",
     name: "Amp",
     scope: "project",
-    file: join3(".amp", "settings.json"),
+    file: join4(".amp", "settings.json"),
     container: "amp.mcpServers",
     shape: "plain",
-    home: join3(".config", "amp")
+    home: join4(".config", "amp")
   },
   {
     id: "warp",
     name: "Warp",
     scope: "project",
-    file: join3(".warp", ".mcp.json"),
+    file: join4(".warp", ".mcp.json"),
     container: "mcpServers",
     shape: "plain",
     home: ".warp",
@@ -41993,7 +42063,7 @@ var HARNESSES = [
     id: "trae",
     name: "Trae",
     scope: "project",
-    file: join3(".trae", "mcp.json"),
+    file: join4(".trae", "mcp.json"),
     container: "mcpServers",
     shape: "plain",
     home: ".trae"
@@ -42002,7 +42072,7 @@ var HARNESSES = [
     id: "factory",
     name: "Factory Droid",
     scope: "project",
-    file: join3(".factory", "mcp.json"),
+    file: join4(".factory", "mcp.json"),
     container: "mcpServers",
     shape: "typed",
     home: ".factory"
@@ -42011,7 +42081,7 @@ var HARNESSES = [
     id: "tabnine",
     name: "Tabnine",
     scope: "project",
-    file: join3(".tabnine", "mcp_servers.json"),
+    file: join4(".tabnine", "mcp_servers.json"),
     container: "mcpServers",
     shape: "plain",
     home: ".tabnine"
@@ -42028,7 +42098,7 @@ var HARNESSES = [
     id: "pi",
     name: "pi",
     scope: "project",
-    file: join3(".pi", "mcp.json"),
+    file: join4(".pi", "mcp.json"),
     container: "mcpServers",
     shape: "plain",
     home: ".pi"
@@ -42037,7 +42107,7 @@ var HARNESSES = [
     id: "mistral-vibe",
     name: "Mistral Vibe",
     scope: "project",
-    file: join3(".vibe", "config.toml"),
+    file: join4(".vibe", "config.toml"),
     container: "mcp_servers",
     shape: "plain",
     toml: {
@@ -42093,7 +42163,7 @@ var HARNESSES = [
     id: "codex",
     name: "Codex CLI",
     scope: "home",
-    file: join3(".codex", "config.toml"),
+    file: join4(".codex", "config.toml"),
     container: "mcp_servers",
     shape: "plain",
     manual: "Codex reads its config at startup, so restart it.",
@@ -42112,20 +42182,20 @@ var HARNESSES = [
     id: "cline",
     name: "Cline",
     scope: "home",
-    file: join3(".cline", "data", "settings", "cline_mcp_settings.json"),
+    file: join4(".cline", "data", "settings", "cline_mcp_settings.json"),
     container: "mcpServers",
     shape: "plain",
     marker: ".cline",
-    skills: { dir: join3(".cline", "skills"), shared: false }
+    skills: { dir: join4(".cline", "skills"), shared: false }
   },
   {
     id: "goose",
     name: "Goose",
     scope: "home",
     file: {
-      win32: { appData: join3("Block", "goose", "config", "config.yaml") },
-      darwin: join3(".config", "goose", "config.yaml"),
-      linux: join3(".config", "goose", "config.yaml")
+      win32: { appData: join4("Block", "goose", "config", "config.yaml") },
+      darwin: join4(".config", "goose", "config.yaml"),
+      linux: join4(".config", "goose", "config.yaml")
     },
     container: "extensions",
     shape: "plain",
@@ -42146,19 +42216,19 @@ var HARNESSES = [
     id: "windsurf",
     name: "Windsurf",
     scope: "home",
-    file: join3(".codeium", "windsurf", "mcp_config.json"),
+    file: join4(".codeium", "windsurf", "mcp_config.json"),
     container: "mcpServers",
     shape: "plain",
-    skills: { dir: join3(".windsurf", "skills"), shared: true }
+    skills: { dir: join4(".windsurf", "skills"), shared: true }
   },
   {
     id: "hermes",
     name: "Hermes",
     scope: "home",
-    file: join3(".hermes", "config.yaml"),
+    file: join4(".hermes", "config.yaml"),
     container: "mcp_servers",
     shape: "plain",
-    skills: { dir: join3(".hermes", "skills"), shared: true },
+    skills: { dir: join4(".hermes", "skills"), shared: true },
     yaml: {
       path: ["mcp_servers", SERVER_KEY],
       entry: (launch) => ({
@@ -42173,7 +42243,7 @@ var HARNESSES = [
     id: "openclaw",
     name: "OpenClaw",
     scope: "home",
-    file: join3(".openclaw", "openclaw.json"),
+    file: join4(".openclaw", "openclaw.json"),
     container: "mcpServers",
     shape: "plain"
   },
@@ -42182,9 +42252,9 @@ var HARNESSES = [
     name: "Claude Desktop",
     scope: "home",
     file: {
-      win32: { appData: join3("Claude", "claude_desktop_config.json") },
-      darwin: join3("Library", "Application Support", "Claude", "claude_desktop_config.json"),
-      linux: join3(".config", "Claude", "claude_desktop_config.json")
+      win32: { appData: join4("Claude", "claude_desktop_config.json") },
+      darwin: join4("Library", "Application Support", "Claude", "claude_desktop_config.json"),
+      linux: join4(".config", "Claude", "claude_desktop_config.json")
     },
     container: "mcpServers",
     shape: "plain"
@@ -42193,7 +42263,7 @@ var HARNESSES = [
     id: "zeroclaw",
     name: "ZeroClaw",
     scope: "home",
-    file: join3(".zeroclaw", "config.toml"),
+    file: join4(".zeroclaw", "config.toml"),
     container: "mcp.servers",
     shape: "plain",
     toml: {
@@ -42214,7 +42284,7 @@ var HARNESSES = [
     id: "deepcode",
     name: "Deep Code",
     scope: "home",
-    file: join3(".deepcode", "settings.json"),
+    file: join4(".deepcode", "settings.json"),
     container: "mcpServers",
     shape: "plain"
   },
@@ -42222,7 +42292,7 @@ var HARNESSES = [
     id: "nanobot",
     name: "nanobot",
     scope: "home",
-    file: join3(".nanobot", "config.json"),
+    file: join4(".nanobot", "config.json"),
     container: "mcpServers",
     shape: "plain",
     snippet: (launch) => jsonSnippet(launch, "mcpServers", "plain")
@@ -42231,17 +42301,17 @@ var HARNESSES = [
     id: "autohand",
     name: "Autohand",
     scope: "home",
-    file: join3(".autohand", "config.json"),
+    file: join4(".autohand", "config.json"),
     container: "mcpServers",
     shape: "plain",
     snippet: (launch) => jsonSnippet(launch, "mcpServers", "plain")
   }
 ];
 function appDataRoot() {
-  return process3.env["APPDATA"] ?? join3(homedir2(), "AppData", "Roaming");
+  return process3.env["APPDATA"] ?? join4(homedir2(), "AppData", "Roaming");
 }
 function homePath(path) {
-  return typeof path === "string" ? join3(homedir2(), path) : join3(appDataRoot(), path.appData);
+  return typeof path === "string" ? join4(homedir2(), path) : join4(appDataRoot(), path.appData);
 }
 function fileFor(harness, platform = process3.platform) {
   if (typeof harness.file === "string") {
@@ -42252,7 +42322,7 @@ function fileFor(harness, platform = process3.platform) {
 function configPath(harness, projectPath) {
   const file = fileFor(harness);
   if (harness.scope === "project") {
-    return join3(projectPath, file);
+    return join4(projectPath, file);
   }
   return homePath(file);
 }
@@ -42311,11 +42381,11 @@ function present(harness, projectPath) {
     return true;
   }
   const root = harness.scope === "project" ? projectPath : homedir2();
-  const own = dirname2(path);
+  const own = dirname3(path);
   if (own !== root && existsSync4(own)) {
     return true;
   }
-  return harness.marker !== undefined && existsSync4(join3(root, harness.marker));
+  return harness.marker !== undefined && existsSync4(join4(root, harness.marker));
 }
 function candidates(projectPath) {
   const found = [];
@@ -42328,7 +42398,7 @@ function candidates(projectPath) {
     }
     if (present(harness, projectPath)) {
       found.push({ harness, reason: "configured" });
-    } else if (harness.home !== undefined && existsSync4(join3(homedir2(), harness.home))) {
+    } else if (harness.home !== undefined && existsSync4(join4(homedir2(), harness.home))) {
       found.push({ harness, reason: "installed" });
     }
   }
@@ -42353,7 +42423,7 @@ function registered(harness, projectPath) {
   if (harness.snippet !== undefined || !existsSync4(path)) {
     return false;
   }
-  const text = readFileSync(path, "utf8");
+  const text = readFileSync2(path, "utf8");
   if (harness.toml !== undefined) {
     return text.includes(harness.toml.identity ?? harness.toml.header);
   }
@@ -42383,7 +42453,7 @@ function recordedEnginePath(projectPath) {
     }
     let parsed;
     try {
-      parsed = JSON.parse(readFileSync(path, "utf8"));
+      parsed = JSON.parse(readFileSync2(path, "utf8"));
     } catch {
       continue;
     }
@@ -42406,7 +42476,7 @@ function disconnect(harness, projectPath) {
   if (harness.snippet !== undefined) {
     return { harness, path, action: "manual" };
   }
-  const text = readFileSync(path, "utf8");
+  const text = readFileSync2(path, "utf8");
   if (harness.toml !== undefined) {
     return taken(harness, path, text, removeToml(text, harness.toml));
   }
@@ -42415,7 +42485,7 @@ function disconnect(harness, projectPath) {
   }
   let existing;
   try {
-    existing = JSON.parse(readFileSync(path, "utf8"));
+    existing = JSON.parse(readFileSync2(path, "utf8"));
   } catch {
     return { harness, path, action: "absent" };
   }
@@ -42435,25 +42505,32 @@ function disconnect(harness, projectPath) {
     root[harness.container] = servers;
   }
   if (Object.keys(root).length === 0) {
-    rmSync(path, { force: true });
+    rmSync2(path, { force: true });
     return { harness, path, action: "deleted" };
   }
-  writeFileSync(path, `${JSON.stringify(root, null, 2)}
+  writeFileSync2(path, `${JSON.stringify(root, null, 2)}
 `, "utf8");
   return { harness, path, action: "removed" };
 }
-function harnessNote(repinned, now) {
+function harnessNote(repinned, now, running = null) {
   const alsoByHand = repinned.byHand === 0 ? "" : `
      ${repinned.byHand === 1 ? "One harness above was" : `${repinned.byHand} harnesses above were`} handed a command to run instead; run it too.`;
+  const serving = running === null ? `     No gdharness server is announcing itself for this project, so which one your harness
+` + `     is running cannot be read from here.
+` : `     The server serving this project is gdharness ${running.server.version} (pid ${running.server.pid})${running.isThisVersion ? ", which is already this version." : "."}
+`;
+  if (running?.isThisVersion === true && repinned.byHand === 0 && (repinned.moved.length > 0 || repinned.written > 0)) {
+    return `  2. Nothing for the harness: the server serving this project is gdharness ${running.server.version}
+     (pid ${running.server.pid}), which is already this version.`;
+  }
   if (repinned.moved.length > 0) {
-    return `  2. Your harness is still running the server it spawned from ${repinned.moved.join(", ")}.
-` + `     Its config names ${now} now.
-` + `     Reconnect the MCP server, or restart the harness.${alsoByHand}`;
+    return `  2. Your harness config held ${repinned.moved.join(", ")} before this upgrade.
+` + `     It names ${now} now.
+` + serving + `     Reconnect the MCP server, or restart the harness.${alsoByHand}`;
   }
   if (repinned.written > 0) {
-    return `  2. Your harness config already named this version, but the server it is running is
-` + `     whichever one it spawned when the session started, which this cannot see from here.
-` + `     Reconnect the MCP server, or restart the harness.${alsoByHand}`;
+    return `  2. Your harness config already named this version.
+` + serving + `     Reconnect the MCP server, or restart the harness.${alsoByHand}`;
   }
   if (repinned.byHand > 0) {
     return `  2. None of the harness configs found here can be written for you, so nothing was
@@ -42480,7 +42557,7 @@ function connect(harness, projectPath, launch) {
   if (harness.snippet !== undefined) {
     return { harness, path, action: "snippet", snippet: harness.snippet(launch) };
   }
-  const held = existsSync4(path) ? readFileSync(path, "utf8") : "";
+  const held = existsSync4(path) ? readFileSync2(path, "utf8") : "";
   if (harness.toml !== undefined) {
     const already = held.includes(harness.toml.identity ?? harness.toml.header);
     return put(harness, path, writeToml(held, harness.toml, launch), already);
@@ -42494,7 +42571,7 @@ function connect(harness, projectPath, launch) {
     try {
       existing = JSON.parse(held);
     } catch (cause) {
-      throw new Refusal2(`${path} is not valid JSON, so gdharness was not added to it.`, { cause });
+      throw new Refusal(`${path} is not valid JSON, so gdharness was not added to it.`, { cause });
     }
   }
   const container = typeof existing === "object" && existing !== null && !Array.isArray(existing) ? existing[harness.container] : undefined;
@@ -42506,8 +42583,8 @@ function connect(harness, projectPath, launch) {
   return was === undefined || was === now ? written : { ...written, wasLaunchedBy: was };
 }
 function put(harness, path, contents, already) {
-  mkdirSync(dirname2(path), { recursive: true });
-  writeFileSync(path, contents, "utf8");
+  mkdirSync2(dirname3(path), { recursive: true });
+  writeFileSync2(path, contents, "utf8");
   return { harness, path, action: already ? "replaced" : "written" };
 }
 function taken(harness, path, held, stripped) {
@@ -42515,22 +42592,23 @@ function taken(harness, path, held, stripped) {
     return { harness, path, action: "absent" };
   }
   if (stripped.trim() === "" || stripped.trim() === "{}") {
-    rmSync(path, { force: true });
+    rmSync2(path, { force: true });
     return { harness, path, action: "deleted" };
   }
-  writeFileSync(path, stripped, "utf8");
+  writeFileSync2(path, stripped, "utf8");
   return { harness, path, action: "removed" };
 }
 
 // src/headless.ts
+init_call_signal();
 init_game_log();
 init_scratch();
-import { execFile as execFile2 } from "node:child_process";
-import { mkdtempSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { execFile as execFile3 } from "node:child_process";
+import { mkdtempSync, writeFileSync as writeFileSync3 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join4 } from "node:path";
-import { promisify as promisify2 } from "node:util";
-var run2 = promisify2(execFile2);
+import { join as join5 } from "node:path";
+import { promisify as promisify3 } from "node:util";
+var run3 = promisify3(execFile3);
 function snakeCased(params) {
   const result = emptyRecord();
   for (const [key, value] of Object.entries(params)) {
@@ -42569,13 +42647,13 @@ function reason(stdout, stderr) {
   return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
 }
 async function runOperation(engine, operation, params, projectPath) {
-  const paramsDir = mkdtempSync(join4(tmpdir(), "gdharness-params-"));
-  const paramsFile = join4(paramsDir, `${operation}.json`);
-  writeFileSync2(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
+  const paramsDir = mkdtempSync(join5(tmpdir(), "gdharness-params-"));
+  const paramsFile = join5(paramsDir, `${operation}.json`);
+  writeFileSync3(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
     "--log-file",
-    join4(paramsDir, "engine.log"),
+    join5(paramsDir, "engine.log"),
     "--path",
     projectPath,
     "--script",
@@ -42587,7 +42665,7 @@ async function runOperation(engine, operation, params, projectPath) {
   let stdout;
   let stderr;
   try {
-    ({ stdout, stderr } = await run2(engine.godotPath, args));
+    ({ stdout, stderr } = await run3(engine.godotPath, args, { signal: callSignal() }));
   } catch (error) {
     if (error instanceof Error && "stdout" in error && "stderr" in error) {
       const failed = error;
@@ -42745,12 +42823,12 @@ class Ask {
 
 // src/server-version.ts
 init_update_check();
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync5 } from "node:fs";
 var DEBUG_MODE2 = process.env["DEBUG"] === "true";
 var GODOT_DEBUG_MODE_DEFAULT2 = process.env["GODOT_DEBUG"] === "true" || DEBUG_MODE2;
 var SERVER_VERSION2 = (() => {
   try {
-    const pkg = JSON.parse(readFileSync4(new URL("../package.json", import.meta.url), "utf8"));
+    const pkg = JSON.parse(readFileSync5(new URL("../package.json", import.meta.url), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : "0.0.0";
   } catch {
     return "0.0.0";
@@ -42762,19 +42840,19 @@ init_class_cache();
 init_headless();
 init_resources();
 init_server_version();
-import { spawnSync } from "node:child_process";
+import { spawnSync as spawnSync2 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
 import {
   cpSync,
   existsSync as existsSync7,
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync4,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync7,
-  rmSync as rmSync3,
+  readFileSync as readFileSync8,
+  rmSync as rmSync4,
   statSync as statSync3,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname3, join as join8 } from "node:path";
+import { dirname as dirname4, join as join9 } from "node:path";
 import { fileURLToPath } from "node:url";
 var ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
 var EDITOR_PLUGINS = ["gdharness_editor", "auto_reload"];
@@ -42791,64 +42869,64 @@ function editorAddonDigest(from = shippedAddonsDirectory()) {
       if (name === VERSION_MARKER || name === DIGEST_MARKER) {
         continue;
       }
-      const path = join8(directory, name);
+      const path = join9(directory, name);
       const inside = `${relative}/${name}`;
       if (statSync3(path).isDirectory()) {
         walk(path, inside);
       } else {
         hash.update(`${inside}
 `);
-        hash.update(readFileSync7(path));
+        hash.update(readFileSync8(path));
         hash.update(`
 `);
       }
     }
   };
   for (const name of EDITOR_PLUGINS) {
-    walk(join8(from, name), name);
+    walk(join9(from, name), name);
   }
   return hash.digest("hex");
 }
 function installedEditorDigest(projectPath) {
-  const marker = join8(projectPath, "addons", ADDONS[0], DIGEST_MARKER);
+  const marker = join9(projectPath, "addons", ADDONS[0], DIGEST_MARKER);
   if (!existsSync7(marker)) {
     return null;
   }
-  const said = readFileSync7(marker, "utf8").trim();
+  const said = readFileSync8(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 function shippedAddonsDirectory() {
-  return join8(dirname3(fileURLToPath(import.meta.url)), "godot", "addons");
+  return join9(dirname4(fileURLToPath(import.meta.url)), "godot", "addons");
 }
 function shippedOperationsScript() {
-  return join8(dirname3(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
+  return join9(dirname4(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
 }
 function installAddons(projectPath, from = shippedAddonsDirectory()) {
   const installed = [];
   for (const name of ADDONS) {
-    const source = join8(from, name);
-    if (!existsSync7(join8(source, name === "gdharness_runtime" ? "runtime_autoload.gd" : "plugin.cfg"))) {
+    const source = join9(from, name);
+    if (!existsSync7(join9(source, name === "gdharness_runtime" ? "runtime_autoload.gd" : "plugin.cfg"))) {
       throw new Error(`The package holds no ${name} addon at ${source}.`);
     }
-    const target = join8(projectPath, "addons", name);
+    const target = join9(projectPath, "addons", name);
     const replaced = existsSync7(target);
-    rmSync3(target, { recursive: true, force: true });
-    mkdirSync3(dirname3(target), { recursive: true });
+    rmSync4(target, { recursive: true, force: true });
+    mkdirSync4(dirname4(target), { recursive: true });
     cpSync(source, target, { recursive: true });
-    writeFileSync5(join8(target, VERSION_MARKER), `${SERVER_VERSION}
+    writeFileSync6(join9(target, VERSION_MARKER), `${SERVER_VERSION}
 `);
     installed.push({ name, path: target, replaced });
   }
-  writeFileSync5(join8(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
+  writeFileSync6(join9(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
 `);
   return installed;
 }
 function removeAddons(projectPath) {
   const removed = [];
   for (const name of ADDONS) {
-    const target = join8(projectPath, "addons", name);
+    const target = join9(projectPath, "addons", name);
     if (existsSync7(target)) {
-      rmSync3(target, { recursive: true, force: true });
+      rmSync4(target, { recursive: true, force: true });
       removed.push(target);
     }
   }
@@ -42882,7 +42960,7 @@ function loaderAmong(projectPath, named) {
     }
     let source = null;
     try {
-      source = readFileSync7(join8(projectPath, path), "utf8");
+      source = readFileSync8(join9(projectPath, path), "utf8");
     } catch {}
     if (source?.includes(RUNTIME_AUTOLOAD.path)) {
       return { name: entry, path, exists: true };
@@ -42905,7 +42983,7 @@ function trackedByGit(projectPath, wanted) {
   if (wanted.length === 0) {
     return new Set;
   }
-  const asked = spawnSync("git", ["ls-files", "-z", "--", ...wanted], {
+  const asked = spawnSync2("git", ["ls-files", "-z", "--", ...wanted], {
     cwd: projectPath,
     encoding: "utf8"
   });
@@ -42924,10 +43002,10 @@ function enabledPlugins(settings) {
 function inspectProject(projectPath) {
   const problems = [];
   const addons = ADDONS.map((name) => {
-    const directory = join8(projectPath, "addons", name);
-    const marker = join8(directory, VERSION_MARKER);
+    const directory = join9(projectPath, "addons", name);
+    const marker = join9(directory, VERSION_MARKER);
     const installed = existsSync7(directory);
-    const version = existsSync7(marker) ? readFileSync7(marker, "utf8").trim() : null;
+    const version = existsSync7(marker) ? readFileSync8(marker, "utf8").trim() : null;
     const current = version === SERVER_VERSION;
     if (!installed) {
       problems.push(`addons/${name} is not installed; run gdharness setup`);
@@ -42936,7 +43014,7 @@ function inspectProject(projectPath) {
     }
     return { name, installed, version, current };
   });
-  const settings = parseProjectGodot(readFileSync7(join8(projectPath, "project.godot"), "utf8"));
+  const settings = parseProjectGodot(readFileSync8(join9(projectPath, "project.godot"), "utf8"));
   const pluginsEnabled = enabledPlugins(settings);
   for (const name of EDITOR_PLUGINS) {
     if (!pluginsEnabled.includes(name)) {
@@ -42952,7 +43030,7 @@ function inspectProject(projectPath) {
   const tracked = trackedByGit(projectPath, [...named.values()]);
   const addonMissing = (path) => addons.some((addon) => !addon.installed && path.startsWith(`addons/${addon.name}/`));
   for (const [name, path] of named) {
-    if (!existsSync7(join8(projectPath, path))) {
+    if (!existsSync7(join9(projectPath, path))) {
       if (!addonMissing(path)) {
         problems.push(`the ${name} autoload names res://${path}, which is not in this project, so it boots with a missing script; restore that file, or point the autoload at one that is here`);
       }
@@ -42985,8 +43063,8 @@ function inspectProject(projectPath) {
 // src/skill.ts
 init_setup();
 init_tool_definitions();
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, readdirSync as readdirSync5, rmSync as rmSync5, writeFileSync as writeFileSync7 } from "node:fs";
-import { basename, dirname as dirname5, join as join10 } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync5, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "node:fs";
+import { basename as basename2, dirname as dirname6, join as join11 } from "node:path";
 
 // src/tool-reference.ts
 init_headless_operations();
@@ -43082,7 +43160,7 @@ function renderToolsMarkdown() {
 
 // src/skill.ts
 var SKILL_NAME = "gdharness";
-var SHARED_SKILLS = join10(".agents", "skills");
+var SHARED_SKILLS = join11(".agents", "skills");
 function skillMarkdown(version) {
   return `---
 name: ${SKILL_NAME}
@@ -43255,27 +43333,27 @@ whatever the engine said on stderr comes back under \`engine_messages\`.
 function skillFiles(version) {
   return new Map([
     ["SKILL.md", skillMarkdown(version)],
-    [join10("references", "tools.md"), renderToolsMarkdown()]
+    [join11("references", "tools.md"), renderToolsMarkdown()]
   ]);
 }
 function skillDirectories(harnesses, projectPath, exists) {
-  const directories = [join10(projectPath, SHARED_SKILLS, SKILL_NAME)];
+  const directories = [join11(projectPath, SHARED_SKILLS, SKILL_NAME)];
   for (const harness of harnesses) {
     if (harness.skills === undefined) {
       continue;
     }
-    const own = join10(projectPath, harness.skills.dir);
-    if ((!harness.skills.shared || exists(own)) && !directories.includes(join10(own, SKILL_NAME))) {
-      directories.push(join10(own, SKILL_NAME));
+    const own = join11(projectPath, harness.skills.dir);
+    if ((!harness.skills.shared || exists(own)) && !directories.includes(join11(own, SKILL_NAME))) {
+      directories.push(join11(own, SKILL_NAME));
     }
   }
   return directories;
 }
 function everySkillDirectory(projectPath, harnesses) {
-  const directories = new Set([join10(projectPath, SHARED_SKILLS, SKILL_NAME)]);
+  const directories = new Set([join11(projectPath, SHARED_SKILLS, SKILL_NAME)]);
   for (const harness of harnesses) {
     if (harness.skills !== undefined) {
-      directories.add(join10(projectPath, harness.skills.dir, SKILL_NAME));
+      directories.add(join11(projectPath, harness.skills.dir, SKILL_NAME));
     }
   }
   return [...directories];
@@ -43284,51 +43362,51 @@ function removeSkill(directories, projectPath) {
   const removed = [];
   for (const directory of directories) {
     if (existsSync9(directory)) {
-      rmSync5(directory, { recursive: true, force: true });
-      pruneEmpty(dirname5(directory), projectPath);
+      rmSync6(directory, { recursive: true, force: true });
+      pruneEmpty(dirname6(directory), projectPath);
       removed.push(directory);
     }
   }
   return removed;
 }
 function pruneEmpty(directory, projectPath) {
-  const shared = join10(projectPath, ".agents");
+  const shared = join11(projectPath, ".agents");
   let path = directory;
-  while (path !== projectPath && (basename(path) === "skills" || path === shared)) {
+  while (path !== projectPath && (basename2(path) === "skills" || path === shared)) {
     if (readdirSync5(path).length > 0) {
       return;
     }
-    rmSync5(path, { recursive: true, force: true });
-    path = dirname5(path);
+    rmSync6(path, { recursive: true, force: true });
+    path = dirname6(path);
   }
 }
 function writeSkill(directories, version) {
   const files = skillFiles(version);
   return directories.map((directory) => {
     const replaced = existsSync9(directory);
-    rmSync5(directory, { recursive: true, force: true });
+    rmSync6(directory, { recursive: true, force: true });
     for (const [name, contents] of files) {
-      const path = join10(directory, name);
-      mkdirSync5(dirname5(path), { recursive: true });
-      writeFileSync7(path, contents, "utf8");
+      const path = join11(directory, name);
+      mkdirSync6(dirname6(path), { recursive: true });
+      writeFileSync8(path, contents, "utf8");
     }
     return { path: directory, replaced };
   });
 }
 
 // src/version.ts
-import { readFileSync as readFileSync9 } from "node:fs";
-import { dirname as dirname6, join as join11 } from "node:path";
+import { readFileSync as readFileSync10 } from "node:fs";
+import { dirname as dirname7, join as join12 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function getLocalVersion() {
-  const currentDirectory = dirname6(fileURLToPath3(import.meta.url));
+  const currentDirectory = dirname7(fileURLToPath3(import.meta.url));
   const packageCandidates = [
-    join11(currentDirectory, "..", "package.json"),
-    join11(currentDirectory, "..", "..", "package.json")
+    join12(currentDirectory, "..", "package.json"),
+    join12(currentDirectory, "..", "..", "package.json")
   ];
   for (const packagePath of packageCandidates) {
     try {
-      const value = JSON.parse(readFileSync9(packagePath, "utf-8"));
+      const value = JSON.parse(readFileSync10(packagePath, "utf-8"));
       if (typeof value === "object" && value !== null && "name" in value && value.name === "gdharness" && "version" in value && typeof value.version === "string") {
         return value.version;
       }
@@ -43341,12 +43419,12 @@ function getLocalVersion() {
 var args = process.argv.slice(2);
 var command = args[0];
 
-class UsageError extends Refusal {
+class UsageError extends Refusal2 {
 }
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve5(named ?? ".");
-  if (!existsSync16(join23(projectPath, "project.godot"))) {
+  if (!existsSync16(join24(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -43365,7 +43443,7 @@ async function engine(projectPath) {
 }
 function said2(outcome, what) {
   if (!outcome.ok) {
-    throw new Refusal(`${what}: ${outcome.message}`);
+    throw new Refusal2(`${what}: ${outcome.message}`);
   }
   for (const entry of outcome.messages) {
     console.error(`  engine ${entry.severity}: ${entry.text}`);
@@ -43385,7 +43463,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync16(join23(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync16(join24(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
     console.log(`  that file is not in this project, so it boots with a missing script: restore it, or point the entry at res://${RUNTIME_AUTOLOAD.path}`);
   }
 }
@@ -43620,7 +43698,8 @@ On ${version}. What is left for you:`);
 ` + `     so it gives an open editor nothing to restart for. editor_status says addonIsStale
 ` + "     if the editor is older than that." : `  1. The open editor is still running the addons it loaded at startup. Restart it with the
 ` + "     editor_launch restart tool, which closes and reopens the window.");
-  console.log(harnessNote({ moved, written, byHand }, [launch.command, ...launch.args].join(" ")));
+  const serving = serverServing(projectPath);
+  console.log(harnessNote({ moved, written, byHand }, [launch.command, ...launch.args].join(" "), serving === null ? null : { server: serving, isThisVersion: serving.version === version }));
 }
 function doctorReport(projectPath) {
   const report = inspectProject(projectPath);
@@ -43780,7 +43859,7 @@ async function main() {
   }
 }
 await main().catch((error) => {
-  if (error instanceof Refusal) {
+  if (error instanceof Refusal2) {
     console.error("gdharness:", error.message);
     process.exit(error instanceof UsageError ? 2 : 1);
   }