gdharness 1.1.13 → 1.1.15

package/build/index.js

@@ -10084,9 +10084,10 @@ function markIfStale(answer, addonVersion, serverVersion, addonDigest, shippedDi
 // src/issues.ts
 var NEW_ISSUE = "https://github.com/Aureliolo/gdharness/issues/new";
 var ENHANCEMENT_URL = `${NEW_ISSUE}?template=feature_request.md`;
-function feedbackNotice() {
+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
     }
@@ -10200,29 +10201,27 @@ function defectReport(where, error, context = {}) {
 }
 
 // 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 existsSync11,
+  existsSync as existsSync12,
   fstatSync,
   mkdirSync as mkdirSync10,
-  mkdtempSync as mkdtempSync2,
   openSync as openSync3,
-  readdirSync as readdirSync7,
+  readdirSync as readdirSync8,
   readFileSync as readFileSync17,
   readSync as readSync2,
   rmdirSync as rmdirSync2,
   statSync as statSync8
 } from "node:fs";
-import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename4, dirname as dirname11, extname as extname2, isAbsolute as isAbsolute3, join as join17, normalize as normalize2, relative as relative3 } from "node:path";
+import { basename as basename4, dirname as dirname11, extname as extname2, isAbsolute as isAbsolute3, join as join18, normalize as normalize2, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
-import { promisify as promisify5 } from "node:util";
+import { promisify as promisify6 } from "node:util";
 
 // node_modules/zod/v3/helpers/util.js
 var util;
@@ -24787,6 +24786,20 @@ class StdioServerTransport {
   }
 }
 
+// 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";
+  }
+}
+
 // src/boot-note.ts
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname as dirname2, join as join3 } from "node:path";
@@ -24812,8 +24825,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));
   }
@@ -24923,12 +24946,161 @@ function resolveWithinProject(projectPath, candidatePath) {
 }
 
 // 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";
+
+// src/windows-ask.ts
+import { spawn } from "node:child_process";
+import process6 from "node:process";
+var 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(`
+`);
+
+class WindowsAskFailure extends Error {
+  constructor(how) {
+    super(`PowerShell ${how}`);
+  }
+}
+var helper = null;
+var buffered = "";
+var next = 1;
+var out = null;
+var queued = [];
+var held = false;
+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 (process6.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();
+    }
+  });
+}
+
+// src/process-children.ts
 var run = promisify(execFile);
-var POWERSHELL_UTF8 = "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; ";
-function startTimesOf(pids) {
+async function startTimesOf(pids) {
   const began = new Map;
   if (pids.length === 0) {
     return began;
@@ -24936,12 +25108,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);
@@ -24951,11 +25118,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);
@@ -24967,18 +25133,41 @@ 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);
+    });
+  });
+}
 var ASK_TIMEOUT_MS = 15000;
 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;
   }
 }
 var lastListingFailure;
+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/)) {
@@ -25108,14 +25297,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="], {
@@ -25234,14 +25417,6 @@ function reportAlreadyInTranscript(transcript, report) {
   return end <= report.length && report.subarray(boundary, end).equals(copied) ? end : report.length;
 }
 var ERROR_REPORT_KEEP_MS = 60 * 60 * 1000;
-function processAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error.code === "EPERM";
-  }
-}
 function parseAnnouncement(file, pid) {
   let fields;
   try {
@@ -25328,6 +25503,7 @@ var STARTED_AFTER_ANNOUNCING_MS = 2000;
 var CONFIRMED_FOR_MS = 60000;
 var JUDGED_AFTER_MS = 60000;
 var verdicts = new Map;
+var judging = null;
 function strangersAmong(candidates, now, startTimes = startTimesOf) {
   const toJudge = candidates.filter((one) => {
     if (now - one.writtenAt < JUDGED_AFTER_MS) {
@@ -25336,15 +25512,21 @@ 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 (!existsSync2(directory)) {
@@ -25365,17 +25547,17 @@ function announcedIn(directory) {
     }
     const file = join2(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: statSync(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) {
@@ -25407,7 +25589,7 @@ async function announcementEnded(pid, directories = runtimeDirectories()) {
     return;
   }
   const until = Date.now() + ENDED_WITHIN_MS;
-  while (processAlive(pid)) {
+  while (alive(pid)) {
     const left = until - Date.now();
     if (left <= 0) {
       return;
@@ -25423,7 +25605,7 @@ async function announcementEnded(pid, directories = runtimeDirectories()) {
   }
 }
 function sweepErrorReport(path, pid, now = Date.now()) {
-  if (processAlive(pid)) {
+  if (alive(pid)) {
     return;
   }
   try {
@@ -25853,6 +26035,15 @@ import { join as join6 } from "node:path";
 var DECLARATION = /^(?:@[a-z_]+(?:\([^)\n]*\))?\s+)*class_name\s+([A-Za-z_][A-Za-z0-9_]*)/m;
 function declaredClasses(projectPath) {
   const declared = new Map;
+  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 (existsSync3(join6(directory, ".gdignore"))) {
       return;
@@ -25865,15 +26056,53 @@ function declaredClasses(projectPath) {
       if (entry.isDirectory()) {
         visit(path, `${prefix}${entry.name}/`);
       } else if (entry.isFile() && entry.name.endsWith(".gd")) {
-        const found = DECLARATION.exec(readFileSync7(path, "utf8"));
-        if (found?.[1]) {
-          declared.set(found[1], `res://${prefix}${entry.name}`);
-        }
+        each(`res://${prefix}${entry.name}`, readFileSync7(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 = join6(projectPath, ".godot", "global_script_class_cache.cfg");
@@ -26697,6 +26926,9 @@ class GodotDAPClient {
   isConnected() {
     return this.connected;
   }
+  connection() {
+    return this.connected ? this.socket : null;
+  }
   isStopped() {
     return this.halt !== null;
   }
@@ -27837,14 +28069,48 @@ class GodotLocator {
 
 // src/headless.ts
 import { execFile as execFile3 } from "node:child_process";
-import { mkdtempSync, writeFileSync as writeFileSync7 } from "node:fs";
-import { tmpdir as tmpdir3 } from "node:os";
-import { join as join11 } from "node:path";
+import { writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join12 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 
 // src/scratch.ts
-import { rmSync as rmSync4 } from "node:fs";
-var SWEPT = { recursive: true, force: true, maxRetries: 20, retryDelay: 250 };
+import { existsSync as existsSync8, mkdtempSync, readdirSync as readdirSync4, rmSync as rmSync4 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join11 } from "node:path";
+import process7 from "node:process";
+var SWEPT = { recursive: true, force: true };
+var AGAIN_AFTER_MS = [250, 500, 1000, 2000, 4000, 8000, 16000];
+var waiting = new Set;
+var atExit = new Set;
+var KINDS = [
+  "desktop",
+  "export",
+  "import",
+  "params",
+  "runtime-screenshot",
+  "tests"
+];
+function scratchDirectory(kind) {
+  return mkdtempSync(join11(tmpdir3(), `gdharness-${kind}-${process7.pid}-`));
+}
+function sweepAbandonedScratch(directory = tmpdir3()) {
+  let entries;
+  try {
+    entries = readdirSync4(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(join11(directory, entry));
+    } catch {}
+  }
+}
 function discardWith(remove, paths) {
   const left = [];
   for (const path of paths) {
@@ -27860,9 +28126,54 @@ function discardWith(remove, paths) {
   return left;
 }
 function discard(...paths) {
-  return discardWith((path) => {
-    rmSync4(path, SWEPT);
-  }, paths);
+  const left = discardWith(remove, paths);
+  for (const { path } of left) {
+    tryAgain(path, 0);
+  }
+  return left;
+}
+function remove(path) {
+  rmSync4(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 || !existsSync8(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 lastTryWatched = false;
+function lastTryOnExit() {
+  if (lastTryWatched) {
+    return;
+  }
+  lastTryWatched = true;
+  process7.once("exit", () => {
+    for (const path of [...waiting, ...atExit]) {
+      try {
+        remove(path);
+      } catch {}
+    }
+  });
 }
 
 // src/headless.ts
@@ -27905,9 +28216,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(join11(tmpdir3(), "gdharness-import-"));
+  const logDir = scratchDirectory("import");
   try {
-    const { stderr } = await run3(godotPath, ["--headless", "--log-file", join11(logDir, "engine.log"), "--path", projectPath, "--import"], { signal: callSignal() });
+    const { stderr } = await run3(godotPath, ["--headless", "--log-file", join12(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) {
@@ -27928,13 +28239,13 @@ async function runImport(godotPath, projectPath) {
   }
 }
 async function runOperation(engine, operation, params, projectPath) {
-  const paramsDir = mkdtempSync(join11(tmpdir3(), "gdharness-params-"));
-  const paramsFile = join11(paramsDir, `${operation}.json`);
+  const paramsDir = scratchDirectory("params");
+  const paramsFile = join12(paramsDir, `${operation}.json`);
   writeFileSync7(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
     "--log-file",
-    join11(paramsDir, "engine.log"),
+    join12(paramsDir, "engine.log"),
     "--path",
     projectPath,
     "--script",
@@ -28888,7 +29199,7 @@ async function handleLSPTool(client, toolName, args) {
 }
 
 // src/outside.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function changesFrom(env, base) {
   const changes = {};
@@ -28922,7 +29233,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
     });
@@ -28959,14 +29270,14 @@ var run4 = promisify4(execFile4);
 var ASK_TIMEOUT_MS2 = 6000;
 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) {
@@ -28990,14 +29301,14 @@ function secondsFromClock(printed) {
 }
 
 // src/project-scan.ts
-import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync11 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync9, readdirSync as readdirSync5, readFileSync as readFileSync11 } from "node:fs";
+import { join as join13 } from "node:path";
 var SKIPPED = new Set(["node_modules"]);
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
 function steppedOver(directory) {
-  return existsSync8(join12(directory, ".gdignore"));
+  return existsSync9(join13(directory, ".gdignore"));
 }
 var ASSET_EXTENSIONS = new Set(["png", "jpg", "jpeg", "webp", "svg", "ttf", "otf", "wav", "mp3", "ogg"]);
 function projectStructure(projectPath) {
@@ -29006,12 +29317,12 @@ function projectStructure(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join12(directory, entry.name));
+        visit(join13(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (extension === "tscn") {
@@ -29036,20 +29347,20 @@ function scriptsWithoutUid(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join12(directory, entry.name), spelled);
+        visit(join13(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync8(join12(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync9(join13(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -29077,14 +29388,14 @@ function searchProject(projectPath, options) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
       if (full()) {
         return;
       }
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join12(directory, entry.name);
+      const entryPath = join13(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -29119,12 +29430,12 @@ function searchProject(projectPath, options) {
 
 // src/reimport.ts
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync9, readFileSync as readFileSync12, rmSync as rmSync5, statSync as statSync5, utimesSync, writeFileSync as writeFileSync8 } from "node:fs";
-import { basename as basename2, join as join13 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync12, rmSync as rmSync5, statSync as statSync5, utimesSync, writeFileSync as writeFileSync8 } from "node:fs";
+import { basename as basename2, join as join14 } from "node:path";
 function forceNextImport(projectPath, resourcePath) {
   const relative = resourcePath.replace(/^res:\/\//, "");
-  const sidecar = join13(projectPath, `${relative}.import`);
-  if (!existsSync9(sidecar)) {
+  const sidecar = join14(projectPath, `${relative}.import`);
+  if (!existsSync10(sidecar)) {
     return;
   }
   const { atime, mtimeMs } = statSync5(sidecar);
@@ -29134,7 +29445,7 @@ function forceNextImport(projectPath, resourcePath) {
 }
 function importRecord(projectPath, resourcePath) {
   const digest = createHash2("md5").update(resourcePath).digest("hex");
-  return join13(projectPath, ".godot", "imported", `${basename2(resourcePath)}-${digest}.md5`);
+  return join14(projectPath, ".godot", "imported", `${basename2(resourcePath)}-${digest}.md5`);
 }
 
 // src/resources.ts
@@ -29380,9 +29691,9 @@ function setupResourceHandlers(mcp, getProjectPath) {
 
 // src/restart-note.ts
 import { mkdirSync as mkdirSync7, readFileSync as readFileSync14, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname8, join as join14 } from "node:path";
+import { dirname as dirname8, join as join15 } from "node:path";
 function restartNotePath(projectPath) {
-  return join14(projectPath, ".godot", "gdharness-restart.json");
+  return join15(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
@@ -29418,28 +29729,30 @@ function restartSettled(projectPath) {
 }
 
 // src/run-record.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { execFile as execFile5 } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
 import {
   mkdirSync as mkdirSync8,
   openSync as openSync2,
-  readdirSync as readdirSync5,
+  readdirSync as readdirSync6,
   readFileSync as readFileSync15,
   realpathSync as realpathSync3,
   rmSync as rmSync7,
   statSync as statSync6,
   writeFileSync as writeFileSync10
 } from "node:fs";
-import { basename as basename3, dirname as dirname9, join as join15, resolve as resolve5 } from "node:path";
+import { basename as basename3, dirname as dirname9, join as join16, resolve as resolve5 } from "node:path";
+import { promisify as promisify5 } from "node:util";
+var execFileAsync = promisify5(execFile5);
 function runsDirectory() {
-  return join15(runtimeDirectory(), "runs");
+  return join16(runtimeDirectory(), "runs");
 }
 function realAsFarAsItExists(path) {
   const missing = [];
   let at = path;
   for (;; ) {
     try {
-      return join15(realpathSync3.native(at), ...missing);
+      return join16(realpathSync3.native(at), ...missing);
     } catch {
       const parent = dirname9(at);
       if (parent === at) {
@@ -29456,16 +29769,16 @@ function projectKey(projectPath) {
   return createHash3("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join15(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join16(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 var SHARED_NOTE = "run.json";
 function openTranscript(startedAt) {
   mkdirSync8(runsDirectory(), { recursive: true });
-  const path = join15(runsDirectory(), `run-${startedAt}.log`);
+  const path = join16(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync2(path, "a") };
 }
 function editorNotePath(projectPath, directory = runtimeDirectory()) {
-  return join15(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join16(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
   mkdirSync8(runsDirectory(), { recursive: true });
@@ -29473,7 +29786,7 @@ function writeEditorRunNote(note) {
 }
 function readEditorRunNote(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join15(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join16(directory, "runs", "editor-run.json"));
     if (note !== null && isSameDirectory(note.projectPath, projectPath)) {
       return note;
     }
@@ -29505,7 +29818,7 @@ function readRunRecord(projectPath) {
     if (own !== null) {
       return own;
     }
-    const shared = recordAt(join15(directory, "runs", SHARED_NOTE));
+    const shared = recordAt(join16(directory, "runs", SHARED_NOTE));
     if (shared !== null && shared.projectPath !== "" && isSameDirectory(shared.projectPath, projectPath)) {
       return shared;
     }
@@ -29517,13 +29830,13 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync5(join15(directory, "runs"));
+      entries = readdirSync6(join16(directory, "runs"));
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry === SHARED_NOTE || entry.startsWith("note-") && entry.endsWith(".json")) {
-        const record = recordAt(join15(directory, "runs", entry));
+        const record = recordAt(join16(directory, "runs", entry));
         if (record !== null) {
           found.push(record);
         }
@@ -29561,49 +29874,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 = readFileSync15(`/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]);
@@ -29628,39 +29939,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
@@ -29670,11 +29973,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");
 }
 var SAME_RUN_WINDOW_MS = 1e4;
 function judgeRun(record, running, needed) {
@@ -29702,8 +30005,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) {
@@ -29720,7 +30023,7 @@ function judgeAnnouncedGame(running, projectPath, announcedAt) {
 }
 function clearRunRecord(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const shared = join15(directory, "runs", SHARED_NOTE);
+    const shared = join16(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] : []]) {
@@ -29742,7 +30045,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
   const kept = new Set(everyRunRecord().map((record) => record.transcript));
   let entries;
   try {
-    entries = readdirSync5(directory);
+    entries = readdirSync6(directory);
   } catch {
     return;
   }
@@ -29750,7 +30053,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join15(directory, entry);
+    const path = join16(directory, entry);
     if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
@@ -29764,16 +30067,16 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
 import { createHash as createHash4 } from "node:crypto";
 import {
   cpSync,
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   mkdirSync as mkdirSync9,
-  readdirSync as readdirSync6,
+  readdirSync as readdirSync7,
   readFileSync as readFileSync16,
   rmdirSync,
   rmSync as rmSync8,
   statSync as statSync7,
   writeFileSync as writeFileSync11
 } from "node:fs";
-import { dirname as dirname10, join as join16 } from "node:path";
+import { dirname as dirname10, join as join17 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
 var EDITOR_PLUGINS = ["gdharness_editor", "auto_reload"];
@@ -29786,11 +30089,11 @@ var DIGEST_MARKER = ".gdharness-digest";
 function editorAddonDigest(from = shippedAddonsDirectory()) {
   const hash = createHash4("sha256");
   const walk = (directory, relative) => {
-    for (const name of readdirSync6(directory).sort()) {
+    for (const name of readdirSync7(directory).sort()) {
       if (name === VERSION_MARKER || name === DIGEST_MARKER) {
         continue;
       }
-      const path = join16(directory, name);
+      const path = join17(directory, name);
       const inside = `${relative}/${name}`;
       if (statSync7(path).isDirectory()) {
         walk(path, inside);
@@ -29804,7 +30107,7 @@ function editorAddonDigest(from = shippedAddonsDirectory()) {
     }
   };
   for (const name of EDITOR_PLUGINS) {
-    walk(join16(from, name), name);
+    walk(join17(from, name), name);
   }
   return hash.digest("hex");
 }
@@ -29820,11 +30123,11 @@ function shippedEditorDigest() {
   return shippedDigest ?? undefined;
 }
 function shippedAddonsDirectory() {
-  return join16(dirname10(fileURLToPath3(import.meta.url)), "godot", "addons");
+  return join17(dirname10(fileURLToPath3(import.meta.url)), "godot", "addons");
 }
 function installedAddonVersion(projectPath) {
-  const marker = join16(projectPath, "addons", ADDONS[0], VERSION_MARKER);
-  if (!existsSync10(marker)) {
+  const marker = join17(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  if (!existsSync11(marker)) {
     return null;
   }
   const said = readFileSync16(marker, "utf8").trim();
@@ -30479,7 +30782,11 @@ var TOOL_SPECS = [
     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"],
@@ -30497,6 +30804,11 @@ var TOOL_SPECS = [
         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"],
@@ -30611,7 +30923,7 @@ var TOOL_SPECS = [
   },
   {
     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: {
@@ -30717,7 +31029,7 @@ var TOOL_SPECS = [
       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",
@@ -30872,7 +31184,7 @@ var TOOL_SPECS = [
       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",
@@ -31003,7 +31315,7 @@ var TOOL_SPECS = [
       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",
@@ -31124,7 +31436,7 @@ function buildToolDefinitions() {
 // src/server.ts
 var UPDATE_NOTICE_EVERY = 500;
 var FEEDBACK_NOTICE_EVERY = 250;
-var run5 = promisify5(execFile5);
+var run5 = promisify6(execFile6);
 var __dirname2 = dirname11(fileURLToPath4(import.meta.url));
 var EDITOR_RESTART_TIMEOUT_MS = 90000;
 var HOLD_PING_MS = 2000;
@@ -31140,15 +31452,15 @@ function captureDestinationRefusal(outputPath, projects) {
     return `outputPath ${outputPath} does not end in .png, which is what a capture is.`;
   }
   const directory = realPathOr(dirname11(outputPath));
-  if (!existsSync11(directory)) {
+  if (!existsSync12(directory)) {
     return `outputPath's directory ${dirname11(outputPath)} does not exist; a capture creates no directories.`;
   }
-  const where = join17(directory, basename4(outputPath));
+  const where = join18(directory, basename4(outputPath));
   const inside = projects.find((project) => project !== "" && isWithinRoot(realPathOr(project), where));
   if (inside !== undefined) {
     return `outputPath ${outputPath} is inside the project at ${inside}; a capture is saved outside it, so it never becomes part of the game.`;
   }
-  if (existsSync11(where)) {
+  if (existsSync12(where)) {
     return `outputPath ${outputPath} already exists; a capture is not written over a file. Name a new one.`;
   }
   return null;
@@ -31308,7 +31620,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.";
@@ -31391,17 +31704,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":
@@ -31649,13 +31951,13 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync11(join17(projectPath, wanted))) {
+  if (wanted === "" || existsSync12(join18(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
   let near = [];
   try {
-    near = readdirSync7(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 = 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()));
   } catch {
     return "";
   }
@@ -31671,7 +31973,7 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync17(join17(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
+    return readFileSync17(join18(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
@@ -31696,7 +31998,7 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   mcp;
   locator = new GodotLocator;
-  operationsScript = join17(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join18(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -31708,6 +32010,7 @@ class GodotServer {
   lastGodotVersion = null;
   lspClient = null;
   dapClient = null;
+  adapterPassed = null;
   breakpointsSeededOn = null;
   bridgeStartupError = null;
   bridgeRetry = null;
@@ -31766,6 +32069,7 @@ class GodotServer {
       this.handleShutdown("stdin:end", 0);
     });
     console.error("gdharness running on stdio");
+    sweepAbandonedScratch();
     try {
       await this.takeOverFromAPredecessor();
       await this.godotBridge.start();
@@ -32092,7 +32396,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) {
@@ -32436,8 +32740,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join17(path, "project.godot");
-    if (!existsSync11(file)) {
+    const file = join18(path, "project.godot");
+    if (!existsSync12(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -32598,13 +32902,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) {
@@ -32614,7 +32918,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;
@@ -33033,11 +33337,11 @@ class GodotServer {
       return this.createErrorResponse(`Cannot create ${dirname11(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
-    const exportLogs = mkdtempSync2(join17(tmpdir4(), "gdharness-export-"));
+    const exportLogs = scratchDirectory("export");
     const exportArgs = [
       "--headless",
       "--log-file",
-      join17(exportLogs, "engine.log"),
+      join18(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -33069,7 +33373,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 && existsSync11(output.absolutePath),
+      exported: ending.exitCode === 0 && log.count("error") === 0 && existsSync12(output.absolutePath),
       preset,
       outputPath: output.relativePath,
       debug,
@@ -33105,7 +33409,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync11(join17(project.value.path, runner))) {
+    if (!existsSync12(join18(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"
       ]);
@@ -33141,7 +33445,7 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync2(join17(tmpdir4(), "gdharness-tests-"));
+    const userData = scratchDirectory("tests");
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const console2 = [];
     let lastSaid = Date.now();
@@ -33168,14 +33472,17 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join17(project.value.path, ".godot", ...ours.split("/"));
+    if (timedOut && run.process.pid !== undefined) {
+      await untilGone([run.process.pid]);
+    }
+    const reportsDir = join18(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync11(reportsDir) ? readdirSync7(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync12(reportsDir) ? readdirSync8(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(readFileSync17(join17(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync17(join18(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -33333,7 +33640,7 @@ class GodotServer {
     const cached = cachedClasses(projectPath);
     const contradicted = cached === null ? [] : contradictedDiagnostics(messages, cached, (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
-      if (!contained.ok || !existsSync11(contained.absolutePath)) {
+      if (!contained.ok || !existsSync12(contained.absolutePath)) {
         return null;
       }
       try {
@@ -33387,7 +33694,7 @@ class GodotServer {
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
-    if (!contained.ok || !existsSync11(contained.absolutePath)) {
+    if (!contained.ok || !existsSync12(contained.absolutePath)) {
       return null;
     }
     try {
@@ -33408,28 +33715,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() {
@@ -33518,8 +33829,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);
@@ -33528,14 +33840,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.`,
@@ -33624,7 +33936,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,
@@ -33632,14 +33944,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
       },
@@ -33669,7 +33982,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync17(join17(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync17(join18(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -33818,7 +34131,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 };
   }
@@ -33866,13 +34179,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();
@@ -33882,14 +34197,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);
@@ -33900,7 +34217,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);
@@ -33922,7 +34239,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync11(join17(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync12(join18(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
     }
     let asking = null;
@@ -33933,12 +34250,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);
         }
@@ -33956,7 +34273,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);
     }
@@ -33997,8 +34314,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)}`, [
@@ -34006,7 +34325,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",
@@ -34014,7 +34333,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;
@@ -34200,13 +34521,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 {
@@ -34227,7 +34548,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 = () => {
@@ -34394,8 +34715,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;
     }
@@ -34406,7 +34727,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;
     }
@@ -34492,7 +34813,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)) {
@@ -34513,7 +34834,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;
@@ -34594,8 +34915,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;
@@ -34634,10 +34955,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();
@@ -34684,7 +35009,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) {
@@ -34721,10 +35046,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,
@@ -34748,7 +35074,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());
     }
@@ -34787,7 +35113,7 @@ class GodotServer {
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync11(join17(run.projectPath, RUNTIME_AUTOLOAD.path)),
+        couldAnnounce: run.projectPath !== null && existsSync12(join18(run.projectPath, RUNTIME_AUTOLOAD.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -34825,16 +35151,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);
@@ -34876,16 +35213,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.`);
     }
@@ -35083,6 +35426,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) {
@@ -35094,13 +35439,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,
@@ -35108,6 +35456,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,
@@ -35116,6 +35467,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 [];
@@ -35298,9 +35676,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) || !existsSync11(join17(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync12(join18(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -35326,8 +35704,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;
@@ -35336,7 +35714,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.`;
@@ -35352,7 +35730,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);
@@ -35379,8 +35757,8 @@ class GodotServer {
         return this.createErrorResponse(refusal);
       }
     }
-    const screenshotDir = expectsScreenshot ? mkdtempSync2(join17(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join17(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
+    const screenshotPath = screenshotDir ? join18(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) {