gdharness 1.1.13 → 1.1.15

package/build/cli.js

@@ -68,11 +68,156 @@ var init_errors = __esm(() => {
   };
 });
 
+// src/windows-ask.ts
+import { spawn } from "node:child_process";
+import process2 from "node:process";
+function holding(child, wanted) {
+  if (held === wanted) {
+    return;
+  }
+  held = wanted;
+  const stdout = child.stdout;
+  if (wanted) {
+    stdout.ref?.();
+  } else {
+    stdout.unref?.();
+  }
+}
+function running() {
+  if (helper?.exitCode === null && helper.signalCode === null) {
+    return helper;
+  }
+  const child = spawn("powershell.exe", [
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-EncodedCommand",
+    Buffer.from(SCRIPT, "utf16le").toString("base64")
+  ], { stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+  buffered = "";
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    buffered += chunk;
+    for (let end = buffered.indexOf(`
+`);end !== -1; end = buffered.indexOf(`
+`)) {
+      answered(buffered.slice(0, end).trim());
+      buffered = buffered.slice(end + 1);
+    }
+  });
+  child.stderr.resume();
+  child.stdin.on("error", () => {});
+  const gone = () => {
+    if (helper !== child) {
+      return;
+    }
+    helper = null;
+    if (out !== null) {
+      clearTimeout(out.timer);
+      out.question.reject(new WindowsAskFailure("exited before it answered"));
+      out = null;
+    }
+    sendNext();
+  };
+  child.once("exit", gone);
+  child.once("error", gone);
+  child.unref();
+  child.stdin.unref?.();
+  child.stderr.unref?.();
+  held = true;
+  holding(child, false);
+  helper = child;
+  return child;
+}
+function answered(line) {
+  const [id, tag, body] = line.split(" ");
+  if (out === null || out.id !== Number(id)) {
+    return;
+  }
+  const { question, timer } = out;
+  clearTimeout(timer);
+  out = null;
+  const said = Buffer.from(body ?? "", "base64").toString("utf8");
+  if (tag === "OK") {
+    question.resolve(said);
+  } else {
+    question.reject(new WindowsAskFailure(`refused the question: ${said.trim() || "no reason given"}`));
+  }
+  sendNext();
+}
+function sendNext() {
+  const question = queued.shift();
+  if (question === undefined) {
+    if (helper !== null) {
+      holding(helper, false);
+    }
+    return;
+  }
+  const child = running();
+  holding(child, true);
+  const id = next;
+  next += 1;
+  const timer = setTimeout(() => {
+    if (out?.id !== id) {
+      return;
+    }
+    out = null;
+    question.reject(new WindowsAskFailure(`did not answer within ${question.withinMs}ms`));
+    if (helper === child) {
+      helper = null;
+    }
+    child.kill();
+    sendNext();
+  }, question.withinMs);
+  out = { id, question, timer };
+  child.stdin.write(`${id} ${Buffer.from(question.script, "utf8").toString("base64")}
+`);
+}
+function askWindows(script, withinMs) {
+  if (process2.platform !== "win32") {
+    return Promise.reject(new WindowsAskFailure("is asked only on Windows"));
+  }
+  return new Promise((resolve, reject) => {
+    queued.push({ script, withinMs, resolve, reject });
+    if (out === null) {
+      sendNext();
+    }
+  });
+}
+var SCRIPT, WindowsAskFailure, helper = null, buffered = "", next = 1, out = null, queued, held = false;
+var init_windows_ask = __esm(() => {
+  SCRIPT = [
+    "[Console]::OutputEncoding = [Text.Encoding]::UTF8",
+    "$in = [Console]::In",
+    "while ($null -ne ($line = $in.ReadLine())) {",
+    '  $parts = $line.Split(" ", 2)',
+    "  try {",
+    "    $asked = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($parts[1]))",
+    "    $said = (& ([ScriptBlock]::Create($asked)) | Out-String -Width 1000000)",
+    '    $tag = "OK"',
+    "  } catch {",
+    "    $said = $_.Exception.Message",
+    '    $tag = "ERR"',
+    "  }",
+    '  [Console]::Out.Write($parts[0] + " " + $tag + " " + [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($said)) + "`n")',
+    "  [Console]::Out.Flush()",
+    "}"
+  ].join(`
+`);
+  WindowsAskFailure = class WindowsAskFailure extends Error {
+    constructor(how) {
+      super(`PowerShell ${how}`);
+    }
+  };
+  queued = [];
+});
+
 // src/process-children.ts
-import { execFile, execFileSync, spawnSync } from "node:child_process";
+import { execFile } from "node:child_process";
 import { basename } from "node:path";
 import { promisify } from "node:util";
-function startTimesOf(pids) {
+async function startTimesOf(pids) {
   const began = new Map;
   if (pids.length === 0) {
     return began;
@@ -80,12 +225,7 @@ function startTimesOf(pids) {
   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 });
+      const said = await askWindows(`Get-CimInstance Win32_Process -Filter "${filter}" | ForEach-Object { "$($_.ProcessId) $(([DateTimeOffset]$_.CreationDate).ToUnixTimeMilliseconds())" }`, ASK_TIMEOUT_MS);
       for (const line of said.split(`
 `)) {
         const found = /^\s*(\d+)\s+(\d+)\s*$/.exec(line);
@@ -95,11 +235,10 @@ function startTimesOf(pids) {
       }
       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;
+    const said = await printedBy("ps", ["-p", pids.join(","), "-o", "pid=,lstart="], {
+      ...process.env,
+      LC_ALL: "C"
+    });
     for (const line of said.split(`
 `)) {
       const found = /^\s*(\d+)\s+(.+)$/.exec(line);
@@ -111,16 +250,39 @@ function startTimesOf(pids) {
   } catch {}
   return began;
 }
+function printedBy(command, args, env) {
+  return new Promise((resolve) => {
+    execFile(command, [...args], { encoding: "utf8", timeout: ASK_TIMEOUT_MS, env }, (_error, stdout) => {
+      resolve(stdout);
+    });
+  });
+}
 async function processTree() {
   try {
-    const tree = process.platform === "win32" ? parseProcessTable(await askWindows(), true) : parseProcessTable(await askPosix());
+    const tree = process.platform === "win32" ? parseProcessTable(await listWindows(), true) : parseProcessTable(await askPosix());
     lastListingFailure = undefined;
     return tree;
   } catch (error) {
-    lastListingFailure = error instanceof Error ? error.message : String(error);
+    lastListingFailure = listingFailure(error);
     return;
   }
 }
+function listingFailure(error) {
+  if (error instanceof WindowsAskFailure) {
+    return error.message;
+  }
+  if (!(error instanceof Error)) {
+    return String(error);
+  }
+  const failed = error;
+  const how = failed.killed === true ? `was killed after the ${ASK_TIMEOUT_MS}ms budget${failed.signal ? ` (${failed.signal})` : ""}` : failed.signal ? `was ended by ${failed.signal}` : failed.code !== undefined && failed.code !== null ? `exited with ${failed.code}` : "failed";
+  const said = typeof failed.stderr === "string" ? failed.stderr.trim() : "";
+  const asked = basename((failed.cmd ?? "").split(" ")[0] ?? "") || "the listing";
+  return `${asked} ${how}${said === "" ? ", with nothing on stderr" : `; stderr: ${said.slice(0, 400)}`}`;
+}
+function whyTheProcessTreeFailed() {
+  return lastListingFailure;
+}
 function parseProcessTable(printed, started = false) {
   const tree = new Map;
   for (const line of printed.split(/\r?\n/)) {
@@ -250,14 +412,8 @@ function commandWords(command) {
   }
   return words;
 }
-async function askWindows() {
-  const { stdout } = await run("powershell.exe", [
-    "-NoProfile",
-    "-NonInteractive",
-    "-Command",
-    `${POWERSHELL_UTF8}Get-CimInstance Win32_Process -Property ProcessId,ParentProcessId,CreationDate,CommandLine | 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;
+function listWindows() {
+  return askWindows('Get-CimInstance Win32_Process -Property ProcessId,ParentProcessId,CreationDate,CommandLine | ForEach-Object { $began = 0; if ($_.CreationDate) { $began = ([DateTimeOffset]$_.CreationDate).ToUnixTimeMilliseconds() }; "$($_.ProcessId) $($_.ParentProcessId) $began $($_.CommandLine)" }', ASK_TIMEOUT_MS);
 }
 async function askPosix() {
   const { stdout } = await run("ps", ["-e", "-o", "pid=,ppid=,args="], {
@@ -266,8 +422,9 @@ async function askPosix() {
   });
   return stdout;
 }
-var run, POWERSHELL_UTF8 = "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; ", ASK_TIMEOUT_MS = 15000, lastListingFailure;
+var run, ASK_TIMEOUT_MS = 15000, lastListingFailure;
 var init_process_children = __esm(() => {
+  init_windows_ask();
   run = promisify(execFile);
 });
 
@@ -302,12 +459,12 @@ function serverBehind(announcement, startedAt) {
   }
   return { version: announcement.version, pid: announcement.pid };
 }
-function serverServing(projectPath) {
+async function serverServing(projectPath) {
   const announcement = readAnnouncement(announcementPath(projectPath));
   if (announcement === null) {
     return null;
   }
-  return serverBehind(announcement, startTimesOf([announcement.pid]).get(announcement.pid));
+  return serverBehind(announcement, (await startTimesOf([announcement.pid])).get(announcement.pid));
 }
 function announcementIsOurs(path) {
   return readAnnouncement(path)?.pid === process.pid;
@@ -448,8 +605,18 @@ function resolveHeadless(requested, host) {
   }
   return envValue("DISPLAY", host.variables) === undefined && envValue("WAYLAND_DISPLAY", host.variables) === undefined;
 }
+function resolveSilent(requested, variables) {
+  if (typeof requested === "boolean") {
+    return requested;
+  }
+  const said = envValue("GDHARNESS_SILENT", variables)?.toLowerCase();
+  return said !== undefined && said !== "0" && said !== "false";
+}
 function runArguments(options) {
   const args = options.headless ? ["--headless", "--path", options.projectPath] : ["--path", options.projectPath];
+  if (options.silent === true && !options.headless) {
+    args.push("--audio-driver", "Dummy");
+  }
   if (options.quitAfter !== undefined && options.quitAfter !== null) {
     args.push("--quit-after", String(options.quitAfter));
   }
@@ -7520,16 +7687,16 @@ var require_public_api = __commonJS(function(exports) {
 // src/runner.ts
 import { existsSync as existsSync3 } from "node:fs";
 import { dirname as dirname2, join as join3 } from "node:path";
-import process2 from "node:process";
+import process3 from "node:process";
 function currentRunner() {
-  const versions = process2.versions;
+  const versions = process3.versions;
   return versions["bun"] === undefined ? "npx" : "bunx";
 }
 function runLine(runner, version, rest = "") {
   const flag = runner === "npx" ? "-y " : "";
   return `${runner} ${flag}gdharness@${version}${rest === "" ? "" : ` ${rest}`}`;
 }
-function spawnFor(runner, version, execPath = process2.execPath) {
+function spawnFor(runner, version, execPath = process3.execPath) {
   const spec = `gdharness@${version}`;
   if (runner !== currentRunner()) {
     return { command: runner, args: runner === "npx" ? ["-y", spec] : ["--bun", spec] };
@@ -7540,7 +7707,7 @@ function spawnFor(runner, version, execPath = process2.execPath) {
   return { command: alongside(execPath, "npx") ?? "npx", args: ["-y", spec] };
 }
 function alongside(execPath, name) {
-  const runner = join3(dirname2(execPath), process2.platform === "win32" ? `${name}.cmd` : name);
+  const runner = join3(dirname2(execPath), process3.platform === "win32" ? `${name}.cmd` : name);
   return existsSync3(runner) ? runner : undefined;
 }
 var init_runner = () => {};
@@ -7683,8 +7850,47 @@ var init_game_log = __esm(() => {
   };
 });
 
+// src/alive.ts
+import process5 from "node:process";
+function alive(pid) {
+  if (pid === undefined || pid === null) {
+    return false;
+  }
+  try {
+    process5.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+var init_alive = () => {};
+
 // src/scratch.ts
-import { rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync5, mkdtempSync, readdirSync as readdirSync2, rmSync as rmSync3 } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join5 } from "node:path";
+import process6 from "node:process";
+function scratchDirectory(kind) {
+  return mkdtempSync(join5(tmpdir(), `gdharness-${kind}-${process6.pid}-`));
+}
+function sweepAbandonedScratch(directory = tmpdir()) {
+  let entries;
+  try {
+    entries = readdirSync2(directory);
+  } catch {
+    return;
+  }
+  const named = new RegExp(`^gdharness-(${KINDS.join("|")})-(\\d+)-[A-Za-z0-9]{6}$`);
+  for (const entry of entries) {
+    const owner = named.exec(entry)?.[2];
+    if (owner === undefined || alive(Number(owner))) {
+      continue;
+    }
+    try {
+      remove(join5(directory, entry));
+    } catch {}
+  }
+}
 function discardWith(remove, paths) {
   const left = [];
   for (const path of paths) {
@@ -7700,20 +7906,75 @@ function discardWith(remove, paths) {
   return left;
 }
 function discard(...paths) {
-  return discardWith((path) => {
-    rmSync3(path, SWEPT);
-  }, paths);
+  const left = discardWith(remove, paths);
+  for (const { path } of left) {
+    tryAgain(path, 0);
+  }
+  return left;
+}
+function remove(path) {
+  rmSync3(path, SWEPT);
+}
+function tryAgain(path, attempt) {
+  if (attempt === 0) {
+    if (waiting.has(path)) {
+      return;
+    }
+    waiting.add(path);
+    atExit.delete(path);
+    lastTryOnExit();
+  }
+  const after = AGAIN_AFTER_MS[attempt];
+  if (after === undefined || !existsSync5(path)) {
+    waiting.delete(path);
+    if (after === undefined) {
+      atExit.add(path);
+    }
+    return;
+  }
+  setTimeout(() => {
+    try {
+      remove(path);
+      waiting.delete(path);
+    } catch {
+      tryAgain(path, attempt + 1);
+    }
+  }, after).unref();
 }
-var SWEPT;
+function lastTryOnExit() {
+  if (lastTryWatched) {
+    return;
+  }
+  lastTryWatched = true;
+  process6.once("exit", () => {
+    for (const path of [...waiting, ...atExit]) {
+      try {
+        remove(path);
+      } catch {}
+    }
+  });
+}
+var SWEPT, AGAIN_AFTER_MS, waiting, atExit, KINDS, lastTryWatched = false;
 var init_scratch = __esm(() => {
-  SWEPT = { recursive: true, force: true, maxRetries: 20, retryDelay: 250 };
+  init_alive();
+  SWEPT = { recursive: true, force: true };
+  AGAIN_AFTER_MS = [250, 500, 1000, 2000, 4000, 8000, 16000];
+  waiting = new Set;
+  atExit = new Set;
+  KINDS = [
+    "desktop",
+    "export",
+    "import",
+    "params",
+    "runtime-screenshot",
+    "tests"
+  ];
 });
 
 // src/headless.ts
 import { execFile as execFile3 } from "node:child_process";
-import { mkdtempSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { tmpdir } from "node:os";
-import { join as join5 } from "node:path";
+import { writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join6 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 function snakeCased(params) {
   const result = emptyRecord();
@@ -7753,9 +8014,9 @@ function reason(stdout, stderr) {
   return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
 }
 async function runImport(godotPath, projectPath) {
-  const logDir = mkdtempSync(join5(tmpdir(), "gdharness-import-"));
+  const logDir = scratchDirectory("import");
   try {
-    const { stderr } = await run3(godotPath, ["--headless", "--log-file", join5(logDir, "engine.log"), "--path", projectPath, "--import"], { signal: callSignal() });
+    const { stderr } = await run3(godotPath, ["--headless", "--log-file", join6(logDir, "engine.log"), "--path", projectPath, "--import"], { signal: callSignal() });
     return { ok: true, messages: problems(stderr) };
   } catch (error) {
     if (error instanceof Error && "stdout" in error && "stderr" in error) {
@@ -7776,13 +8037,13 @@ async function runImport(godotPath, projectPath) {
   }
 }
 async function runOperation(engine, operation, params, projectPath) {
-  const paramsDir = mkdtempSync(join5(tmpdir(), "gdharness-params-"));
-  const paramsFile = join5(paramsDir, `${operation}.json`);
+  const paramsDir = scratchDirectory("params");
+  const paramsFile = join6(paramsDir, `${operation}.json`);
   writeFileSync3(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
     "--log-file",
-    join5(paramsDir, "engine.log"),
+    join6(paramsDir, "engine.log"),
     "--path",
     projectPath,
     "--script",
@@ -7831,9 +8092,9 @@ var init_headless = __esm(() => {
 });
 
 // src/update-check.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync6, 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 join6 } from "node:path";
+import { join as join7 } from "node:path";
 function packageUrl(root) {
   return `${root.replace(/\/+$/, "")}/gdharness/latest`;
 }
@@ -7855,25 +8116,25 @@ function cacheDirectory(environment) {
   };
   const home = set("HOME") ?? homedir3();
   if (process.platform === "win32") {
-    return join6(set("LOCALAPPDATA") ?? home, "gdharness");
+    return join7(set("LOCALAPPDATA") ?? home, "gdharness");
   }
   if (process.platform === "darwin") {
-    return join6(home, "Library", "Caches", "gdharness");
+    return join7(home, "Library", "Caches", "gdharness");
   }
-  return join6(set("XDG_CACHE_HOME") ?? join6(home, ".cache"), "gdharness");
+  return join7(set("XDG_CACHE_HOME") ?? join7(home, ".cache"), "gdharness");
 }
 function cacheFile(environment = process.env) {
   try {
     const directory = cacheDirectory(environment);
     mkdirSync3(directory, { recursive: true, mode: 448 });
-    return join6(directory, "update-check.json");
+    return join7(directory, "update-check.json");
   } catch {
-    return join6(tmpdir2(), "gdharness-update-check.json");
+    return join7(tmpdir2(), "gdharness-update-check.json");
   }
 }
 function readCache(path) {
   try {
-    if (!existsSync5(path)) {
+    if (!existsSync6(path)) {
       return null;
     }
     const parsed = JSON.parse(readFileSync3(path, "utf8"));
@@ -8076,19 +8337,20 @@ var init_server_version = __esm(() => {
 
 // src/issues.ts
 import { createHash } from "node:crypto";
-import process4 from "node:process";
-function feedbackNotice() {
+import process7 from "node:process";
+function feedbackNotice(every) {
   return JSON.stringify({
     gdharness_feedback: {
+      why_here: `Asked once every ${every} answers, whatever the call was. It is not about the answer it comes with, which is complete as it stands.`,
       what_to_do: "If this session has run into something gdharness cannot do, or a tool that should " + "exist and does not, tell the user what is missing and offer to open an enhancement " + "issue for them. Only if they say yes, and only for a real gap: a call you got wrong " + "is not one. If you cannot open an issue yourself, give them the link and what to " + "write in it.",
       enhancement_url: ENHANCEMENT_URL
     }
   }, null, 2);
 }
 function runtime() {
-  const versions = process4.versions;
+  const versions = process7.versions;
   const bun = versions["bun"];
-  return bun === undefined ? `node ${process4.versions.node}` : `bun ${bun}`;
+  return bun === undefined ? `node ${process7.versions.node}` : `bun ${bun}`;
 }
 function defectSignature(where, message) {
   const normalised = `${where}
@@ -8100,7 +8362,7 @@ function facts(where, message, godotVersion) {
     ["Where", where],
     ["Error", message],
     ["Version", `gdharness ${SERVER_VERSION}`],
-    ["Runtime", `${runtime()}, ${process4.platform} ${process4.arch}`],
+    ["Runtime", `${runtime()}, ${process7.platform} ${process7.arch}`],
     ["Godot", godotVersion ?? "not known at the point this failed"],
     ["Signature", defectSignature(where, message)]
   ];
@@ -8110,7 +8372,7 @@ function filledTemplate(where, message, godotVersion) {
     `**gdharness version**: ${SERVER_VERSION}`,
     `**Godot version**: ${godotVersion ?? ""}`,
     `**Bun version**: ${runtime()}`,
-    `**OS**: ${process4.platform} ${process4.arch}`,
+    `**OS**: ${process7.platform} ${process7.arch}`,
     "**MCP client**:",
     "",
     "## What you did",
@@ -8199,35 +8461,82 @@ var init_issues = __esm(() => {
 });
 
 // src/class-cache.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync2 } from "node:fs";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync2 } from "node:fs";
+import { join as join8 } from "node:path";
 function declaredClasses(projectPath) {
   const declared = new Map;
+  eachScript(projectPath, (script, source) => {
+    const found = DECLARATION.exec(source);
+    if (found?.[1]) {
+      declared.set(found[1], script);
+    }
+  });
+  return declared;
+}
+function eachScript(projectPath, each) {
   const visit = (directory, prefix) => {
-    if (existsSync6(join7(directory, ".gdignore"))) {
+    if (existsSync7(join8(directory, ".gdignore"))) {
       return;
     }
-    for (const entry of readdirSync2(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync3(directory, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) {
         continue;
       }
-      const path = join7(directory, entry.name);
+      const path = join8(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"));
-        if (found?.[1]) {
-          declared.set(found[1], `res://${prefix}${entry.name}`);
-        }
+        each(`res://${prefix}${entry.name}`, readFileSync5(path, "utf8"));
       }
     }
   };
   visit(projectPath, "");
-  return declared;
+}
+function scriptsNaming(projectPath, classes) {
+  const named = new Map(classes.map((name) => [name, ""]));
+  const naming = [];
+  eachScript(projectPath, (script, source) => {
+    const declares = DECLARATION.exec(source)?.[1];
+    if (declares !== undefined && named.has(declares)) {
+      return;
+    }
+    const code = codeOf(source);
+    if (classesNamedIn(code, named).length > 0) {
+      naming.push({ script, tool: /^\s*@tool\b/m.test(code) });
+    }
+  });
+  return naming.sort((a, b) => a.script.localeCompare(b.script));
+}
+function codeOf(source) {
+  let code = "";
+  let at = 0;
+  while (at < source.length) {
+    const here = source[at] ?? "";
+    if (here === "#") {
+      const end = source.indexOf(`
+`, at);
+      at = end === -1 ? source.length : end;
+      continue;
+    }
+    if (here === '"' || here === "'") {
+      const fence = source.startsWith(here.repeat(3), at) ? here.repeat(3) : here;
+      let end = at + fence.length;
+      while (end < source.length && !source.startsWith(fence, end)) {
+        end += source[end] === "\\" ? 2 : 1;
+      }
+      const literal = source.slice(at, Math.min(end + fence.length, source.length));
+      code += literal.replace(/[^\n]/g, " ");
+      at = end + fence.length;
+      continue;
+    }
+    code += here;
+    at += 1;
+  }
+  return code;
 }
 function cachedClasses(projectPath) {
-  const cache = join7(projectPath, ".godot", "global_script_class_cache.cfg");
-  if (!existsSync6(cache)) {
+  const cache = join8(projectPath, ".godot", "global_script_class_cache.cfg");
+  if (!existsSync7(cache)) {
     return null;
   }
   const listed = new Map;
@@ -8340,7 +8649,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 = join7(projectPath, ".godot", "global_script_class_cache.cfg");
+  const cache = join8(projectPath, ".godot", "global_script_class_cache.cfg");
   try {
     return statSync2(cache).mtimeMs;
   } catch {
@@ -8354,14 +8663,14 @@ function declaredSince(projectPath, paths, names, since) {
       return false;
     }
     try {
-      return statSync2(join7(projectPath, path.slice("res://".length))).mtimeMs > since;
+      return statSync2(join8(projectPath, path.slice("res://".length))).mtimeMs > since;
     } catch {
       return false;
     }
   });
 }
 function cachedAtMissingPaths(cached, projectPath) {
-  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync6(join7(projectPath, path.slice("res://".length)))).map(([name]) => name).sort();
+  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync7(join8(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);
@@ -15851,29 +16160,29 @@ function readParams(params, key) {
 }
 
 // src/setup.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
+import { spawnSync } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
 import {
   cpSync,
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   mkdirSync as mkdirSync4,
-  readdirSync as readdirSync3,
+  readdirSync as readdirSync4,
   readFileSync as readFileSync7,
   rmdirSync,
   rmSync as rmSync4,
   statSync as statSync3,
   writeFileSync as writeFileSync5
 } from "node:fs";
-import { dirname as dirname4, join as join8 } from "node:path";
+import { dirname as dirname4, join as join9 } from "node:path";
 import { fileURLToPath } from "node:url";
 function editorAddonDigest(from = shippedAddonsDirectory()) {
   const hash = createHash2("sha256");
   const walk = (directory, relative) => {
-    for (const name of readdirSync3(directory).sort()) {
+    for (const name of readdirSync4(directory).sort()) {
       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);
@@ -15887,7 +16196,7 @@ function editorAddonDigest(from = shippedAddonsDirectory()) {
     }
   };
   for (const name of EDITOR_PLUGINS) {
-    walk(join8(from, name), name);
+    walk(join9(from, name), name);
   }
   return hash.digest("hex");
 }
@@ -15902,42 +16211,42 @@ function shippedEditorDigest() {
   return shippedDigest ?? undefined;
 }
 function installedEditorDigest(projectPath) {
-  const marker = join8(projectPath, "addons", ADDONS[0], DIGEST_MARKER);
-  if (!existsSync7(marker)) {
+  const marker = join9(projectPath, "addons", ADDONS[0], DIGEST_MARKER);
+  if (!existsSync8(marker)) {
     return null;
   }
   const said = readFileSync7(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 function shippedAddonsDirectory() {
-  return join8(dirname4(fileURLToPath(import.meta.url)), "godot", "addons");
+  return join9(dirname4(fileURLToPath(import.meta.url)), "godot", "addons");
 }
 function shippedOperationsScript() {
-  return join8(dirname4(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 (!existsSync8(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 replaced = existsSync7(target);
+    const target = join9(projectPath, "addons", name);
+    const replaced = existsSync8(target);
     rmSync4(target, { recursive: true, force: true });
     mkdirSync4(dirname4(target), { recursive: true });
     cpSync(source, target, { recursive: true });
-    writeFileSync5(join8(target, VERSION_MARKER), `${SERVER_VERSION}
+    writeFileSync5(join9(target, VERSION_MARKER), `${SERVER_VERSION}
 `);
     installed.push({ name, path: target, replaced });
   }
-  writeFileSync5(join8(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
+  writeFileSync5(join9(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
 `);
   return installed;
 }
 function installedAddonVersion(projectPath) {
-  const marker = join8(projectPath, "addons", ADDONS[0], VERSION_MARKER);
-  if (!existsSync7(marker)) {
+  const marker = join9(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  if (!existsSync8(marker)) {
     return null;
   }
   const said = readFileSync7(marker, "utf8").trim();
@@ -15946,14 +16255,14 @@ function installedAddonVersion(projectPath) {
 function removeAddons(projectPath) {
   const removed = [];
   for (const name of ADDONS) {
-    const target = join8(projectPath, "addons", name);
-    if (existsSync7(target)) {
+    const target = join9(projectPath, "addons", name);
+    if (existsSync8(target)) {
       rmSync4(target, { recursive: true, force: true });
       removed.push(target);
     }
   }
-  const addons = join8(projectPath, "addons");
-  if (removed.length > 0 && existsSync7(addons) && readdirSync3(addons).length === 0) {
+  const addons = join9(projectPath, "addons");
+  if (removed.length > 0 && existsSync8(addons) && readdirSync4(addons).length === 0) {
     rmdirSync(addons);
     removed.push(addons);
   }
@@ -15987,7 +16296,7 @@ function loaderAmong(projectPath, named) {
     }
     let source = null;
     try {
-      source = readFileSync7(join8(projectPath, path), "utf8");
+      source = readFileSync7(join9(projectPath, path), "utf8");
     } catch {}
     if (source?.includes(RUNTIME_AUTOLOAD.path)) {
       return { name: entry, path, exists: true };
@@ -16010,7 +16319,7 @@ function trackedByGit(projectPath, wanted) {
   if (wanted.length === 0) {
     return new Set;
   }
-  const asked = spawnSync2("git", ["ls-files", "-z", "--", ...wanted], {
+  const asked = spawnSync("git", ["ls-files", "-z", "--", ...wanted], {
     cwd: projectPath,
     encoding: "utf8"
   });
@@ -16029,10 +16338,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 installed = existsSync7(directory);
-    const version = existsSync7(marker) ? readFileSync7(marker, "utf8").trim() : null;
+    const directory = join9(projectPath, "addons", name);
+    const marker = join9(directory, VERSION_MARKER);
+    const installed = existsSync8(directory);
+    const version = existsSync8(marker) ? readFileSync7(marker, "utf8").trim() : null;
     const current = version === SERVER_VERSION;
     if (!installed) {
       problems.push(`addons/${name} is not installed; run gdharness setup`);
@@ -16041,7 +16350,7 @@ function inspectProject(projectPath) {
     }
     return { name, installed, version, current };
   });
-  const settings = parseProjectGodot(readFileSync7(join8(projectPath, "project.godot"), "utf8"));
+  const settings = parseProjectGodot(readFileSync7(join9(projectPath, "project.godot"), "utf8"));
   const pluginsEnabled = enabledPlugins(settings);
   for (const name of EDITOR_PLUGINS) {
     if (!pluginsEnabled.includes(name)) {
@@ -16057,7 +16366,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 (!existsSync8(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`);
       }
@@ -16816,7 +17125,11 @@ var init_tool_definitions = __esm(() => {
       name: "editor_run",
       description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. args hands the game its own flags, the ones it reads with OS.get_cmdline_user_args(), and a run carrying any is started by this server rather than by the editor. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. start and check both wait first for a scan the open editor is running and for the class cache it writes just after, since a game booted in between resolves no global class, as does every other engine this server starts on the project; waitedForEditorScanMs says how long, and scanNote says when a scan ran past thirty seconds and the game started during it. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice. When it is not listening, mayYetAnnounce says whether that is final: false is a runtime that is not coming, true is a game still on its way up, which editor_status will see and runtimeWaitMs waits longer for. A start this server made also answers with transcript, the file both the run's streams are written to, so a watch on it can be armed off the start rather than off a second call.",
       parameters: {
-        projectPath: { ...PROJECT_PATH, ops: ["start", "check"] },
+        projectPath: {
+          ...PROJECT_PATH,
+          ops: ["start", "check", "stop", "wait"],
+          description: "Absolute path to the project directory, the one holding project.godot. stop, wait: optional, the project whose run is meant; a run of another project is refused rather than touched."
+        },
         scene: {
           type: "string",
           ops: ["start", "check"],
@@ -16834,6 +17147,11 @@ var init_tool_definitions = __esm(() => {
           ops: ["start"],
           description: "start: on Windows, show the window on the desktop in use. By default a windowed run this server starts goes on a desktop of its own, where it renders and runtime_capture works but the window never shows and never takes the keyboard. A game a visible editor plays opens on the desktop in use, and one a hidden editor (editor_launch hidden: true) plays goes on its desktop. Elsewhere than Windows the window shows either way. Default false."
         },
+        silent: {
+          type: "boolean",
+          ops: ["start"],
+          description: "start: run the game with no sound out of the machine, by starting the engine with --audio-driver Dummy: every stream still plays and every playback position still advances, so what is playing can still be asked. The editor takes no engine flags for a game it plays, so a silent windowed run is started by this server, and the debug_* tools do not answer for it. A headless run, check's included, is silent already. Default false, or true when GDHARNESS_SILENT is set in the server's environment to anything but 0 or false; silent: false then plays through the editor as before."
+        },
         savesIn: {
           type: "string",
           ops: ["start", "check"],
@@ -16948,7 +17266,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_rescan",
-      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. A scan or an import the editor is already running is waited out first rather than scanned over, which would start a second import over it, and the answer says how long under waitedForEditorScanMs. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script: measured against a real editor on three platforms, with idle waits of the same length ruled out so the scan is credited rather than the time it takes, and reproduced in a second project against its own reproduction in 203ms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. The other direction is guarded the same way: a class the editor still holds for a script that was renamed or deleted comes back into the cache at a path that is not there, and the next engine to read it fails on \"Could not parse global class\" in whichever correct script shares the bare name, so the cache is rebuilt without it and the answer names it under cacheDropped; the editor goes on holding it until it is restarted, and every scan until then ends in that rebuild. A script or shader written outside the editor has no .uid sidecar until something imports it, and the scan writes one beside it, which a project that commits sidecars needs before the commit. Needs the editor connected.",
+      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. A scan or an import the editor is already running is waited out first rather than scanned over, which would start a second import over it, and the answer says how long under waitedForEditorScanMs. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script: measured against a real editor on three platforms, with idle waits of the same length ruled out so the scan is credited rather than the time it takes, and reproduced in a second project against its own reproduction in 203ms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. A class the scan brings in is named under broughtIn, and every script naming it is reloaded in the editor and named under dependentsReloaded: what the editor compiled from them while it could not see the class stays compiled that way after the scan, and a script extending a new base class went on reporting \"Could not find base class\" until reloaded. One that would not reload is named under dependentsNotReloaded and the call is not ok. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. The other direction is guarded the same way: a class the editor still holds for a script that was renamed or deleted comes back into the cache at a path that is not there, and the next engine to read it fails on \"Could not parse global class\" in whichever correct script shares the bare name, so the cache is rebuilt without it and the answer names it under cacheDropped; the editor goes on holding it until it is restarted, and every scan until then ends in that rebuild. A script or shader written outside the editor has no .uid sidecar until something imports it, and the scan writes one beside it, which a project that commits sidecars needs before the commit. Needs the editor connected.",
       parameters: {
         projectPath: PROJECT_PATH,
         timeoutMs: {
@@ -17054,7 +17372,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["find"],
-          description: "find: part of what the node has written on it as drawn, the way the text op reads it, case-insensitively, which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern, and a glob that finds nothing says under note how many nodes it would find open at both ends. A label with a line break is matched with the break in the words, and a backslash followed by n counts as one."
+          description: 'find: part of what the node has written on it as drawn, the way the text op reads it, case-insensitively, which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern, and a glob that finds nothing says under note how many nodes it would find open at both ends. A label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Alternatives separated by | match when any one of them does, each by these rules ("*won*|*lost*"); write \\| for a bar that is part of the words.'
         },
         limit: {
           type: "integer",
@@ -17209,7 +17527,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["click"],
-          description: "click: the words on the control to click, matched the way runtime_inspect find matches says (a plain word is contained in the text, a pattern with * or ? is a glob over it), among the controls on screen, and pressed in the same frame it was found in, so a panel rebuilding between a find and a click cannot free it first. Words on a label inside a button press the button. A control with something drawn over its centre that would take the pointer, such as a screen shown over it, is not on screen. The matches are ranked the way a person picks what to press: a button before text that cannot be pressed, then a control whose whole text is the words before one saying them as part of more, and the best one is pressed; found.picked says why. Several matches at the best rank are refused with each one listed, and index picks one."
+          description: "click: the words on the control to click, matched the way runtime_inspect find matches says (a plain word is contained in the text, a pattern with * or ? is a glob over it, and | separates alternatives), among the controls on screen, and pressed in the same frame it was found in, so a panel rebuilding between a find and a click cannot free it first. Words on a label inside a button press the button. A control with something drawn over its centre that would take the pointer, such as a screen shown over it, is not on screen. The matches are ranked the way a person picks what to press: a button before text that cannot be pressed, then a control whose whole text, or one whole line of it such as the title on a card, is the words before one saying them as part of more, and the best one is pressed; found.picked says why. Several matches at the best rank are refused with each one listed, and index picks one."
         },
         action: {
           type: "string",
@@ -17340,7 +17658,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["until"],
-          description: "until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Matched the way runtime_inspect find matches says: case-insensitive, a plain word anywhere in the text, a pattern with * or ? a glob over the whole of it; on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property. It looks every frame while a look is cheap and less often on a screen large enough for a look to cost a real share of a frame, so the game keeps its speed; the answer counts the frames the wait spanned and the looks it took."
+          description: 'until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Matched the way runtime_inspect find matches says: case-insensitive, a plain word anywhere in the text, a pattern with * or ? a glob over the whole of it, and alternatives separated by | met by whichever appears first ("*won*|*lost*"); on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property. It looks every frame while a look is cheap and less often on a screen large enough for a look to cost a real share of a frame, so the game keeps its speed; the answer counts the frames the wait spanned and the looks it took.'
         },
         includeHidden: {
           type: "boolean",
@@ -32099,10 +32417,10 @@ var init_stdio = __esm(() => {
 });
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
-import process6 from "node:process";
+import process9 from "node:process";
 
 class StdioServerTransport {
-  constructor(_stdin = process6.stdin, _stdout = process6.stdout, options) {
+  constructor(_stdin = process9.stdin, _stdout = process9.stdout, options) {
     this._stdin = _stdin;
     this._stdout = _stdout;
     this._started = false;
@@ -32167,10 +32485,10 @@ var init_stdio2 = __esm(() => {
 });
 
 // src/runtime-client.ts
-import { existsSync as existsSync9, readdirSync as readdirSync5, readFileSync as readFileSync9, statSync as statSync4, unlinkSync } from "node:fs";
+import { existsSync as existsSync10, readdirSync as readdirSync6, readFileSync as readFileSync9, statSync as statSync4, unlinkSync } from "node:fs";
 import { createConnection } from "node:net";
 import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname7, join as join11, resolve as resolve3 } from "node:path";
+import { dirname as dirname7, join as join12, 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);
@@ -32178,20 +32496,20 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join11(perUser ?? tmpdir3(), "gdharness");
+  return join12(perUser ?? tmpdir3(), "gdharness");
 }
 function runtimeDirectories(variables = process.env) {
   const candidates = [runtimeDirectory(variables)];
   const fallbacks = process.platform === "win32" ? [envValue("SystemRoot", variables) ?? envValue("windir", variables) ?? "C:\\Windows"] : ["/tmp", "/var/tmp"];
   for (const base of fallbacks) {
-    candidates.push(join11(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+    candidates.push(join12(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 = join11(directory, `runtime-${pid}.log`);
-    if (existsSync9(path)) {
+    const path = join12(directory, `runtime-${pid}.log`);
+    if (existsSync10(path)) {
       return path;
     }
   }
@@ -32219,14 +32537,6 @@ function reportAlreadyInTranscript(transcript, report) {
   const end = boundary + copied.length;
   return end <= report.length && report.subarray(boundary, end).equals(copied) ? end : report.length;
 }
-function processAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error.code === "EPERM";
-  }
-}
 function parseAnnouncement(file, pid) {
   let fields;
   try {
@@ -32314,46 +32624,52 @@ function strangersAmong(candidates, now, startTimes = startTimesOf) {
     const known = verdicts.get(one.file);
     return known === undefined || known.writtenAt !== one.writtenAt || !known.stranger && now - known.judgedAt > CONFIRMED_FOR_MS;
   });
-  if (toJudge.length > 0) {
-    const began = startTimes(toJudge.map((one) => one.pid));
-    for (const one of toJudge) {
-      const at = began.get(one.pid);
-      const stranger = at !== undefined && at - one.writtenAt > STARTED_AFTER_ANNOUNCING_MS;
-      verdicts.set(one.file, { writtenAt: one.writtenAt, judgedAt: now, stranger });
-    }
+  if (toJudge.length > 0 && judging === null) {
+    judging = startTimes(toJudge.map((one) => one.pid)).then((began) => {
+      for (const one of toJudge) {
+        const at = began.get(one.pid);
+        const stranger = at !== undefined && at - one.writtenAt > STARTED_AFTER_ANNOUNCING_MS;
+        verdicts.set(one.file, { writtenAt: one.writtenAt, judgedAt: now, stranger });
+      }
+    }).catch(() => {}).finally(() => {
+      judging = null;
+    });
   }
-  return new Set(candidates.filter((one) => verdicts.get(one.file)?.stranger === true).map((one) => one.file));
+  return new Set(candidates.filter((one) => {
+    const known = verdicts.get(one.file);
+    return known?.stranger === true && known.writtenAt === one.writtenAt;
+  }).map((one) => one.file));
 }
 function announcedIn(directory) {
-  if (!existsSync9(directory)) {
+  if (!existsSync10(directory)) {
     return [];
   }
   const found = [];
   const candidates = [];
   const entries = [];
-  for (const entry of readdirSync5(directory)) {
+  for (const entry of readdirSync6(directory)) {
     const report = ERROR_REPORT_PATTERN.exec(entry);
     if (report) {
-      sweepErrorReport(join11(directory, entry), Number.parseInt(report[1] ?? "", 10));
+      sweepErrorReport(join12(directory, entry), Number.parseInt(report[1] ?? "", 10));
       continue;
     }
     const match = ANNOUNCEMENT_PATTERN.exec(entry);
     if (!match) {
       continue;
     }
-    const file = join11(directory, entry);
+    const file = join12(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
-    const alive = processAlive(pid);
-    entries.push({ file, pid, alive });
-    if (alive) {
+    const running = alive(pid);
+    entries.push({ file, pid, running });
+    if (running) {
       try {
         candidates.push({ file, pid, writtenAt: statSync4(file).mtimeMs });
       } catch {}
     }
   }
   const strangers = strangersAmong(candidates, Date.now());
-  for (const { file, pid, alive } of entries) {
-    const gone = !alive || strangers.has(file);
+  for (const { file, pid, running } of entries) {
+    const gone = !running || strangers.has(file);
     const announced = gone ? { kind: "rubbish" } : parseAnnouncement(file, pid);
     if (announced.kind === "rubbish") {
       if (!gone) {
@@ -32369,7 +32685,7 @@ function announcedIn(directory) {
     found.push(announced);
   }
   const held = new Set(entries.map((one) => one.file));
-  const here = join11(directory, ".");
+  const here = join12(directory, ".");
   for (const file of verdicts.keys()) {
     if (dirname7(file) === here && !held.has(file)) {
       verdicts.delete(file);
@@ -32378,13 +32694,13 @@ function announcedIn(directory) {
   return found;
 }
 async function announcementEnded(pid, directories = runtimeDirectories()) {
-  const files = directories.map((directory) => join11(directory, `runtime-${pid}.json`)).filter((file) => existsSync9(file));
+  const files = directories.map((directory) => join12(directory, `runtime-${pid}.json`)).filter((file) => existsSync10(file));
   const first = files[0];
   if (first === undefined) {
     return;
   }
   const until = Date.now() + ENDED_WITHIN_MS;
-  while (processAlive(pid)) {
+  while (alive(pid)) {
     const left = until - Date.now();
     if (left <= 0) {
       return;
@@ -32400,7 +32716,7 @@ async function announcementEnded(pid, directories = runtimeDirectories()) {
   }
 }
 function sweepErrorReport(path, pid, now = Date.now()) {
-  if (processAlive(pid)) {
+  if (alive(pid)) {
     return;
   }
   try {
@@ -32663,8 +32979,9 @@ function runtimeRequest(endpoint, command, params, timeoutMs, keepListening = fa
     });
   });
 }
-var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, ERROR_REPORT_PATTERN, CONSOLE_BOUNDARY = "[gdharness] runtime listening on ", ERROR_REPORT_KEEP_MS, GONE_WINDOW_MS = 120000, GONE_KEPT = 32, gone, STARTED_AFTER_ANNOUNCING_MS = 2000, CONFIRMED_FOR_MS = 60000, JUDGED_AFTER_MS = 60000, verdicts, ENDED_WITHIN_MS = 3000, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1, LATE_ANSWER_MS, LATE_KEPT = 50, lateAnswers;
+var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, ERROR_REPORT_PATTERN, CONSOLE_BOUNDARY = "[gdharness] runtime listening on ", ERROR_REPORT_KEEP_MS, GONE_WINDOW_MS = 120000, GONE_KEPT = 32, gone, STARTED_AFTER_ANNOUNCING_MS = 2000, CONFIRMED_FOR_MS = 60000, JUDGED_AFTER_MS = 60000, verdicts, judging = null, ENDED_WITHIN_MS = 3000, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1, LATE_ANSWER_MS, LATE_KEPT = 50, lateAnswers;
 var init_runtime_client = __esm(() => {
+  init_alive();
   init_paths();
   init_process_children();
   ANNOUNCEMENT_PATTERN = /^runtime-(\d+)\.json$/;
@@ -32678,9 +32995,9 @@ var init_runtime_client = __esm(() => {
 
 // src/boot-note.ts
 import { mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname8, join as join12 } from "node:path";
+import { dirname as dirname8, join as join13 } from "node:path";
 function bootNotePath(projectPath) {
-  return join12(projectPath, ".godot", "gdharness-boot.json");
+  return join13(projectPath, ".godot", "gdharness-boot.json");
 }
 function readBootNote(projectPath) {
   try {
@@ -32713,9 +33030,9 @@ var init_boot_note = __esm(() => {
 
 // src/breakpoint-note.ts
 import { mkdirSync as mkdirSync7, readFileSync as readFileSync11, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname9, isAbsolute as isAbsolute2, join as join13, relative as relative2 } from "node:path";
+import { dirname as dirname9, isAbsolute as isAbsolute2, join as join14, relative as relative2 } from "node:path";
 function breakpointNotePath(projectPath) {
-  return join13(projectPath, ".godot", "gdharness-breakpoints.json");
+  return join14(projectPath, ".godot", "gdharness-breakpoints.json");
 }
 function writeBreakpointNote(projectPath, held) {
   const path = breakpointNotePath(projectPath);
@@ -32756,7 +33073,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(join13(projectPath, script)), lines });
+        held.push({ scriptPath: realPathOr(join14(projectPath, script)), lines });
       }
     }
     return held;
@@ -32775,9 +33092,9 @@ var init_breakpoint_note = __esm(() => {
 
 // src/class-note.ts
 import { mkdirSync as mkdirSync8, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname10, join as join14 } from "node:path";
+import { dirname as dirname10, join as join15 } from "node:path";
 function classNotePath(projectPath) {
-  return join14(projectPath, ".godot", "gdharness-classes.json");
+  return join15(projectPath, ".godot", "gdharness-classes.json");
 }
 function readClassNote(projectPath) {
   try {
@@ -32806,11 +33123,11 @@ function writeClassNote(projectPath, note) {
 var init_class_note = () => {};
 
 // src/config-pin.ts
-import { existsSync as existsSync10, readFileSync as readFileSync13 } from "node:fs";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync13 } from "node:fs";
+import { join as join16 } from "node:path";
 function versionsNamedInConfig(projectPath) {
-  const config = join15(projectPath, ".mcp.json");
-  if (!existsSync10(config)) {
+  const config = join16(projectPath, ".mcp.json");
+  if (!existsSync11(config)) {
     return [];
   }
   let text;
@@ -33443,6 +33760,9 @@ class GodotDAPClient {
   isConnected() {
     return this.connected;
   }
+  connection() {
+    return this.connected ? this.socket : null;
+  }
   isStopped() {
     return this.halt !== null;
   }
@@ -33572,7 +33892,7 @@ var init_desktop = () => {};
 // src/editor-log.ts
 import {
   closeSync,
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   mkdirSync as mkdirSync9,
   openSync,
   readFileSync as readFileSync14,
@@ -33581,12 +33901,12 @@ import {
   statSync as statSync5,
   writeFileSync as writeFileSync10
 } from "node:fs";
-import { dirname as dirname11, join as join16 } from "node:path";
+import { dirname as dirname11, join as join17 } from "node:path";
 function editorLogPath(projectPath) {
-  return join16(projectPath, ".godot", "gdharness-editor.log");
+  return join17(projectPath, ".godot", "gdharness-editor.log");
 }
 function editorLogNotePath(projectPath) {
-  return join16(projectPath, ".godot", "gdharness-editor.json");
+  return join17(projectPath, ".godot", "gdharness-editor.json");
 }
 function readEditorLogNote(projectPath) {
   try {
@@ -33631,7 +33951,7 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
     return { kind: "older server", notedPid: noted?.pid ?? null };
   }
   const path = editorLogPath(projectPath);
-  if (!existsSync11(path)) {
+  if (!existsSync12(path)) {
     return { kind: "not written" };
   }
   const log = new GameLog;
@@ -38060,7 +38380,7 @@ var init_lsp_client = __esm(() => {
 });
 
 // src/outside.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function changesFrom(env, base) {
   const changes = {};
@@ -38093,7 +38413,7 @@ function readLaunched(printed) {
 }
 async function launchOutsideTheTree(spec, runtime = process.execPath, keeper = KEEPER_SCRIPT) {
   return await new Promise((resolve) => {
-    const launcher = spawn(runtime, [keeper, "launch"], {
+    const launcher = spawn2(runtime, [keeper, "launch"], {
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true
     });
@@ -38132,14 +38452,14 @@ import { execFile as execFile4 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
 async function cpuSecondsOf(pid) {
   try {
-    return process.platform === "win32" ? await askWindows2(pid) : await askPosix2(pid);
+    return process.platform === "win32" ? await secondsOnWindows(pid) : await askPosix2(pid);
   } catch {
     return;
   }
 }
-async function askWindows2(pid) {
-  const { stdout } = await run4("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `(Get-Process -Id ${pid}).CPU`], { timeout: ASK_TIMEOUT_MS2, windowsHide: true });
-  const seconds = Number(stdout.trim().replace(",", "."));
+async function secondsOnWindows(pid) {
+  const said = await askWindows(`(Get-Process -Id ${pid}).CPU`, ASK_TIMEOUT_MS2);
+  const seconds = Number(said.trim().replace(",", "."));
   return Number.isFinite(seconds) ? seconds : undefined;
 }
 async function askPosix2(pid) {
@@ -38163,17 +38483,18 @@ function secondsFromClock(printed) {
 }
 var run4, ASK_TIMEOUT_MS2 = 6000;
 var init_process_time = __esm(() => {
+  init_windows_ask();
   run4 = promisify4(execFile4);
 });
 
 // src/project-scan.ts
-import { existsSync as existsSync12, readdirSync as readdirSync6, readFileSync as readFileSync15 } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync13, readdirSync as readdirSync7, readFileSync as readFileSync15 } from "node:fs";
+import { join as join18 } from "node:path";
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
 function steppedOver(directory) {
-  return existsSync12(join17(directory, ".gdignore"));
+  return existsSync13(join18(directory, ".gdignore"));
 }
 function projectStructure(projectPath) {
   const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
@@ -38181,12 +38502,12 @@ function projectStructure(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join17(directory, entry.name));
+        visit(join18(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (extension === "tscn") {
@@ -38210,20 +38531,20 @@ function scriptsWithoutUid(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join17(directory, entry.name), spelled);
+        visit(join18(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync12(join17(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync13(join18(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -38251,14 +38572,14 @@ function searchProject(projectPath, options) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
       if (full()) {
         return;
       }
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join17(directory, entry.name);
+      const entryPath = join18(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -38299,12 +38620,12 @@ var init_project_scan = __esm(() => {
 
 // src/reimport.ts
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync13, readFileSync as readFileSync16, rmSync as rmSync8, statSync as statSync6, utimesSync, writeFileSync as writeFileSync11 } from "node:fs";
-import { basename as basename3, join as join18 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync16, rmSync as rmSync8, statSync as statSync6, utimesSync, writeFileSync as writeFileSync11 } from "node:fs";
+import { basename as basename3, join as join19 } from "node:path";
 function forceNextImport(projectPath, resourcePath) {
   const relative = resourcePath.replace(/^res:\/\//, "");
-  const sidecar = join18(projectPath, `${relative}.import`);
-  if (!existsSync13(sidecar)) {
+  const sidecar = join19(projectPath, `${relative}.import`);
+  if (!existsSync14(sidecar)) {
     return;
   }
   const { atime, mtimeMs } = statSync6(sidecar);
@@ -38314,15 +38635,15 @@ function forceNextImport(projectPath, resourcePath) {
 }
 function importRecord(projectPath, resourcePath) {
   const digest = createHash3("md5").update(resourcePath).digest("hex");
-  return join18(projectPath, ".godot", "imported", `${basename3(resourcePath)}-${digest}.md5`);
+  return join19(projectPath, ".godot", "imported", `${basename3(resourcePath)}-${digest}.md5`);
 }
 var init_reimport = () => {};
 
 // src/restart-note.ts
 import { mkdirSync as mkdirSync10, readFileSync as readFileSync17, rmSync as rmSync9, writeFileSync as writeFileSync12 } from "node:fs";
-import { dirname as dirname13, join as join19 } from "node:path";
+import { dirname as dirname13, join as join20 } from "node:path";
 function restartNotePath(projectPath) {
-  return join19(projectPath, ".godot", "gdharness-restart.json");
+  return join20(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
@@ -38361,28 +38682,29 @@ var init_restart_note = __esm(() => {
 });
 
 // src/run-record.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { execFile as execFile5 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
 import {
   mkdirSync as mkdirSync11,
   openSync as openSync2,
-  readdirSync as readdirSync7,
+  readdirSync as readdirSync8,
   readFileSync as readFileSync18,
   realpathSync as realpathSync3,
   rmSync as rmSync10,
   statSync as statSync7,
   writeFileSync as writeFileSync13
 } from "node:fs";
-import { basename as basename4, dirname as dirname14, join as join20, resolve as resolve5 } from "node:path";
+import { basename as basename4, dirname as dirname14, join as join21, resolve as resolve5 } from "node:path";
+import { promisify as promisify5 } from "node:util";
 function runsDirectory() {
-  return join20(runtimeDirectory(), "runs");
+  return join21(runtimeDirectory(), "runs");
 }
 function realAsFarAsItExists(path) {
   const missing = [];
   let at = path;
   for (;; ) {
     try {
-      return join20(realpathSync3.native(at), ...missing);
+      return join21(realpathSync3.native(at), ...missing);
     } catch {
       const parent = dirname14(at);
       if (parent === at) {
@@ -38399,15 +38721,15 @@ function projectKey(projectPath) {
   return createHash4("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join20(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join21(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 function openTranscript(startedAt) {
   mkdirSync11(runsDirectory(), { recursive: true });
-  const path = join20(runsDirectory(), `run-${startedAt}.log`);
+  const path = join21(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync2(path, "a") };
 }
 function editorNotePath(projectPath, directory = runtimeDirectory()) {
-  return join20(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join21(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
   mkdirSync11(runsDirectory(), { recursive: true });
@@ -38415,7 +38737,7 @@ function writeEditorRunNote(note) {
 }
 function readEditorRunNote(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join20(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join21(directory, "runs", "editor-run.json"));
     if (note !== null && isSameDirectory(note.projectPath, projectPath)) {
       return note;
     }
@@ -38447,7 +38769,7 @@ function readRunRecord(projectPath) {
     if (own !== null) {
       return own;
     }
-    const shared = recordAt(join20(directory, "runs", SHARED_NOTE));
+    const shared = recordAt(join21(directory, "runs", SHARED_NOTE));
     if (shared !== null && shared.projectPath !== "" && isSameDirectory(shared.projectPath, projectPath)) {
       return shared;
     }
@@ -38459,13 +38781,13 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync7(join20(directory, "runs"));
+      entries = readdirSync8(join21(directory, "runs"));
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry === SHARED_NOTE || entry.startsWith("note-") && entry.endsWith(".json")) {
-        const record = recordAt(join20(directory, "runs", entry));
+        const record = recordAt(join21(directory, "runs", entry));
         if (record !== null) {
           found.push(record);
         }
@@ -38503,49 +38825,47 @@ function recordAt(path) {
     ...typeof fields["exitSignal"] === "string" ? { exitSignal: fields["exitSignal"] } : {}
   };
 }
-function runningAs(pid) {
+async function runningAs(pid) {
   if (process.platform === "win32") {
-    const answer = windowsCommandLine(pid);
+    const answer = await windowsCommandLine(pid);
     if (answer !== null) {
       const [, ...rest] = answer.split(`
 `);
       const line = rest.join(`
 `).trim();
-      const began = startedAt(pid, answer);
+      const began = await startedAt(pid, answer);
       if (line !== "") {
         return { kind: "commandLine", text: line, ...began === null ? {} : { startedAt: began } };
       }
     }
-    const image = windowsImage(pid);
+    const image = await windowsImage(pid);
     return image === null ? null : { kind: "image", text: image };
   }
   try {
-    const began = startedAt(pid, null);
+    const began = await startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
       const raw = readFileSync18(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
-    const args = execFileSync2("ps", ["-p", String(pid), "-o", "args="], {
-      encoding: "utf8",
-      timeout: 15000
-    }).trim();
+    const args = (await execFileAsync("ps", ["-p", String(pid), "-o", "args="], { encoding: "utf8", timeout: 15000 })).stdout.trim();
     return args === "" ? null : { kind: "commandLine", text: args, ...when };
   } catch {
     return null;
   }
 }
-function listeningPid(port) {
+async function listeningPid(port) {
   try {
     if (process.platform === "win32") {
-      return listeningPidInNetstat(execFileSync2("netstat", ["-ano"], { encoding: "utf8", timeout: 15000 }), port);
+      const { stdout } = await execFileAsync("netstat", ["-ano"], { encoding: "utf8", timeout: 15000 });
+      return listeningPidInNetstat(stdout, port);
     }
     for (const [command, args, pattern] of [
       ["lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], /^(\d+)/],
       ["ss", ["-ltnpH", `sport = :${port}`], /pid=(\d+)/]
     ]) {
       try {
-        const said = execFileSync2(command, [...args], { encoding: "utf8", timeout: 15000 }).trim();
+        const said = (await execFileAsync(command, [...args], { encoding: "utf8", timeout: 15000 })).stdout.trim();
         const found = pattern.exec(said);
         if (found?.[1] !== undefined) {
           return Number(found[1]);
@@ -38570,39 +38890,31 @@ function listeningPidInNetstat(printed, port) {
   }
   return null;
 }
-function windowsCommandLine(pid) {
+async function windowsCommandLine(pid) {
   try {
-    const answer = execFileSync2("powershell", [
-      "-NoProfile",
-      "-NonInteractive",
-      "-Command",
-      `${POWERSHELL_UTF8}$p = Get-CimInstance Win32_Process -Filter "ProcessId=${pid}"; if ($p) { $p.CreationDate.ToUniversalTime().ToString("o"); $p.CommandLine }`
-    ], { encoding: "utf8", timeout: 15000, windowsHide: true }).trim();
+    const answer = (await askWindows(`$p = Get-CimInstance Win32_Process -Filter "ProcessId=${pid}"; if ($p) { $p.CreationDate.ToUniversalTime().ToString("o"); $p.CommandLine }`, 15000)).trim();
     return answer === "" ? null : answer;
   } catch {
     return null;
   }
 }
-function startedAt(pid, windowsAnswer) {
+async function startedAt(pid, windowsAnswer) {
   if (process.platform === "win32") {
     const when = Date.parse(windowsAnswer?.split(`
 `)[0]?.trim() ?? "");
     return Number.isNaN(when) ? null : when;
   }
   try {
-    const said = execFileSync2("ps", ["-p", String(pid), "-o", "lstart="], {
-      encoding: "utf8",
-      timeout: 15000
-    }).trim();
+    const said = (await execFileAsync("ps", ["-p", String(pid), "-o", "lstart="], { encoding: "utf8", timeout: 15000 })).stdout.trim();
     const when = Date.parse(said);
     return said === "" || Number.isNaN(when) ? null : when;
   } catch {
     return null;
   }
 }
-function windowsImage(pid) {
+async function windowsImage(pid) {
   try {
-    const csv = execFileSync2("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
+    const { stdout: csv } = await execFileAsync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
       encoding: "utf8",
       timeout: 15000,
       windowsHide: true
@@ -38612,11 +38924,11 @@ function windowsImage(pid) {
     return null;
   }
 }
-function stillTheRecordedRun(record) {
-  return judgeRun(record, runningAs(record.pid), "confirmed");
+async function stillTheRecordedRun(record) {
+  return judgeRun(record, await runningAs(record.pid), "confirmed");
 }
-function couldStillBeTheRecordedRun(record) {
-  return judgeRun(record, runningAs(record.pid), "possible");
+async function couldStillBeTheRecordedRun(record) {
+  return judgeRun(record, await runningAs(record.pid), "possible");
 }
 function judgeRun(record, running, needed) {
   if (running === null) {
@@ -38643,8 +38955,8 @@ function judgeRun(record, running, needed) {
   const project = process.platform === "win32" ? record.projectPath.toLowerCase() : record.projectPath;
   return said.includes(project);
 }
-function stillTheAnnouncedGame(pid, projectPath, announcedAt) {
-  return judgeAnnouncedGame(runningAs(pid), projectPath, announcedAt);
+async function stillTheAnnouncedGame(pid, projectPath, announcedAt) {
+  return judgeAnnouncedGame(await runningAs(pid), projectPath, announcedAt);
 }
 function judgeAnnouncedGame(running, projectPath, announcedAt) {
   if (running?.kind !== "commandLine" || running.startedAt === undefined) {
@@ -38661,7 +38973,7 @@ function judgeAnnouncedGame(running, projectPath, announcedAt) {
 }
 function clearRunRecord(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const shared = join20(directory, "runs", SHARED_NOTE);
+    const shared = join21(directory, "runs", SHARED_NOTE);
     const sharedRecord = recordAt(shared);
     const ours = sharedRecord !== null && sharedRecord.projectPath !== "" && isSameDirectory(sharedRecord.projectPath, projectPath);
     for (const path of [runRecordPath(projectPath, directory), ...ours ? [shared] : []]) {
@@ -38683,7 +38995,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
   const kept = new Set(everyRunRecord().map((record) => record.transcript));
   let entries;
   try {
-    entries = readdirSync7(directory);
+    entries = readdirSync8(directory);
   } catch {
     return;
   }
@@ -38691,7 +39003,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join20(directory, entry);
+    const path = join21(directory, entry);
     if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
@@ -38700,37 +39012,37 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     } catch {}
   }
 }
-var SHARED_NOTE = "run.json", SAME_RUN_WINDOW_MS = 1e4;
+var execFileAsync, SHARED_NOTE = "run.json", SAME_RUN_WINDOW_MS = 1e4;
 var init_run_record = __esm(() => {
   init_paths();
   init_process_children();
   init_runtime_client();
+  init_windows_ask();
+  execFileAsync = promisify5(execFile5);
 });
 
 // src/server.ts
-import { execFile as execFile5, spawn as spawn2 } from "node:child_process";
+import { execFile as execFile6, spawn as spawn3 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   appendFileSync,
   closeSync as closeSync2,
   constants,
   copyFileSync,
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   fstatSync,
   mkdirSync as mkdirSync12,
-  mkdtempSync as mkdtempSync2,
   openSync as openSync3,
-  readdirSync as readdirSync8,
+  readdirSync as readdirSync9,
   readFileSync as readFileSync19,
   readSync as readSync2,
   rmdirSync as rmdirSync2,
   statSync as statSync8
 } from "node:fs";
-import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename5, dirname as dirname15, extname as extname2, isAbsolute as isAbsolute3, join as join21, normalize as normalize2, relative as relative3 } from "node:path";
+import { basename as basename5, dirname as dirname15, extname as extname2, isAbsolute as isAbsolute3, join as join22, normalize as normalize2, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
-import { promisify as promisify5 } from "node:util";
+import { promisify as promisify6 } from "node:util";
 function captureDestinationRefusal(outputPath, projects) {
   if (/^(res|user):\/\//.test(outputPath)) {
     return `outputPath ${outputPath} is a Godot path; a capture is saved outside the project, at an absolute path on this machine.`;
@@ -38742,15 +39054,15 @@ function captureDestinationRefusal(outputPath, projects) {
     return `outputPath ${outputPath} does not end in .png, which is what a capture is.`;
   }
   const directory = realPathOr(dirname15(outputPath));
-  if (!existsSync14(directory)) {
+  if (!existsSync15(directory)) {
     return `outputPath's directory ${dirname15(outputPath)} does not exist; a capture creates no directories.`;
   }
-  const where = join21(directory, basename5(outputPath));
+  const where = join22(directory, basename5(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.`;
   }
-  if (existsSync14(where)) {
+  if (existsSync15(where)) {
     return `outputPath ${outputPath} already exists; a capture is not written over a file. Name a new one.`;
   }
   return null;
@@ -38906,7 +39218,8 @@ function aboutTheChildren(ended, throughEditor) {
     return throughEditor ? `Anything that game started for itself, with OS.create_process or otherwise, is not the editor's to stop and was not signalled; ${reaches}` : `Anything that game started for itself, with OS.create_process or otherwise, is a separate process this stop did not signal; ${reaches}`;
   }
   if (ended.unknown === "platform") {
-    return "andChildren was asked for and this platform would not list what the game had started, so nothing else was ended.";
+    const why = whyTheProcessTreeFailed();
+    return `andChildren was asked for and this platform would not list what the game had started, so nothing else was ended.${why === undefined ? "" : ` The listing failed: ${why}.`}`;
   }
   if (ended.unknown === "no process") {
     return "andChildren was asked for and this run has no process id to list under: the editor plays it and its game announced none, so nothing else was ended.";
@@ -38987,17 +39300,6 @@ function runtimeVerdict(endpoint, after) {
     heldAt: null
   };
 }
-function alive(pid) {
-  if (pid === undefined || pid === null) {
-    return false;
-  }
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error.code === "EPERM";
-  }
-}
 function isOfType(value, kind) {
   switch (kind) {
     case "string":
@@ -39189,13 +39491,13 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync14(join21(projectPath, wanted))) {
+  if (wanted === "" || existsSync15(join22(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
   let near = [];
   try {
-    near = readdirSync8(projectPath, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.toLowerCase() !== root).map((entry) => entry.name).filter((name) => name.toLowerCase().startsWith("test") || root.startsWith(name.toLowerCase()));
+    near = readdirSync9(projectPath, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.toLowerCase() !== root).map((entry) => entry.name).filter((name) => name.toLowerCase().startsWith("test") || root.startsWith(name.toLowerCase()));
   } catch {
     return "";
   }
@@ -39211,7 +39513,7 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync19(join21(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
+    return readFileSync19(join22(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
@@ -39236,7 +39538,7 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   mcp;
   locator = new GodotLocator;
-  operationsScript = join21(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join22(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -39248,6 +39550,7 @@ class GodotServer {
   lastGodotVersion = null;
   lspClient = null;
   dapClient = null;
+  adapterPassed = null;
   breakpointsSeededOn = null;
   bridgeStartupError = null;
   bridgeRetry = null;
@@ -39306,6 +39609,7 @@ class GodotServer {
       this.handleShutdown("stdin:end", 0);
     });
     console.error("gdharness running on stdio");
+    sweepAbandonedScratch();
     try {
       await this.takeOverFromAPredecessor();
       await this.godotBridge.start();
@@ -39632,7 +39936,7 @@ class GodotServer {
     this.callsSinceFeedback = 0;
     return {
       ...answer,
-      content: [...answer.content, { type: "text", text: feedbackNotice() }]
+      content: [...answer.content, { type: "text", text: feedbackNotice(FEEDBACK_NOTICE_EVERY) }]
     };
   }
   validateArguments(spec, args) {
@@ -39976,8 +40280,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join21(path, "project.godot");
-    if (!existsSync14(file)) {
+    const file = join22(path, "project.godot");
+    if (!existsSync15(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -40138,13 +40442,13 @@ class GodotServer {
     let sawAScan = false;
     let scanEndedAt = null;
     for (;; ) {
-      const asked = Date.now();
       let status;
       try {
         status = asParams(await this.godotBridge.invokeTool("scan_status", {}));
       } catch {
         return { waitedMs: Date.now() - started, stillScanning: false };
       }
+      const answered = Date.now();
       if (status["scanning"] === true || status["importing"] === true || status["pending"] === true) {
         sawAScan = true;
         if (Date.now() - started >= SCAN_WAIT_MS) {
@@ -40154,7 +40458,7 @@ class GodotServer {
         continue;
       }
       const since = readNumber(status, "sinceScanFinishedMs");
-      scanEndedAt = since !== undefined && since >= 0 ? asked - since : sawAScan ? asked : null;
+      scanEndedAt = since !== undefined && since >= 0 ? answered - since : sawAScan ? answered : null;
       break;
     }
     let waitedForTheWrite = false;
@@ -40573,11 +40877,11 @@ class GodotServer {
       return this.createErrorResponse(`Cannot create ${dirname15(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
-    const exportLogs = mkdtempSync2(join21(tmpdir4(), "gdharness-export-"));
+    const exportLogs = scratchDirectory("export");
     const exportArgs = [
       "--headless",
       "--log-file",
-      join21(exportLogs, "engine.log"),
+      join22(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -40609,7 +40913,7 @@ class GodotServer {
     log.finish();
     const problems = log.select({ severity: "warning", sinceLastCall: false, limit: 200 });
     const verdict = {
-      exported: ending.exitCode === 0 && log.count("error") === 0 && existsSync14(output.absolutePath),
+      exported: ending.exitCode === 0 && log.count("error") === 0 && existsSync15(output.absolutePath),
       preset,
       outputPath: output.relativePath,
       debug,
@@ -40645,7 +40949,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync14(join21(project.value.path, runner))) {
+    if (!existsSync15(join22(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"
       ]);
@@ -40681,7 +40985,7 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync2(join21(tmpdir4(), "gdharness-tests-"));
+    const userData = scratchDirectory("tests");
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const console2 = [];
     let lastSaid = Date.now();
@@ -40708,14 +41012,17 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join21(project.value.path, ".godot", ...ours.split("/"));
+    if (timedOut && run.process.pid !== undefined) {
+      await untilGone([run.process.pid]);
+    }
+    const reportsDir = join22(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync14(reportsDir) ? readdirSync8(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      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(readFileSync19(join21(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync19(join22(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -40873,7 +41180,7 @@ class GodotServer {
     const cached = cachedClasses(projectPath);
     const contradicted = cached === null ? [] : contradictedDiagnostics(messages, cached, (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
-      if (!contained.ok || !existsSync14(contained.absolutePath)) {
+      if (!contained.ok || !existsSync15(contained.absolutePath)) {
         return null;
       }
       try {
@@ -40927,7 +41234,7 @@ class GodotServer {
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
-    if (!contained.ok || !existsSync14(contained.absolutePath)) {
+    if (!contained.ok || !existsSync15(contained.absolutePath)) {
       return null;
     }
     try {
@@ -40948,28 +41255,32 @@ class GodotServer {
   async handleDAP(toolName, args) {
     return handleDAPTool(this.dap(), toolName, args);
   }
-  adapterBelongsElsewhere() {
+  async adapterBelongsElsewhere() {
     const status = this.godotBridge.getStatus();
     const ours = status.editorPid;
     if (ours === undefined) {
       return null;
     }
+    const connection = this.dapClient?.connection() ?? null;
+    if (connection !== null && this.adapterPassed?.connection === connection && this.adapterPassed.editorPid === ours) {
+      return null;
+    }
     const port = this.editorServes("dapPort", "GDHARNESS_DAP_PORT", DEFAULT_DAP_PORT);
-    const holder = listeningPid(port);
+    const askedAt = Date.now();
+    const holder = await listeningPid(port);
+    this.logDebug(`Asked who holds debug adapter port ${port} in ${Date.now() - askedAt}ms: ${holder ?? "not said"}`);
     if (holder === null || holder === ours) {
+      this.adapterPassed = connection === null ? null : { connection, editorPid: ours };
       return null;
     }
     return `The debug adapter on port ${port} belongs to process ${holder}, and the editor on this server's bridge is process ${ours}. Godot gives every editor the same debug adapter port by default, so the one this editor names in its settings is not necessarily the one it holds. Playing the game now would put another editor's console and another project's debugger under this project's name.`;
   }
-  anEditorIsStillComing(listeningSince) {
-    return anEditorIsStillComing(listeningSince, this.launchedEditorIsUp());
-  }
-  launchedEditorIsUp() {
+  async launchedEditorIsUp() {
     const launched = this.launchedEditor;
     if (launched === null || !alive(launched.pid)) {
       return false;
     }
-    const now = startTimesOf([launched.pid]).get(launched.pid);
+    const now = (await startTimesOf([launched.pid])).get(launched.pid);
     return launched.startedAt === null || now === undefined || now === launched.startedAt;
   }
   dap() {
@@ -41058,8 +41369,9 @@ class GodotServer {
     }
     return owed;
   }
-  getEditorStatusPayload() {
+  async getEditorStatusPayload() {
     const status = this.godotBridge.getStatus();
+    const launchedIsUp = !status.connected && await this.launchedEditorIsUp();
     const isPortConflict = this.bridgeStartupError?.includes("EADDRINUSE") ?? false;
     const stale = status.connected && editorIsStale(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest());
     const unfinished = this.restartLeftUnfinished(status.connected);
@@ -41068,14 +41380,14 @@ class GodotServer {
       serverVersion: SERVER_VERSION,
       addonIsStale: status.connected ? stale : undefined,
       bridgeAvailable: this.bridgeStartupError === null,
-      mayYetConnect: status.connected ? undefined : unfinished !== null ? false : this.anEditorIsStillComing(status.listeningSince),
+      mayYetConnect: status.connected ? undefined : unfinished !== null ? false : anEditorIsStillComing(status.listeningSince, launchedIsUp),
       restartInterrupted: unfinished === null ? undefined : {
         quitEditorPid: unfinished.editorPid,
         quitAt: unfinished.quitAt,
         byServerPid: unfinished.byPid,
         note: "A restart begun by a previous gdharness server asked this project's editor to quit, and that server was ended before it could start the editor again, so nothing is coming. editor_launch open starts one, and clears this."
       },
-      awaitingLaunchedEditor: status.connected || !this.launchedEditorIsUp() ? undefined : this.launchedEditor?.pid ?? undefined,
+      awaitingLaunchedEditor: status.connected || !launchedIsUp ? undefined : this.launchedEditor?.pid ?? undefined,
       ...status.connected ? this.whatTheLaunchedEditorDropped() : {},
       startupError: this.bridgeStartupError,
       portNote: status.portWanted === undefined ? undefined : `Port ${status.portWanted}, the one this server was configured with, was held ${this.notHandedOverBy === null ? "by another process" : `by pid ${this.notHandedOverBy}, the gdharness server this one replaced, which had not let go of it ${HANDOVER_MS / 1000} seconds after being told it was replaced`} when the bridge started, so it took ${status.port} and announced that where the editor looks for it${this.announcedAt === null ? "" : `, ${this.announcedAt}`}. The editor finds it there; the next server started takes ${status.portWanted} again if it is free.`,
@@ -41164,7 +41476,7 @@ class GodotServer {
     const asked = (async () => {
       const playing = await this.editorPlayingState();
       await this.pickUpWhatTheEditorIsPlaying();
-      const current = this.currentRun();
+      const current = await this.currentRun();
       const active = current === null ? false : await this.runStillGoing(current, playing?.playing ?? null);
       return {
         playing,
@@ -41172,14 +41484,15 @@ class GodotServer {
         hold: current === null ? {} : await this.holdOf(current, active)
       };
     })();
-    const [games, { playing, active, hold }, scan] = await Promise.all([
+    const [games, { playing, active, hold }, scan, editorStatus] = await Promise.all([
       pinged,
       asked,
-      this.editorScanState()
+      this.editorScanState(),
+      this.getEditorStatusPayload()
     ]);
     return this.jsonTextResponse({
       editor: {
-        ...this.getEditorStatusPayload(),
+        ...editorStatus,
         debugPort: playing?.debugPort ?? this.godotBridge.getStatus().debugPort,
         scan
       },
@@ -41209,7 +41522,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync19(join21(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync19(join22(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -41358,7 +41671,7 @@ class GodotServer {
     writeEditorLogNote(projectPath, launched.pid);
     this.launchedEditor = {
       pid: launched.pid,
-      startedAt: startTimesOf([launched.pid]).get(launched.pid) ?? null
+      startedAt: (await startTimesOf([launched.pid])).get(launched.pid) ?? null
     };
     return { pid: launched.pid, error: null };
   }
@@ -41406,13 +41719,15 @@ class GodotServer {
     }
     await this.pickUpWhatTheEditorIsPlaying();
     let ended = null;
-    const before = this.currentRun();
+    const before = await this.currentRun();
     if (before !== null && await this.runStillGoing(before)) {
       this.logDebug("Ending the running game before starting another");
+      const endingFrom = Date.now();
       ended = {
         pid: before.pid ?? this.announcedPidOf(before) ?? null,
         ending: await this.endActiveGame("editor_run start, which ends the run that was going before it starts another", true)
       };
+      this.logDebug(`The running game was ${ended.ending} after ${Date.now() - endingFrom}ms`);
     }
     const alreadyPlaying = new Set(discoverRuntimes().map((endpoint) => endpoint.pid));
     const wereHereFirst = this.everyRuntimeOfOurs();
@@ -41422,14 +41737,16 @@ class GodotServer {
     });
     const runtimeWaitMs = this.announceBudget(args, project.value.path);
     const editorWouldPlay = !headless || editorPlaysHeadless(project.value.file);
-    if (this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0 && !needsItsOwnProcess(asked.value)) {
+    const silent = resolveSilent(args["silent"], process.env) && !headless;
+    if (this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0 && !needsItsOwnProcess(asked.value) && !silent) {
       return await this.playThroughEditor(sceneArgument, refreshed.value, scanned, project.value.path, alreadyPlaying, runtimeWaitMs, ended);
     }
     const cmdArgs = runArguments({
       projectPath: project.value.path,
       headless,
       scene: sceneArgument,
-      userArgs: given.value
+      userArgs: given.value,
+      silent
     });
     this.logDebug(`Running Godot project: ${engine.value} ${cmdArgs.join(" ")}`);
     const started = await this.launchKeptGame(engine.value, cmdArgs, project.value.path, needsItsOwnProcess(asked.value) ? environmentFor({ ...asked.value, runtimeDirectory: runtimeDirectory() }) : undefined, headless || args["visible"] === true ? undefined : HIDDEN_DESKTOP);
@@ -41440,7 +41757,7 @@ class GodotServer {
     }
     started.announcedBefore = alreadyPlaying;
     this.activeProcess = started;
-    const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && given.value.length > 0 ? " The editor cannot be handed arguments for a game it plays, so this one was started " + "here: the debug_* tools answer only for a game the editor is playing." : this.godotBridge.isConnected() && editorWouldPlay && needsItsOwnProcess(asked.value) ? " The editor plays a game with its own environment, so a run given one was started " + "here: the debug_* tools answer only for a game the editor is playing." : "";
+    const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && given.value.length > 0 ? " The editor cannot be handed arguments for a game it plays, so this one was started " + "here: the debug_* tools answer only for a game the editor is playing." : this.godotBridge.isConnected() && editorWouldPlay && needsItsOwnProcess(asked.value) ? " The editor plays a game with its own environment, so a run given one was started " + "here: the debug_* tools answer only for a game the editor is playing." : this.godotBridge.isConnected() && editorWouldPlay && silent ? " The editor cannot play a game silent, which takes an engine flag, so this one was " + `started here${args["silent"] === true ? "" : ", silent because GDHARNESS_SILENT says so"}: the debug_* tools answer only for a game the editor is playing, and silent: false plays it through the editor.` : "";
     const endedForThis = endedToStartThis(ended);
     const stranded = wereHereFirst.filter((one) => one.pid !== ended?.pid && alive(one.pid));
     const alsoRunning = leftRunningNote(stranded);
@@ -41462,7 +41779,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync14(join21(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync15(join22(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
     }
     let asking = null;
@@ -41473,12 +41790,12 @@ class GodotServer {
     const lastSaid = () => editorSaysGoing ? "playing" : "not playing";
     const endpoint = await announcedSince(projectPath, before, {
       budgetMs,
-      accept: (one) => this.isTheGameOf(this.currentRun(), one, projectPath),
+      accept: (one) => this.isTheGameOf(this.activeProcess, one, projectPath),
       giveUp: () => {
         if (this.dapClient?.isStopped() === true) {
           return true;
         }
-        const run = this.currentRun();
+        const run = this.activeProcess;
         if (run === null || !run.throughEditor) {
           return !stillRunning(run);
         }
@@ -41496,7 +41813,7 @@ class GodotServer {
     });
     const asked = editorAsks === 0 ? "editor not asked" : `editor asked ${editorAsks === 1 ? "once" : `${editorAsks} times`}, last said ${lastSaid()}`;
     this.logDebug(`announce wait ended after ${Date.now() - waitBegan}ms: ${endpoint === null ? "nothing announced" : `pid ${endpoint.pid} announced`}, ${asked}`);
-    const going = this.currentRun();
+    const going = await this.currentRun();
     if (endpoint !== null && going !== null && going.announcedPid === undefined) {
       this.tie(going, endpoint);
     }
@@ -41537,8 +41854,10 @@ class GodotServer {
   }
   async playThroughEditor(scene, refreshedClasses, scanned, projectPath, alreadyPlaying, runtimeWaitMs, ended) {
     const log = new GameLog;
+    const connectingFrom = Date.now();
     try {
       await this.dap().connect();
+      this.logDebug(`The debug adapter was connected after ${Date.now() - connectingFrom}ms`);
       this.dapClient?.getOutput(true);
     } catch (error) {
       return this.createErrorResponse(`The editor is connected but its debug adapter is not: ${errorMessage(error)}`, [
@@ -41546,7 +41865,7 @@ class GodotServer {
         "GDHARNESS_DAP_PORT points this server at another one"
       ]);
     }
-    const stranger = this.adapterBelongsElsewhere();
+    const stranger = await this.adapterBelongsElsewhere();
     if (stranger !== null) {
       return this.createErrorResponse(stranger, [
         "editor_status names the editor on the bridge and the port it says it serves",
@@ -41554,7 +41873,9 @@ class GodotServer {
         "Closing the other editor, or moving its debug adapter port in its editor settings, frees this one"
       ]);
     }
+    const sendingFrom = Date.now();
     const breakpoints = await this.dapHoldingBreakpointsOf(projectPath).reapplyBreakpoints();
+    this.logDebug(`Breakpoints were sent again after ${Date.now() - sendingFrom}ms`);
     const answer = await this.handleViaBridge("play_scene", scene === null ? {} : { scenePath: `res://${scene}` });
     if (answer.isError === true) {
       return answer;
@@ -41740,13 +42061,13 @@ class GodotServer {
       arguments: [],
       ...running.command === undefined ? {} : { command: running.command }
     };
-    if (!stillTheRecordedRun(startedAs)) {
+    if (!await stillTheRecordedRun(startedAs)) {
       clearTheRecord();
       running.endedHere = null;
       running.log.record("warning", `This run was not ended here: pid ${running.pid} no longer answers as the process the run was started as, so nothing was signalled. If that process is still the game, end it yourself; if it is not, it belongs to something else.`);
       return "refused";
     }
-    const signalled = runningAs(running.pid);
+    const signalled = await runningAs(running.pid);
     const described = signalled === null ? "nothing it would name" : `${signalled.kind}: ${signalled.text}`;
     let landed = true;
     try {
@@ -41767,7 +42088,7 @@ class GodotServer {
     return gone ? "gone" : "lingering";
   }
   spawnGame(godotPath, cmdArgs, env) {
-    const child = spawn2(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
+    const child = spawn3(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
     const cancelled = callSignal();
     if (cancelled !== undefined) {
       const end = () => {
@@ -41934,8 +42255,8 @@ class GodotServer {
     }
     return run.announcedPid;
   }
-  ownGameAmong(running, projectPath) {
-    const run = this.currentRun();
+  async ownGameAmong(running, projectPath) {
+    const run = await this.currentRun();
     if (run === null || !stillRunning(run)) {
       return;
     }
@@ -41946,7 +42267,7 @@ class GodotServer {
     return its !== undefined && running.some((one) => one.pid === its) ? its : undefined;
   }
   async ownGameThroughTheTree(running, projectPath) {
-    const run = this.currentRun();
+    const run = await this.currentRun();
     if (run === null || !stillRunning(run) || run.announcedPid !== undefined) {
       return;
     }
@@ -42032,7 +42353,7 @@ class GodotServer {
     const editor = this.godotBridge.getStatus().editorPid;
     return endpoint.editorPid === undefined || endpoint.editorPid !== editor;
   }
-  adoptRecordedRun() {
+  async adoptRecordedRun() {
     const project = this.ourProject();
     const record = project === null ? null : readRunRecord(project);
     if (record === null || !this.couldBeOurs(record.projectPath)) {
@@ -42053,7 +42374,7 @@ class GodotServer {
       pickedUp: true
     };
     this.drainTranscript(adopted);
-    if (!alive(record.pid) || !couldStillBeTheRecordedRun(record)) {
+    if (!alive(record.pid) || !await couldStillBeTheRecordedRun(record)) {
       adopted.log.finish();
       adopted.exitCode = record.exitCode ?? null;
       adopted.exitSignal = record.exitSignal ?? null;
@@ -42134,8 +42455,8 @@ class GodotServer {
     const status = this.godotBridge.getStatus();
     return this.ownProject ?? (status.connected ? status.projectPath ?? null : null);
   }
-  currentRun() {
-    return this.activeProcess ?? this.adoptRecordedRun();
+  async currentRun() {
+    return this.activeProcess ?? await this.adoptRecordedRun();
   }
   async checkBoot(godotPath, projectPath, scene, args, userArgs, scanned, asked = {}) {
     const frames = readPositiveNumber(args, "frames") ?? 3;
@@ -42174,10 +42495,14 @@ class GodotServer {
   }
   async handleWaitForRun(args) {
     await this.pickUpWhatTheEditorIsPlaying();
-    const run = this.currentRun();
+    const run = await this.currentRun();
     if (!run) {
       return this.createErrorResponse(this.nothingOfOursIsRunning());
     }
+    const elsewhere = this.anotherProjectsRun(run.projectPath, args, "waited on");
+    if (elsewhere !== null) {
+      return elsewhere;
+    }
     const budgetMs = readPositiveNumber(args, "timeoutMs") ?? WAIT_FOR_RUN_MS;
     const until = Date.now() + budgetMs;
     const cancelled = callSignal();
@@ -42224,7 +42549,7 @@ class GodotServer {
       await delay3(50);
     }
   }
-  handleEditorConsole(args) {
+  async handleEditorConsole(args) {
     const status = this.godotBridge.getStatus();
     const projectPath = status.projectPath ?? this.ownProject ?? undefined;
     if (projectPath === undefined) {
@@ -42261,10 +42586,11 @@ class GodotServer {
     const filtered = severity !== "info" || contains !== undefined;
     const grouped = bursts(everything, readNonNegativeNumber(args, "before") ?? 3, filtered ? (entry) => answersTo(entry, severity, contains) : undefined);
     const shown = grouped.slice(0, MOST_GROUPS);
+    const stillComing = !status.connected && await this.launchedEditorIsUp();
     return this.jsonTextResponse({
       editorPid: editorPid ?? undefined,
       projectPath,
-      ...status.connected ? {} : this.launchedEditorIsUp() ? { stillConnecting: true } : { exitedBeforeConnecting: true },
+      ...status.connected ? {} : stillComing ? { stillConnecting: true } : { exitedBeforeConnecting: true },
       capturedIn: console2.path,
       ...console2.of === undefined ? {} : {
         readFromTheStart: console2.readBytes,
@@ -42288,7 +42614,7 @@ class GodotServer {
       return this.handleEditorConsole(args);
     }
     await this.pickUpWhatTheEditorIsPlaying();
-    const run = this.currentRun();
+    const run = await this.currentRun();
     if (!run) {
       return this.createErrorResponse(this.nothingOfOursIsRunning());
     }
@@ -42327,7 +42653,7 @@ class GodotServer {
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync14(join21(run.projectPath, RUNTIME_AUTOLOAD.path)),
+        couldAnnounce: run.projectPath !== null && existsSync15(join22(run.projectPath, RUNTIME_AUTOLOAD.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -42365,16 +42691,27 @@ class GodotServer {
       entries: forAnswer(selected.entries)
     });
   }
+  anotherProjectsRun(runsProject, args, act) {
+    const named = readNonEmptyString(args, "projectPath");
+    if (named === undefined || runsProject === null || isSameDirectory(runsProject, named)) {
+      return null;
+    }
+    return this.createErrorResponse(`The run this server holds is of ${runsProject}, not ${named}, so nothing was ${act}. A run of ${named} is held by the server that started it, in that project's own session.`);
+  }
   async handleStopProject(args) {
     await this.pickUpWhatTheEditorIsPlaying();
-    const stopped = this.currentRun();
+    const stopped = await this.currentRun();
     const named = readNumber(args, "pid");
     if (named !== undefined && (stopped === null || named !== stopped.pid && named !== this.announcedPidOf(stopped))) {
-      return await this.stopAnnouncedGame(named, readBoolean(args, "andChildren") === true);
+      return await this.stopAnnouncedGame(named, readBoolean(args, "andChildren") === true, args);
     }
     if (!stopped) {
       return this.createErrorResponse(this.nothingOfOursIsRunning());
     }
+    const elsewhere = this.anotherProjectsRun(stopped.projectPath, args, "stopped");
+    if (elsewhere !== null) {
+      return elsewhere;
+    }
     this.drainEditorOutput(stopped);
     this.drainTranscript(stopped);
     const wasRunning = await this.runStillGoing(stopped);
@@ -42416,16 +42753,22 @@ class GodotServer {
       entries: forAnswer(stopped.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries)
     });
   }
-  async stopAnnouncedGame(pid, andChildren) {
+  async stopAnnouncedGame(pid, andChildren, args) {
     const announced = runtimesAnnounced();
     const game = [
       ...this.allAnnouncedForOurProject(announced.running),
       ...this.allAnnouncedForOurProject(announced.unspoken)
     ].find((one) => one.pid === pid);
+    if (game !== undefined) {
+      const elsewhere = this.anotherProjectsRun(game.project.path, args, "signalled");
+      if (elsewhere !== null) {
+        return elsewhere;
+      }
+    }
     if (game === undefined) {
       return this.createErrorResponse(`pid ${pid} is not a game announced for this project, so nothing was signalled. editor_status lists this project's games under runtimes. A game that announces no runtime is ended by the server holding its run, or with andChildren by a stop of the run that started it.`);
     }
-    const read = game.announcedAt === undefined ? null : stillTheAnnouncedGame(pid, game.project.path, game.announcedAt);
+    const read = game.announcedAt === undefined ? null : await stillTheAnnouncedGame(pid, game.project.path, game.announcedAt);
     if (read === null) {
       return this.createErrorResponse(`pid ${pid} announced itself as a game of this project, but the operating system does not describe it as this project's engine run started before that announcement (the engine with --path on the project and no editor flag), so nothing was signalled. If it is still the game, runtime_invoke can ask it to quit.`);
     }
@@ -42623,6 +42966,8 @@ class GodotServer {
     }
     const checked = busy ? { unseen: [] } : await this.classesTheEditorCannotSee(args);
     const unseen = checked.unseen;
+    const broughtIn = blind.unseen.map((one) => one.className).filter((name) => !unseen.some((still) => still.className === name));
+    const dependents = busy || projectPath === "" || broughtIn.length === 0 ? null : await this.reloadDependents(projectPath, broughtIn);
     const stillGone = lost.filter((name) => !restored.includes(name));
     const notes = [];
     if (busy) {
@@ -42634,13 +42979,16 @@ class GodotServer {
     } else if (unseen.length > 0) {
       notes.push("The scan finished and these classes are still not in the list the editor resolves against, so every use of them reads as an unknown identifier. Its walk skips a file another engine has already imported. Rescan again on its own, which is the measured cure and needs no change to the declaring script, or restart the editor with editor_launch restart.");
     }
+    if (dependents !== null && dependents.notReloaded.length > 0) {
+      notes.push(`The scan brought in ${broughtIn.join(", ")}, and ${dependents.notReloaded.map((one) => one.scriptPath).join(", ")} ${dependents.notReloaded.length === 1 ? "names one of them and" : "name them and"} could not be reloaded, so the editor still holds what it compiled while it could not see the class and reports that to the language server. editor_rescan with reloadScript on each, or editor_launch restart.`);
+    }
     if (stillAtMissingPaths.length > 0) {
       notes.push(`The scan wrote the class cache with ${stillAtMissingPaths.join(", ")} at a path that is not on disk, and rebuilding the cache from the files did not take it out. The next engine to read the cache fails on "Could not parse global class" in whichever correct script shares the bare name. Restart the editor with editor_launch restart, then run project_import refresh_classes.`);
     } else if (dropped.length > 0) {
       notes.push(`The scan wrote the class cache from the list this editor is holding, and that list still has ${dropped.join(", ")} for a script that is gone, so the cache was rebuilt from the files without it. The editor goes on holding it and writes it back on every scan until it is restarted with editor_launch restart; until then a scan is followed by this same rebuild.`);
     }
     return this.jsonTextResponse({
-      ok: !busy && unseen.length === 0 && stillGone.length === 0 && stillAtMissingPaths.length === 0 && checked.unchecked === undefined,
+      ok: !busy && unseen.length === 0 && stillGone.length === 0 && stillAtMissingPaths.length === 0 && (dependents === null || dependents.notReloaded.length === 0) && checked.unchecked === undefined,
       stillWorking: busy,
       waitedMs: Date.now() - started,
       waitedForEditorScanMs: waitedForEditorMs > 0 ? waitedForEditorMs : undefined,
@@ -42648,6 +42996,9 @@ class GodotServer {
       reloadedMethods: reloaded.methods,
       reloadProblem: reloaded.problem,
       unseenByEditor: unseen.length > 0 ? unseen : undefined,
+      broughtIn: broughtIn.length > 0 ? broughtIn : undefined,
+      dependentsReloaded: dependents !== null && dependents.reloaded.length > 0 ? dependents.reloaded : undefined,
+      dependentsNotReloaded: dependents !== null && dependents.notReloaded.length > 0 ? dependents.notReloaded : undefined,
       cacheLost: lost.length > 0 ? lost : undefined,
       cacheRestored: restored.length > 0 ? restored : undefined,
       cacheDropped: dropped.length > 0 ? dropped : undefined,
@@ -42656,6 +43007,33 @@ class GodotServer {
       note: notes.length > 0 ? notes.join(" ") : undefined
     });
   }
+  async reloadDependents(projectPath, classes) {
+    const reloaded = [];
+    const notReloaded = [];
+    for (const { script: scriptPath, tool } of scriptsNaming(projectPath, classes)) {
+      if (tool) {
+        notReloaded.push({
+          scriptPath,
+          problem: "a @tool script, which runs inside the editor, so it is not reloaded from here; editor_launch restart recompiles it"
+        });
+        continue;
+      }
+      try {
+        const answer = asParams(await this.godotBridge.invokeTool("reload_script", { scriptPath }));
+        if (readArray(answer, "methods") === undefined) {
+          notReloaded.push({
+            scriptPath,
+            problem: "the editor would not say what it has after reloading it"
+          });
+        } else {
+          reloaded.push(scriptPath);
+        }
+      } catch (error) {
+        notReloaded.push({ scriptPath, problem: errorMessage(error) });
+      }
+    }
+    return { reloaded, notReloaded };
+  }
   async rebuildCacheAfterLoss(projectPath, lost) {
     if (projectPath === "") {
       return [];
@@ -42838,9 +43216,9 @@ class GodotServer {
     return { heldAt: undefined, heldUnknown: true, heldNote: reply.message };
   }
   async ownRunOnItsWay(projectPath, budgetMs) {
-    const run = this.currentRun();
+    const run = await this.currentRun();
     const project = projectPath ?? run?.projectPath ?? null;
-    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync14(join21(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync15(join22(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -42866,8 +43244,8 @@ class GodotServer {
     }
     const endpoint = await announcedSince(project, new Set(already.map((one) => one.pid)), {
       budgetMs: Math.min(budgetMs, remaining),
-      accept: (one) => this.isTheGameOf(this.currentRun(), one, project),
-      giveUp: () => this.currentRun() !== run || this.dapClient?.isStopped() === true || !stillRunning(run)
+      accept: (one) => this.isTheGameOf(this.activeProcess, one, project),
+      giveUp: () => this.activeProcess !== run || this.dapClient?.isStopped() === true || !stillRunning(run)
     });
     if (endpoint !== null) {
       const tiedMeanwhile = () => run.announcedPid !== undefined;
@@ -42876,7 +43254,7 @@ class GodotServer {
       }
       return null;
     }
-    if (this.currentRun() !== run || !await this.runStillGoing(run)) {
+    if (await this.currentRun() !== run || !await this.runStillGoing(run)) {
       return null;
     }
     return `The game this server started (${which}) is still coming up and has not announced its runtime after a wait of ${Math.min(budgetMs, remaining)}ms, so there is nothing to talk to yet. It is still running: ask again in a moment rather than starting another.`;
@@ -42892,7 +43270,7 @@ class GodotServer {
     }
     const announced = runtimesAnnounced();
     const wanted = typeof projectPath === "string" ? projectPath : this.ownProject ?? undefined;
-    const own = typeof pid === "number" ? undefined : this.ownGameAmong(announced.running, wanted) ?? await this.ownGameThroughTheTree(announced.running, wanted);
+    const own = typeof pid === "number" ? undefined : await this.ownGameAmong(announced.running, wanted) ?? await this.ownGameThroughTheTree(announced.running, wanted);
     const choice = chooseRuntime(announced.running, wanted, announced.unspoken, typeof pid === "number" ? pid : own);
     if ("problem" in choice) {
       return this.createErrorResponse(choice.problem);
@@ -42919,8 +43297,8 @@ class GodotServer {
         return this.createErrorResponse(refusal);
       }
     }
-    const screenshotDir = expectsScreenshot ? mkdtempSync2(join21(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join21(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
+    const screenshotPath = screenshotDir ? join22(screenshotDir, "capture.png") : null;
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs, !expectsScreenshot);
       if (!reply.ok && reply.requestId !== undefined) {
@@ -43066,6 +43444,7 @@ var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();
   init_types();
+  init_alive();
   init_boot_note();
   init_breakpoint_note();
   init_bridge_announce();
@@ -43101,7 +43480,7 @@ var init_server3 = __esm(() => {
   init_setup();
   init_tool_definitions();
   init_update_check();
-  run5 = promisify5(execFile5);
+  run5 = promisify6(execFile6);
   __dirname2 = dirname15(fileURLToPath5(import.meta.url));
   CONSOLE_WRAPPER = /_console(\.exe)?$/i;
   LONGEST_BOOT_NOTED_MS = 5 * 60000;
@@ -43151,14 +43530,14 @@ var init_server3 = __esm(() => {
 init_bridge_announce();
 init_errors();
 init_godot_path();
-import { existsSync as existsSync15 } from "node:fs";
-import { join as join22, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync16 } from "node:fs";
+import { join as join23, resolve as resolve6 } from "node:path";
 
 // src/harnesses.ts
 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 dirname3, join as join4 } from "node:path";
-import process3 from "node:process";
+import process4 from "node:process";
 
 // node_modules/yaml/dist/index.js
 var composer = require_composer();
@@ -43726,12 +44105,12 @@ var HARNESSES = [
   }
 ];
 function appDataRoot() {
-  return process3.env["APPDATA"] ?? join4(homedir2(), "AppData", "Roaming");
+  return process4.env["APPDATA"] ?? join4(homedir2(), "AppData", "Roaming");
 }
 function homePath(path) {
   return typeof path === "string" ? join4(homedir2(), path) : join4(appDataRoot(), path.appData);
 }
-function fileFor(harness, platform = process3.platform) {
+function fileFor(harness, platform = process4.platform) {
   if (typeof harness.file === "string") {
     return harness.file;
   }
@@ -43744,7 +44123,7 @@ function configPath(harness, projectPath) {
   }
   return homePath(file);
 }
-function displayPath(harness, platform = process3.platform) {
+function displayPath(harness, platform = process4.platform) {
   const file = fileFor(harness, platform);
   if (typeof file !== "string") {
     return `%APPDATA%/${file.appData.replaceAll("\\", "/")}`;
@@ -44022,10 +44401,10 @@ init_headless();
 init_issues();
 
 // src/prompt.ts
-import process5 from "node:process";
+import process8 from "node:process";
 import { createInterface } from "node:readline/promises";
 function interactive() {
-  return process5.stdin.isTTY && process5.stdout.isTTY;
+  return process8.stdin.isTTY && process8.stdout.isTTY;
 }
 
 class Ask {
@@ -44034,7 +44413,7 @@ class Ask {
     if (!interactive()) {
       return fallback;
     }
-    this.line ??= createInterface({ input: process5.stdin, output: process5.stdout });
+    this.line ??= createInterface({ input: process8.stdin, output: process8.stdout });
     const answer = (await this.line.question(`${question} ${fallback ? "[Y/n]" : "[y/N]"} `)).trim();
     return answer === "" ? fallback : answer.toLowerCase().startsWith("y");
   }
@@ -44051,8 +44430,8 @@ init_setup();
 // src/skill.ts
 init_setup();
 init_tool_definitions();
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync4, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "node:fs";
-import { basename as basename2, dirname as dirname5, join as join9 } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readdirSync as readdirSync5, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { basename as basename2, dirname as dirname5, join as join10 } from "node:path";
 
 // src/tool-reference.ts
 init_headless_operations();
@@ -44148,7 +44527,7 @@ function renderToolsMarkdown() {
 
 // src/skill.ts
 var SKILL_NAME = "gdharness";
-var SHARED_SKILLS = join9(".agents", "skills");
+var SHARED_SKILLS = join10(".agents", "skills");
 function skillMarkdown(version) {
   return `---
 name: ${SKILL_NAME}
@@ -44226,6 +44605,8 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | Answer a dialog | \`runtime_input click\` on its button, or \`runtime_input key\` with \`keycode\` \`Escape\` to dismiss it: an [AcceptDialog] reads that key itself and never asks the InputMap, so \`ui_cancel\` leaves it standing |
 | Press a bound key | \`runtime_input action\` with the action's name, or \`runtime_input key\` with \`keycode\`, a whole press unless you hold it |
 | Where a 3D node is on screen | \`runtime_inspect\` \`rect\`, rather than unprojecting by hand |
+| Wait for whichever of several screens comes next | \`runtime_wait until\` with \`says\` naming each, separated by \`|\`: \`"*won*|*lost*|*turn 3*"\` is met by the first of them to appear. Read as one glob, the bars were characters no screen says and the wait ran out its whole timeout |
+| Ask the game a question its own code answers | \`runtime_invoke call\` on the method that answers it, reached through what a node holds (\`_ladder:encounter:opponent:most_answered\`), with object arguments given as paths to what the game holds and a list of paths for a list: the game's own rules answer, in the running game, before anything is committed |
 | Wait for something in a running game | \`runtime_wait\`, never a sleep; \`until\` with \`says\` for a panel that rebuilds its own labels. The words have to be shown: a button that exists hidden through an animation does not satisfy it until it appears, unless \`includeHidden\` says otherwise |
 | What every label on a screen says | \`runtime_inspect tree\` with \`properties\` naming \`text\`, which reads it off every node that has one; \`includeProperties\` is every stored property of every node and ran to seventy-six thousand characters for one row |
 | Whether this engine has a method or property, and what it takes | \`editor_classes info\` with \`member\`, which answers that one member and which class declares it rather than the whole class |
@@ -44337,27 +44718,27 @@ whatever the engine said on stderr comes back under \`engine_messages\`.
 function skillFiles(version) {
   return new Map([
     ["SKILL.md", skillMarkdown(version)],
-    [join9("references", "tools.md"), renderToolsMarkdown()]
+    [join10("references", "tools.md"), renderToolsMarkdown()]
   ]);
 }
 function skillDirectories(harnesses, projectPath, exists) {
-  const directories = [join9(projectPath, SHARED_SKILLS, SKILL_NAME)];
+  const directories = [join10(projectPath, SHARED_SKILLS, SKILL_NAME)];
   for (const harness of harnesses) {
     if (harness.skills === undefined) {
       continue;
     }
-    const own = join9(projectPath, harness.skills.dir);
-    if ((!harness.skills.shared || exists(own)) && !directories.includes(join9(own, SKILL_NAME))) {
-      directories.push(join9(own, SKILL_NAME));
+    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));
     }
   }
   return directories;
 }
 function everySkillDirectory(projectPath, harnesses) {
-  const directories = new Set([join9(projectPath, SHARED_SKILLS, SKILL_NAME)]);
+  const directories = new Set([join10(projectPath, SHARED_SKILLS, SKILL_NAME)]);
   for (const harness of harnesses) {
     if (harness.skills !== undefined) {
-      directories.add(join9(projectPath, harness.skills.dir, SKILL_NAME));
+      directories.add(join10(projectPath, harness.skills.dir, SKILL_NAME));
     }
   }
   return [...directories];
@@ -44365,7 +44746,7 @@ function everySkillDirectory(projectPath, harnesses) {
 function removeSkill(directories, projectPath) {
   const removed = [];
   for (const directory of directories) {
-    if (existsSync8(directory)) {
+    if (existsSync9(directory)) {
       rmSync5(directory, { recursive: true, force: true });
       pruneEmpty(dirname5(directory), projectPath);
       removed.push(directory);
@@ -44374,10 +44755,10 @@ function removeSkill(directories, projectPath) {
   return removed;
 }
 function pruneEmpty(directory, projectPath) {
-  const shared = join9(projectPath, ".agents");
+  const shared = join10(projectPath, ".agents");
   let path = directory;
   while (path !== projectPath && (basename2(path) === "skills" || path === shared)) {
-    if (readdirSync4(path).length > 0) {
+    if (readdirSync5(path).length > 0) {
       return;
     }
     rmSync5(path, { recursive: true, force: true });
@@ -44387,10 +44768,10 @@ function pruneEmpty(directory, projectPath) {
 function writeSkill(directories, version) {
   const files = skillFiles(version);
   return directories.map((directory) => {
-    const replaced = existsSync8(directory);
+    const replaced = existsSync9(directory);
     rmSync5(directory, { recursive: true, force: true });
     for (const [name, contents] of files) {
-      const path = join9(directory, name);
+      const path = join10(directory, name);
       mkdirSync5(dirname5(path), { recursive: true });
       writeFileSync6(path, contents, "utf8");
     }
@@ -44400,13 +44781,13 @@ function writeSkill(directories, version) {
 
 // src/version.ts
 import { readFileSync as readFileSync8 } from "node:fs";
-import { dirname as dirname6, join as join10 } from "node:path";
+import { dirname as dirname6, join as join11 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function getLocalVersion() {
   const currentDirectory = dirname6(fileURLToPath2(import.meta.url));
   const packageCandidates = [
-    join10(currentDirectory, "..", "package.json"),
-    join10(currentDirectory, "..", "..", "package.json")
+    join11(currentDirectory, "..", "package.json"),
+    join11(currentDirectory, "..", "..", "package.json")
   ];
   for (const packagePath of packageCandidates) {
     try {
@@ -44428,7 +44809,7 @@ class UsageError extends Refusal {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve6(named ?? ".");
-  if (!existsSync15(join22(projectPath, "project.godot"))) {
+  if (!existsSync16(join23(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -44467,7 +44848,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync15(join22(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync16(join23(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}`);
   }
 }
@@ -44599,7 +44980,7 @@ async function setup() {
       console.log("no harness configured; name one yourself, and gdharness harnesses lists them all");
     }
     if (!args.includes("--no-skill")) {
-      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync15);
+      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync16);
       for (const written of writeSkill(directories, getLocalVersion())) {
         console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
       }
@@ -44693,7 +45074,7 @@ async function upgrade() {
       moved.push(took.from);
     }
   }
-  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync15), version)) {
+  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync16), version)) {
     console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
   }
   console.log(`
@@ -44702,7 +45083,7 @@ 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.");
-  const serving = serverServing(projectPath);
+  const serving = await 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) {