gdharness 0.13.35 → 0.13.37

package/build/index.js

@@ -9846,9 +9846,23 @@ function runLine(runner, version, rest = "") {
 }
 
 // src/update-check.ts
-var REGISTRY = "https://registry.npmjs.org/gdharness/latest";
+var REGISTRY_ROOT = "https://registry.npmjs.org";
+function packageUrl(root) {
+  return `${root.replace(/\/+$/, "")}/gdharness/latest`;
+}
+function registryFor(environment) {
+  const named = environment["GDHARNESS_REGISTRY"] ?? "";
+  if (named === "") {
+    return packageUrl(REGISTRY_ROOT);
+  }
+  try {
+    return new URL(named).protocol === "https:" ? packageUrl(named) : packageUrl(REGISTRY_ROOT);
+  } catch {
+    return packageUrl(REGISTRY_ROOT);
+  }
+}
 var RELEASES = "https://github.com/Aureliolo/gdharness/releases/tag";
-var CACHE_MS = 4 * 60 * 60 * 1000;
+var CACHE_MS = 10 * 60 * 1000;
 var REQUEST_TIMEOUT_MS = 1e4;
 var MAX_BODY_BYTES = 1 << 20;
 var FIRST_RETRY_MS = 30000;
@@ -9923,8 +9937,8 @@ function isNewer(candidate, current) {
   }
   return !left.prerelease && right.prerelease;
 }
-async function fetchLatest() {
-  const response = await fetch(REGISTRY, {
+async function fetchLatest(registry) {
+  const response = await fetch(registry, {
     headers: { accept: "application/vnd.npm.install-v1+json, application/json" },
     redirect: "error",
     signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
@@ -9956,16 +9970,19 @@ async function fetchLatest() {
 class UpdateCheck {
   latest = null;
   checking = false;
+  asked = false;
   checkedAt = 0;
   retryAt = 0;
   backoffMs = FIRST_RETRY_MS;
   enabled;
   current;
   cachePath;
-  constructor(current, environment = process.env) {
+  ask;
+  constructor(current, environment = process.env, ask = () => fetchLatest(registryFor(environment))) {
     this.current = current;
     this.enabled = (environment["GDHARNESS_NO_UPDATE_CHECK"] ?? "") === "";
     this.cachePath = cacheFile(environment);
+    this.ask = ask;
     const cached = this.enabled ? readCache(this.cachePath) : null;
     if (cached !== null) {
       this.latest = cached.latest;
@@ -9973,11 +9990,12 @@ class UpdateCheck {
     }
   }
   refresh(now = Date.now()) {
-    if (!this.enabled || this.checking || now < this.retryAt || !this.stale(now)) {
+    if (!this.enabled || this.checking || now < this.retryAt || this.asked && !this.stale(now)) {
       return;
     }
+    this.asked = true;
     this.checking = true;
-    fetchLatest().then((version) => {
+    this.ask().then((version) => {
       if (version === null) {
         this.scheduleRetry(now);
         return;
@@ -10107,15 +10125,26 @@ function filledTemplate(where, message, godotVersion) {
   ].join(`
 `);
 }
-function defectReport(where, error, godotVersion) {
+function defectReport(where, error, context = {}) {
+  const { godotVersion, seenBefore = 0 } = context;
   const message = errorMessage(error);
   const title = `Defect ${defectSignature(where, message)}: ${where}`;
   const url = `${NEW_ISSUE}?template=bug_report.md&title=${encodeURIComponent(title)}` + `&body=${encodeURIComponent(filledTemplate(where, message, godotVersion))}`;
   const width = Math.max(...facts(where, message, godotVersion).map(([label]) => (label ?? "").length));
   return [
-    "gdharness failed in a way it does not model. This is a defect in gdharness rather than",
-    "anything about the call: the arguments did not cause it, and sending it again will not",
-    "change it.",
+    "gdharness failed in a way it does not model. Whatever went wrong underneath, it reached you",
+    "as a crash rather than as a refusal naming what would have worked, and that much is a defect",
+    "in gdharness however the rest of it turns out.",
+    "",
+    ...seenBefore === 0 ? [
+      "Send the call once more before anything else. Some of what reaches this line is a file",
+      "another process had open, or a connection that dropped, and those are gone by the next",
+      "attempt. If the same Signature comes back, it is not one of those, and repeating it",
+      "further only spends turns."
+    ] : [
+      `You have had this exact failure ${seenBefore === 1 ? "once" : `${seenBefore} times`} in this session already, so it is a`,
+      "state rather than a passing one, and sending the call again will not change it."
+    ],
     "",
     ...facts(where, message, godotVersion).map(([label, value]) => `  ${(label ?? "").padEnd(width)}  ${value ?? ""}`),
     "",
@@ -10146,15 +10175,15 @@ import {
   closeSync,
   existsSync as existsSync9,
   fstatSync,
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync6,
   mkdtempSync as mkdtempSync2,
   openSync as openSync2,
   readdirSync as readdirSync6,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync12,
   readSync
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename2, dirname as dirname4, join as join11, normalize as normalize2 } from "node:path";
+import { basename as basename2, dirname as dirname5, join as join12, normalize as normalize2 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { promisify as promisify4 } from "node:util";
@@ -24886,7 +24915,7 @@ function staleAnalysisNote(contradicted, dependsOn) {
   }
   const types = new Set(contradicted.map((one) => one.type));
   const declaring = [...new Set(contradicted.map((one) => one.declaredIn))].sort();
-  const lever = dependsOn.length === 0 ? ", and the named types depend on no other global class, so that lever is not available here. " + "That is the common case rather than the awkward one: an edit near a type that depends on " + "something refreshes it before the fault is noticed, which is why a type with no " + "dependencies is where this turns up" : `, so changing ${[...dependsOn].sort().join(", ")} and rescanning is worth a try`;
+  const lever = dependsOn.length === 0 ? ", and the named types depend on no other global class, so that lever is not available here. " + "That is the common case rather than the awkward one: an edit near a type that depends on " + "something refreshes it before the fault is noticed, which is why a type with no " + "dependencies is where this turns up" : `, so changing ${[...dependsOn].sort().join(" or ")} and then rescanning is worth a try`;
   return `The editor is reporting against an older copy of ${types.size === 1 ? "a type" : "some types"} ` + "named under contradictedByTheFile. Each member listed is declared in the file the class cache " + "points at, so those diagnostics are wrong however the code is written. Run editor_rescan first: " + "it costs about half a second, and it has cleared this in every reproduction measured since the " + "scan timing was fixed: both in one project, the scan returning in 243ms and 275ms, and one in " + "another where the same call also rebuilt the copy. " + "The fault behind it is that a script the editor has loaded keeps the copy it built, and nothing " + `rebuilds that copy when the file changes; ${declaring.length === 1 ? `editor_rescan with reloadScript set to ${declaring[0]} recompiles that copy` : `reloadScript takes one script, so a call each for ${declaring.join(" and ")} recompiles those copies`} from the file into the same ` + "object and answers with the members it has afterwards under reloadedMethods. Read that and the " + "next diagnostics as two readings, because they are of two things: measured in one window on " + "one editor, the analyser resolved a call to a newly added method while the built copy of that " + "same script did not have it. So the reload is worth doing and is not what clears these; the " + "scan is. The other lever measured is that a held type is refreshed when something it " + `depends on changes rather than when it changes itself${lever}. editor_launch restart has always ` + "worked and costs a window. project_import refresh_classes does not, and answers added: [] while " + "this is happening.";
 }
 function uncachedClassNote(types) {
@@ -25574,6 +25603,11 @@ function announced(line) {
   return { severity: match[2] === "WARNING" ? "warning" : "error", text: match[3] ?? "" };
 }
 var STREAMS = ["stdout", "stderr", "transcript"];
+var ADMITTED = {
+  error: new Set(["error"]),
+  warning: new Set(["error", "warning"]),
+  info: new Set(["error", "warning", "info"])
+};
 function forAnswer(entries) {
   return entries.map((entry) => entry.detail.length === 0 ? { index: entry.index, severity: entry.severity, source: entry.source, text: entry.text } : entry);
 }
@@ -25587,7 +25621,7 @@ class GameLog {
   };
   partial = { stdout: "", stderr: "", transcript: "" };
   lastHeadline = null;
-  cursor = 0;
+  seen = { error: 0, warning: 0, info: 0 };
   append(source, chunk) {
     const decoded = typeof chunk === "string" ? chunk : this.decoders[source].write(chunk);
     const lines = (this.partial[source] + decoded).split(`
@@ -25644,10 +25678,14 @@ class GameLog {
     return this.entries.filter((entry) => entry.severity === severity).length;
   }
   select(options) {
-    const floor = options.sinceLastCall ? this.cursor : 0;
-    this.cursor = this.entries.length;
-    const wanted = new Set(options.severity === "error" ? ["error"] : options.severity === "warning" ? ["error", "warning"] : ["error", "warning", "info"]);
+    const floor = options.sinceLastCall ? this.seen[options.severity] : 0;
+    const wanted = ADMITTED[options.severity];
     const needle = options.contains?.toLowerCase();
+    if (needle === undefined) {
+      for (const severity of wanted) {
+        this.seen[severity] = this.entries.length;
+      }
+    }
     const matching = this.entries.slice(floor).filter((entry) => {
       if (!wanted.has(entry.severity)) {
         return false;
@@ -26353,6 +26391,10 @@ function userDataIn(home, variables = process.env) {
   }
   return carried;
 }
+function savesStayPut(platform = process.platform) {
+  return platform === "darwin";
+}
+var SAVES_NOT_MOVED_NOTE = "On macOS the engine reads user:// off HOME and ignores the variables that move it elsewhere, measured on Godot 4.7.2, so this run wrote its saves where the player keeps theirs. A suite that saves a game has written into the same folder as the copy being played, and one that tidies up after itself may have removed real saves.";
 
 // src/godot-path.ts
 var run = promisify(execFile);
@@ -26361,47 +26403,65 @@ class GodotLocator {
   answered = new Map;
   found = null;
   async find() {
-    if (this.found !== null && await this.answers(this.found)) {
-      return this.found;
+    if (this.found !== null && await this.whyNot(this.found) === null) {
+      return { ok: true, path: this.found };
     }
     this.found = null;
     const named = envValue("GODOT_PATH");
     if (named !== undefined) {
       const path = normalize(named);
-      if (await this.answers(path)) {
+      const reason = await this.whyNot(path);
+      if (reason === null) {
         this.found = path;
+        return { ok: true, path };
       }
-      return this.found;
+      return { ok: false, named: path, reason };
     }
     for (const candidate of godotCandidates(process.platform, resolveHomeDirectory())) {
       const path = normalize(candidate);
-      if (await this.answers(path)) {
+      if (await this.whyNot(path) === null) {
         this.found = path;
-        return path;
+        return { ok: true, path };
       }
     }
-    return null;
+    return { ok: false, named: null };
   }
-  static ADVICE = [
-    "Set GODOT_PATH to the Godot 4 executable",
-    "Or install Godot where it is usually found, such as /usr/bin/godot or C:\\Program Files\\Godot"
-  ];
-  async answers(path) {
+  static refusal(located) {
+    if (located.named === null) {
+      return {
+        message: "No Godot executable found.",
+        advice: [
+          "Set GODOT_PATH to the Godot 4 executable",
+          "Or install Godot where it is usually found, such as /usr/bin/godot or C:\\Program Files\\Godot"
+        ]
+      };
+    }
+    return {
+      message: `GODOT_PATH is set to ${located.named}, which ${located.reason ?? "does not answer"}.`,
+      advice: [
+        "Point GODOT_PATH at a Godot 4 executable that answers --version",
+        "Or unset it, and the usual install locations are searched instead"
+      ]
+    };
+  }
+  async whyNot(path) {
     const known = this.answered.get(path);
     if (known !== undefined) {
       return known;
     }
-    let ok = false;
-    if (path === "godot" || existsSync5(path)) {
+    let reason;
+    if (path !== "godot" && !existsSync5(path)) {
+      reason = "does not exist";
+    } else {
       try {
         await run(path, ["--version"]);
-        ok = true;
-      } catch {
-        ok = false;
+        reason = null;
+      } catch (error) {
+        reason = `does not answer --version: ${errorMessage(error)}`;
       }
     }
-    this.answered.set(path, ok);
-    return ok;
+    this.answered.set(path, reason);
+    return reason;
   }
 }
 
@@ -26659,15 +26719,36 @@ function filledTemplate2(where, message, godotVersion) {
   ].join(`
 `);
 }
-function defectReport2(where, error, godotVersion) {
+
+class DefectsSeen {
+  counts = new Map;
+  before(where, message) {
+    const signature = defectSignature2(where, message);
+    const seen = this.counts.get(signature) ?? 0;
+    this.counts.set(signature, seen + 1);
+    return seen;
+  }
+}
+function defectReport2(where, error, context = {}) {
+  const { godotVersion, seenBefore = 0 } = context;
   const message = errorMessage(error);
   const title = `Defect ${defectSignature2(where, message)}: ${where}`;
   const url = `${NEW_ISSUE2}?template=bug_report.md&title=${encodeURIComponent(title)}` + `&body=${encodeURIComponent(filledTemplate2(where, message, godotVersion))}`;
   const width = Math.max(...facts2(where, message, godotVersion).map(([label]) => (label ?? "").length));
   return [
-    "gdharness failed in a way it does not model. This is a defect in gdharness rather than",
-    "anything about the call: the arguments did not cause it, and sending it again will not",
-    "change it.",
+    "gdharness failed in a way it does not model. Whatever went wrong underneath, it reached you",
+    "as a crash rather than as a refusal naming what would have worked, and that much is a defect",
+    "in gdharness however the rest of it turns out.",
+    "",
+    ...seenBefore === 0 ? [
+      "Send the call once more before anything else. Some of what reaches this line is a file",
+      "another process had open, or a connection that dropped, and those are gone by the next",
+      "attempt. If the same Signature comes back, it is not one of those, and repeating it",
+      "further only spends turns."
+    ] : [
+      `You have had this exact failure ${seenBefore === 1 ? "once" : `${seenBefore} times`} in this session already, so it is a`,
+      "state rather than a passing one, and sending the call again will not change it."
+    ],
     "",
     ...facts2(where, message, godotVersion).map(([label, value]) => `  ${(label ?? "").padEnd(width)}  ${value ?? ""}`),
     "",
@@ -27735,6 +27816,11 @@ function settingKeys(content) {
   return named;
 }
 function settingsDroppedReport(before, after) {
+  if (before === null || after === null) {
+    return {
+      settingsNote: `project.godot could not be read ${before === null ? "before" : "after"} this, so nothing can` + " be said about what the editor saved away. Opening a project rewrites the file and drops any" + " key sitting at its own default, and this is the only thing that would have named them." + " Read the file yourself if a setting was pinned at a default on purpose."
+    };
+  }
   const dropped = [...before].filter(([key]) => !after.has(key));
   if (dropped.length === 0) {
     return {};
@@ -27848,16 +27934,55 @@ function setupResourceHandlers(mcp, getProjectPath) {
   });
 }
 
+// src/restart-note.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync8, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname3, join as join8 } from "node:path";
+function restartNotePath(projectPath) {
+  return join8(projectPath, ".godot", "gdharness-restart.json");
+}
+function noteRestartBegun(note) {
+  const path = restartNotePath(note.projectPath);
+  try {
+    mkdirSync3(dirname3(path), { recursive: true });
+    writeFileSync4(path, `${JSON.stringify(note, null, 2)}
+`, "utf8");
+  } catch (error) {
+    console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
+  }
+}
+function restartOwed(projectPath) {
+  try {
+    const parsed = JSON.parse(readFileSync8(restartNotePath(projectPath), "utf8"));
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    const said = parsed;
+    if (typeof said.quitAt !== "string" || typeof said.byPid !== "number" || typeof said.ports !== "object") {
+      return null;
+    }
+    return said;
+  } catch {
+    return null;
+  }
+}
+function restartSettled(projectPath) {
+  try {
+    rmSync3(restartNotePath(projectPath), { force: true });
+  } catch (error) {
+    console.error(`[SERVER] Could not clear the restart note: ${errorMessage(error)}`);
+  }
+}
+
 // src/run-record.ts
 import { execFileSync } from "node:child_process";
-import { mkdirSync as mkdirSync3, openSync, readdirSync as readdirSync5, readFileSync as readFileSync9, rmSync as rmSync3, statSync as statSync3, writeFileSync as writeFileSync4 } from "node:fs";
-import { basename, join as join9 } from "node:path";
+import { mkdirSync as mkdirSync4, openSync, readdirSync as readdirSync5, readFileSync as readFileSync10, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { basename, join as join10 } from "node:path";
 
 // src/runtime-client.ts
-import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync8, unlinkSync } from "node:fs";
+import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync9, unlinkSync } from "node:fs";
 import { createConnection as createConnection3 } from "node:net";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join8, resolve as resolve4 } from "node:path";
+import { join as join9, resolve as resolve4 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
 
 // src/tool-args.ts
@@ -27925,13 +28050,13 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join8(perUser ?? tmpdir3(), "gdharness");
+  return join9(perUser ?? tmpdir3(), "gdharness");
 }
 function runtimeDirectories(variables = process.env) {
   const candidates = [runtimeDirectory(variables)];
   const fallbacks = process.platform === "win32" ? [envValue("SystemRoot", variables) ?? envValue("windir", variables) ?? "C:\\Windows"] : ["/tmp", "/var/tmp"];
   for (const base of fallbacks) {
-    candidates.push(join8(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+    candidates.push(join9(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
   return [...new Set(candidates.map((path) => resolve4(path)))];
 }
@@ -27946,7 +28071,7 @@ function processAlive(pid) {
 function parseAnnouncement(file, pid) {
   let fields;
   try {
-    fields = asParams(JSON.parse(readFileSync8(file, "utf8")));
+    fields = asParams(JSON.parse(readFileSync9(file, "utf8")));
   } catch {
     return { kind: "rubbish" };
   }
@@ -27984,6 +28109,31 @@ function runtimesAnnounced(directories = runtimeDirectories()) {
 function discoverRuntimes(directories = runtimeDirectories()) {
   return runtimesAnnounced(directories).running;
 }
+var GONE_WINDOW_MS = 120000;
+var GONE_KEPT = 32;
+var gone = [];
+function wentAway(file, pid) {
+  let project = "";
+  try {
+    const fields = asParams(JSON.parse(readFileSync9(file, "utf8")));
+    project = readString(readParams(fields, "project") ?? {}, "path") ?? "";
+  } catch {
+    return;
+  }
+  if (project === "") {
+    return;
+  }
+  gone.unshift({ pid, project, noticedAt: Date.now() });
+  gone.length = Math.min(gone.length, GONE_KEPT);
+}
+function announcedAndGone(projectPath) {
+  if (projectPath === undefined) {
+    return [];
+  }
+  const since = Date.now() - GONE_WINDOW_MS;
+  const wanted = resolve4(projectPath);
+  return gone.filter((one) => one.noticedAt >= since && resolve4(one.project) === wanted);
+}
 function announcedIn(directory) {
   if (!existsSync7(directory)) {
     return [];
@@ -27994,10 +28144,14 @@ function announcedIn(directory) {
     if (!match) {
       continue;
     }
-    const file = join8(directory, entry);
+    const file = join9(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
-    const announced = processAlive(pid) ? parseAnnouncement(file, pid) : { kind: "rubbish" };
+    const alive = processAlive(pid);
+    const announced = alive ? parseAnnouncement(file, pid) : { kind: "rubbish" };
     if (announced.kind === "rubbish") {
+      if (!alive) {
+        wentAway(file, pid);
+      }
       try {
         unlinkSync(file);
       } catch {}
@@ -28038,6 +28192,16 @@ function chooseRuntime(endpoints, projectPath, unspoken = []) {
     if (unspoken.length > 0) {
       return { problem: tooNew(unspoken) };
     }
+    const went = announcedAndGone(projectPath);
+    const first = went[0];
+    if (first !== undefined) {
+      const ago = Math.max(1, Math.round((Date.now() - first.noticedAt) / 1000));
+      const others = went.length - 1;
+      const earlier = others === 0 ? "" : ` ${others} earlier ${others === 1 ? "one" : "ones"} went the same way.`;
+      return {
+        problem: `A game with the runtime addon announced itself and its process is gone: pid ${first.pid}` + `${first.project === "" ? "" : ` for ${first.project}`}, noticed ${ago}s ago.${earlier}` + " It quit or was ended rather than never starting, so editor_output has what it printed" + " on the way, including whatever it broke on. Start another with editor_run once you have read it."
+      };
+    }
     return {
       problem: "No game with the runtime addon is running. Start one with editor_run, or play the project from the editor with the addon enabled."
     };
@@ -28155,33 +28319,33 @@ function runtimeRequest(endpoint, command, params, timeoutMs) {
 
 // src/run-record.ts
 function runsDirectory() {
-  return join9(runtimeDirectory(), "runs");
+  return join10(runtimeDirectory(), "runs");
 }
 function recordPath() {
-  return join9(runsDirectory(), "run.json");
+  return join10(runsDirectory(), "run.json");
 }
 function recordPaths() {
-  return runtimeDirectories().map((directory) => join9(directory, "runs", "run.json"));
+  return runtimeDirectories().map((directory) => join10(directory, "runs", "run.json"));
 }
 function openTranscript(startedAt) {
-  mkdirSync3(runsDirectory(), { recursive: true });
-  const path = join9(runsDirectory(), `run-${startedAt}.log`);
+  mkdirSync4(runsDirectory(), { recursive: true });
+  const path = join10(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync(path, "a") };
 }
 function writeRunRecord(record) {
-  mkdirSync3(runsDirectory(), { recursive: true });
-  writeFileSync4(recordPath(), JSON.stringify(record, null, 2), "utf8");
+  mkdirSync4(runsDirectory(), { recursive: true });
+  writeFileSync5(recordPath(), JSON.stringify(record, null, 2), "utf8");
 }
 function editorNotePath() {
-  return join9(runsDirectory(), "editor-run.json");
+  return join10(runsDirectory(), "editor-run.json");
 }
 function writeEditorRunNote(note) {
-  mkdirSync3(runsDirectory(), { recursive: true });
-  writeFileSync4(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
+  mkdirSync4(runsDirectory(), { recursive: true });
+  writeFileSync5(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
 }
 function readEditorRunNote() {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(join9(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(join10(directory, "runs", "editor-run.json"));
     if (note !== null) {
       return note;
     }
@@ -28191,7 +28355,7 @@ function readEditorRunNote() {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync9(path, "utf8"));
+    parsed = JSON.parse(readFileSync10(path, "utf8"));
   } catch {
     return null;
   }
@@ -28214,7 +28378,7 @@ function recordRunEnded(pid, exitCode) {
     return;
   }
   try {
-    writeFileSync4(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
+    writeFileSync5(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
   } catch {}
 }
 function readRunRecord() {
@@ -28229,7 +28393,7 @@ function readRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync9(path, "utf8"));
+    parsed = JSON.parse(readFileSync10(path, "utf8"));
   } catch {
     return null;
   }
@@ -28256,23 +28420,32 @@ function recordAt(path) {
 }
 function runningAs(pid) {
   if (process.platform === "win32") {
-    const line = windowsCommandLine(pid);
-    if (line !== null) {
-      return { kind: "commandLine", text: line };
+    const answer = windowsCommandLine(pid);
+    if (answer !== null) {
+      const [, ...rest] = answer.split(`
+`);
+      const line = rest.join(`
+`).trim();
+      const began = startedAt(pid, answer);
+      if (line !== "") {
+        return { kind: "commandLine", text: line, ...began === null ? {} : { startedAt: began } };
+      }
     }
     const image = windowsImage(pid);
     return image === null ? null : { kind: "image", text: image };
   }
   try {
+    const began = startedAt(pid, null);
+    const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync9(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
-      return raw === "" ? null : { kind: "commandLine", text: raw };
+      const raw = readFileSync10(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = execFileSync("ps", ["-p", String(pid), "-o", "args="], {
       encoding: "utf8",
       timeout: 15000
     }).trim();
-    return args === "" ? null : { kind: "commandLine", text: args };
+    return args === "" ? null : { kind: "commandLine", text: args, ...when };
   } catch {
     return null;
   }
@@ -28311,13 +28484,30 @@ function windowsCommandLine(pid) {
       "-NoProfile",
       "-NonInteractive",
       "-Command",
-      `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").CommandLine`
+      `$p = Get-CimInstance Win32_Process -Filter "ProcessId=${pid}"; if ($p) { $p.CreationDate.ToUniversalTime().ToString("o"); $p.CommandLine }`
     ], { encoding: "utf8", timeout: 15000, windowsHide: true }).trim();
     return answer === "" ? null : answer;
   } catch {
     return null;
   }
 }
+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 = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+      encoding: "utf8",
+      timeout: 15000
+    }).trim();
+    const when = Date.parse(said);
+    return said === "" || Number.isNaN(when) ? null : when;
+  } catch {
+    return null;
+  }
+}
 function windowsImage(pid) {
   try {
     const csv = execFileSync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
@@ -28337,10 +28527,14 @@ function couldStillBeTheRecordedRun(record) {
   return judgeRun(record, runningAs(record.pid), "possible");
 }
 var AN_EDITOR = /(?:^|\s)(?:-e|--editor)(?:\s|$)/;
+var SAME_RUN_WINDOW_MS = 1e4;
 function judgeRun(record, running, needed) {
   if (running === null) {
     return false;
   }
+  if (running.startedAt !== undefined && running.startedAt - record.startedAt > SAME_RUN_WINDOW_MS) {
+    return false;
+  }
   const engine = record.command === undefined ? null : basename(record.command);
   const said = process.platform === "win32" ? running.text.toLowerCase() : running.text;
   const wanted = engine === null || process.platform !== "win32" ? engine : engine.toLowerCase();
@@ -28366,7 +28560,7 @@ function clearRunRecord(ours = () => true) {
       continue;
     }
     try {
-      rmSync3(path);
+      rmSync4(path);
     } catch {}
   }
 }
@@ -28390,19 +28584,19 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join9(directory, entry);
+    const path = join10(directory, entry);
     if (path === keep || ageMs(path, now) < keepMs) {
       continue;
     }
     try {
-      rmSync3(path);
+      rmSync4(path);
     } catch {}
   }
 }
 
 // src/setup.ts
-import { cpSync, existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync10, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname3, join as join10 } from "node:path";
+import { cpSync, existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync11, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname4, join as join11 } from "node:path";
 var ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
 var RUNTIME_AUTOLOAD = {
   name: "GdharnessRuntime",
@@ -28410,11 +28604,11 @@ var RUNTIME_AUTOLOAD = {
 };
 var VERSION_MARKER = ".gdharness-version";
 function installedAddonVersion(projectPath) {
-  const marker = join10(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  const marker = join11(projectPath, "addons", ADDONS[0], VERSION_MARKER);
   if (!existsSync8(marker)) {
     return null;
   }
-  const said = readFileSync10(marker, "utf8").trim();
+  const said = readFileSync11(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 
@@ -28751,7 +28945,7 @@ var TOOL_SPECS = [
   },
   {
     name: "project_test",
-    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. Needs gdUnit4 under addons/gdUnit4.",
+    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. Needs gdUnit4 under addons/gdUnit4.",
     parameters: {
       projectPath: PROJECT_PATH,
       path: {
@@ -29018,7 +29212,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_launch",
-    description: "Opens the Godot editor on a project, in a window on this machine, or restarts the one already connected. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect; it saves open scenes on the way out and answers with the version that came back. Only an editor with a window can be restarted, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one.",
+    description: "Opens the Godot editor on a project, in a window on this machine, or restarts the one already connected. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect; it saves open scenes on the way out and answers with the version that came back. Only an editor with a window can be restarted, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart.",
     parameters: { projectPath: { ...PROJECT_PATH, ops: ["open"] } },
     requires: [],
     operations: {
@@ -29080,7 +29274,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_output",
-    description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. Answers with the counts and the verdict as well as the entries. A run that has quit still answers here, with running false and its exit code, until the next one starts. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: running is asked of the operating system, endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over.",
+    description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. Answers with the counts and the verdict as well as the entries. A run that has quit still answers here, with running false and its exit code, until the next one starts. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering.",
     parameters: {
       severity: {
         type: "string",
@@ -29089,7 +29283,7 @@ var TOOL_SPECS = [
       },
       sinceLastCall: {
         type: "boolean",
-        description: "Only entries printed since the previous editor_output. Default false."
+        description: "Only entries this has not already answered with at this severity. Default false. Measured per severity floor and not across them, so polling for errors leaves the rest of the output for a later read rather than consuming it, and a read with contains is a search over the whole run and consumes nothing."
       },
       cpu: {
         type: "boolean",
@@ -29108,7 +29302,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_status",
-    description: 'Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means "not reached yet" as often as it means "no editor". True is worth waiting out; false is an editor that is not there. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade: installing moves the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with. Those games are real and running, but no tool here can reach them until the two halves match, so runtimes stays empty and runtimeConnected stays false.',
+    description: 'Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means "not reached yet" as often as it means "no editor". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it.',
     parameters: {},
     requires: []
   },
@@ -29525,7 +29719,7 @@ function buildToolDefinitions() {
 var UPDATE_NOTICE_EVERY = 500;
 var FEEDBACK_NOTICE_EVERY = 250;
 var run4 = promisify4(execFile4);
-var __dirname2 = dirname4(fileURLToPath2(import.meta.url));
+var __dirname2 = dirname5(fileURLToPath2(import.meta.url));
 var EDITOR_RESTART_TIMEOUT_MS = 90000;
 var SLOWEST_FRAME_RATE = 20;
 function patienceForFrames(frames, atLeast) {
@@ -29538,12 +29732,18 @@ function stillRunning(run) {
   if (!run.throughEditor && run.process === null && run.pid !== null) {
     return alive(run.pid);
   }
+  if (run.announcedPid !== undefined && !alive(run.announcedPid)) {
+    return false;
+  }
   return true;
 }
 function runIsUp(run, editorSays) {
   if (run?.throughEditor !== true) {
     return stillRunning(run);
   }
+  if (run.announcedPid !== undefined && !alive(run.announcedPid)) {
+    return false;
+  }
   return editorSays ?? stillRunning(run);
 }
 function runtimeVerdict(endpoint, after) {
@@ -29715,7 +29915,7 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync9(join11(projectPath, wanted))) {
+  if (wanted === "" || existsSync9(join12(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -29729,11 +29929,11 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync11(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync12(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync11(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync12(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -29749,7 +29949,7 @@ function camelCased(params) {
 class GodotServer {
   mcp;
   locator = new GodotLocator;
-  operationsScript = join11(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join12(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -29757,6 +29957,8 @@ class GodotServer {
   noticedUpdate = false;
   callsSinceNotice = 0;
   callsSinceFeedback = 0;
+  defectsSeen = new DefectsSeen;
+  lastGodotVersion = null;
   lspClient = null;
   dapClient = null;
   bridgeStartupError = null;
@@ -29801,11 +30003,11 @@ class GodotServer {
     return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
   }
   async run() {
-    const godotPath = await this.locator.find();
-    if (godotPath === null) {
-      console.error("[SERVER] No Godot found. Set GODOT_PATH; until then every tool that runs the engine will say so.");
+    const located = await this.locator.find();
+    if (!located.ok) {
+      console.error(`[SERVER] ${GodotLocator.refusal(located).message} Until that is fixed every tool that runs the engine will say so.`);
     } else {
-      console.error(`[SERVER] Using Godot at: ${godotPath}`);
+      console.error(`[SERVER] Using Godot at: ${located.path}`);
     }
     const transport = new StdioServerTransport;
     await this.mcp.server.connect(transport);
@@ -30005,7 +30207,19 @@ class GodotServer {
       }
       const where = op === "" ? tool : `${tool} op=${op}`;
       console.error(`[SERVER] Unmodelled failure in ${where}:`, error);
-      return { content: [{ type: "text", text: defectReport2(where, error) }], isError: true };
+      const seenBefore = this.defectsSeen.before(where, errorMessage(error));
+      return {
+        content: [
+          {
+            type: "text",
+            text: defectReport2(where, error, {
+              seenBefore,
+              godotVersion: this.lastGodotVersion ?? undefined
+            })
+          }
+        ],
+        isError: true
+      };
     }
   }
   withUpdateNotice(answer) {
@@ -30366,21 +30580,19 @@ class GodotServer {
     }
   }
   async engine() {
-    const godotPath = await this.locator.find();
-    if (godotPath === null) {
-      return {
-        ok: false,
-        response: this.createErrorResponse("No Godot executable found.", GodotLocator.ADVICE)
-      };
+    const located = await this.locator.find();
+    if (!located.ok) {
+      const refusal = GodotLocator.refusal(located);
+      return { ok: false, response: this.createErrorResponse(refusal.message, [...refusal.advice]) };
     }
-    return { ok: true, value: godotPath };
+    return { ok: true, value: located.path };
   }
   project(args) {
     const path = readNonEmptyString(args, "projectPath");
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join11(path, "project.godot");
+    const file = join12(path, "project.godot");
     if (!existsSync9(file)) {
       return {
         ok: false,
@@ -30522,7 +30734,7 @@ class GodotServer {
     }
     const engine = await this.engine();
     if (!engine.ok) {
-      return this.createErrorResponse("No Godot executable found.");
+      return engine.response;
     }
     const projectPath = project.value.path;
     const before = scriptsWithoutUid(projectPath);
@@ -30545,7 +30757,11 @@ class GodotServer {
   async operation(operation, params, projectPath) {
     const engine = await this.engine();
     if (!engine.ok) {
-      return { ok: false, message: "No Godot executable found.", messages: [] };
+      return {
+        ok: false,
+        message: engine.response.content.map((block) => block.text).join(" "),
+        messages: []
+      };
     }
     this.logDebug(`Running ${operation} in ${projectPath}: ${JSON.stringify(params)}`);
     return await runOperation({ godotPath: engine.value, script: this.operationsScript, debug: GODOT_DEBUG_MODE_DEFAULT }, operation, params, projectPath);
@@ -30577,7 +30793,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync11(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync12(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -30638,18 +30854,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname4(output.absolutePath);
+    const folder = dirname5(output.absolutePath);
     try {
-      mkdirSync5(folder, { recursive: true });
+      mkdirSync6(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname4(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname5(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
-    const exportLogs = mkdtempSync2(join11(tmpdir4(), "gdharness-export-"));
+    const exportLogs = mkdtempSync2(join12(tmpdir4(), "gdharness-export-"));
     const exportArgs = [
       "--headless",
       "--log-file",
-      join11(exportLogs, "engine.log"),
+      join12(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -30707,7 +30923,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync9(join11(project.value.path, runner))) {
+    if (!existsSync9(join12(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"
       ]);
@@ -30742,7 +30958,7 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync2(join11(tmpdir4(), "gdharness-tests-"));
+    const userData = mkdtempSync2(join12(tmpdir4(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const hung = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -30758,14 +30974,14 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join11(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join12(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
       const written = existsSync9(reportsDir) ? readdirSync6(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
       const newest = written.at(-1);
       if (newest !== undefined) {
-        report = parseJUnit(readFileSync11(join11(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync12(join12(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -30786,6 +31002,7 @@ class GodotServer {
     const said = printed.map((entry) => entry.text);
     const nothingRan = hung ? null : whyNoReport(said, asked);
     const verdict = hung ? `hung: killed after ${timeoutMs} ms` : nothingRan ?? verdicts[exitCode ?? -1] ?? `exit ${exitCode ?? "unknown"}`;
+    const savesNote = savesStayPut() && nothingRan === null ? SAVES_NOT_MOVED_NOTE : undefined;
     if (report === null) {
       const note = nothingRan === null ? `The test run wrote no report (${verdict}${reportProblem ? `; ${reportProblem}` : ""}).` : `No tests ran: ${verdict}.${elsewhereIn(project.value.path, asked)}`;
       return {
@@ -30800,7 +31017,8 @@ class GodotServer {
               exitCode,
               hung,
               arguments: cmdArgs,
-              entries: forAnswer(printed.slice(0, 60))
+              entries: forAnswer(printed.slice(0, 60)),
+              savesNote
             }, null, 2)
           }
         ],
@@ -30833,6 +31051,7 @@ class GodotServer {
       warnings: warnings.length > 0 ? warnings : undefined,
       orphans: orphans.total > 0 ? orphans.total : undefined,
       notRun: notRun > 0 ? notRun : undefined,
+      savesNote,
       note: verdict.startsWith("warnings") && warnings.length === 0 ? "gdUnit4 exits 101 for orphan nodes when nothing failed, and this run printed no count of them: orphan reporting may be off in the project settings." : notRun > 0 ? `This run stopped at the first failure in each suite it failed in, so ${notRun} case${notRun === 1 ? "" : "s"} never ran and count as neither passed nor failed. Leave failFast out to run every case.` : undefined,
       suites: unclean.map((suite) => ({
         name: suite.name,
@@ -30855,7 +31074,8 @@ class GodotServer {
   async godotVersion(godotPath) {
     try {
       const { stdout } = await run4(godotPath, ["--version"], { timeout: 1e4 });
-      return stdout.trim();
+      this.lastGodotVersion = stdout.trim();
+      return this.lastGodotVersion;
     } catch (error) {
       this.logDebug(`Godot did not answer --version: ${errorMessage(error)}`);
       return null;
@@ -30901,7 +31121,7 @@ class GodotServer {
         return null;
       }
       try {
-        return readFileSync11(contained.absolutePath, "utf8");
+        return readFileSync12(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -30943,7 +31163,7 @@ class GodotServer {
       return null;
     }
     try {
-      return readFileSync11(contained.absolutePath, "utf8");
+      return readFileSync12(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -31013,16 +31233,37 @@ class GodotServer {
     const status = this.godotBridge.getStatus();
     return (status.connected ? status[field] : undefined) ?? fallback;
   }
+  restartLeftUnfinished(connected) {
+    if (this.ownProject === null) {
+      return null;
+    }
+    const owed = restartOwed(this.ownProject);
+    if (owed === null) {
+      return null;
+    }
+    if (connected) {
+      restartSettled(this.ownProject);
+      return null;
+    }
+    return owed;
+  }
   getEditorStatusPayload() {
     const status = this.godotBridge.getStatus();
     const isPortConflict = this.bridgeStartupError?.includes("EADDRINUSE") ?? false;
     const stale = status.connected && status.addonVersion !== SERVER_VERSION;
+    const unfinished = this.restartLeftUnfinished(status.connected);
     return {
       ...status,
       serverVersion: SERVER_VERSION,
       addonIsStale: status.connected ? stale : undefined,
       bridgeAvailable: this.bridgeStartupError === null,
-      mayYetConnect: status.connected ? undefined : this.anEditorIsStillComing(status.listeningSince),
+      mayYetConnect: status.connected ? undefined : unfinished !== null ? false : this.anEditorIsStillComing(status.listeningSince),
+      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,
       ...status.connected ? this.whatTheLaunchedEditorDropped() : {},
       startupError: this.bridgeStartupError,
@@ -31058,7 +31299,7 @@ class GodotServer {
     }
   }
   async handleEditorStatus() {
-    const godotPath = await this.locator.find();
+    const located = await this.locator.find();
     const announced = runtimesAnnounced();
     const games = await Promise.all(announced.running.map(async (endpoint) => {
       const reply = await runtimeRequest(endpoint, "ping", {}, this.runtimeTimeoutMs());
@@ -31078,8 +31319,9 @@ class GodotServer {
         debugPort: playing?.debugPort ?? this.godotBridge.getStatus().debugPort
       },
       godot: {
-        path: godotPath,
-        version: godotPath === null ? null : await this.godotVersion(godotPath)
+        path: located.ok ? located.path : null,
+        version: located.ok ? await this.godotVersion(located.path) : null,
+        problem: located.ok ? undefined : GodotLocator.refusal(located).message
       },
       game: {
         processActive: runIsUp(this.currentRun(), playing === null ? null : playing.playing),
@@ -31098,12 +31340,12 @@ class GodotServer {
   }
   settingKeysOf(projectPath) {
     if (projectPath === undefined) {
-      return new Map;
+      return null;
     }
     try {
-      return settingKeys(readFileSync11(join11(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync12(join12(projectPath, "project.godot"), "utf8"));
     } catch {
-      return new Map;
+      return null;
     }
   }
   async handleRestartEditor() {
@@ -31163,12 +31405,21 @@ class GodotServer {
       lsp: this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT),
       dap: this.editorServes("dapPort", "GDHARNESS_DAP_PORT", DEFAULT_DAP_PORT)
     };
+    noteRestartBegun({
+      projectPath,
+      editorPid: editorPid ?? null,
+      ports,
+      quitAt: new Date().toISOString(),
+      byPid: process.pid
+    });
     const asked = await this.handleViaBridge("quit_editor", {});
     if (asked.isError === true) {
+      restartSettled(projectPath);
       return asked;
     }
     await this.waitForBridge(() => !alive(editorPid), Date.now() + EDITOR_RESTART_TIMEOUT_MS);
     const opened = await this.openAnEditor(engine.value, projectPath, ports);
+    restartSettled(projectPath);
     if (opened.error !== null) {
       return this.createErrorResponse(`The editor was asked to go and could not be started again: ${opened.error}`, [`editor_launch opens one on ${projectPath}`]);
     }
@@ -31204,10 +31455,12 @@ class GodotServer {
     this.logDebug(`Launching Godot editor for project: ${project.value.path}`);
     const ports = await this.portsForAnEditor();
     const before = this.settingKeysOf(project.value.path);
+    const unfinished = restartOwed(project.value.path);
     const opened = await this.openAnEditor(engine.value, project.value.path, ports);
     if (opened.error !== null) {
       return this.createErrorResponse(`Could not start the editor: ${opened.error}`);
     }
+    restartSettled(project.value.path);
     this.launchedFrom = { projectPath: project.value.path, before };
     return this.jsonTextResponse({
       launched: true,
@@ -31215,7 +31468,8 @@ class GodotServer {
       projectPath: project.value.path,
       lspPort: ports.lsp,
       dapPort: ports.dap,
-      settingsNote: before.size === 0 ? undefined : "Opening a project imports it and saves project.godot, and Godot drops any key sitting at its own default. editor_status names anything lost under settingsDropped once this editor has connected."
+      finishesRestart: unfinished === null ? undefined : `This is the launch half of a restart begun at ${unfinished.quitAt} by server pid ${unfinished.byPid}, which quit editor pid ${unfinished.editorPid ?? "unknown"} and was ended before it could start one.`,
+      settingsNote: before === null ? "project.godot could not be read before this editor was opened, so nothing here will be able to say what the import saved away. Opening a project rewrites the file and drops any key sitting at its own default." : before.size === 0 ? undefined : "Opening a project imports it and saves project.godot, and Godot drops any key sitting at its own default. editor_status names anything lost under settingsDropped once this editor has connected."
     });
   }
   async openAnEditor(engine, projectPath, ports) {
@@ -31332,13 +31586,17 @@ class GodotServer {
     return runIsUp(run, editorSays);
   }
   async runtimeUp(projectPath, before, budgetMs, withArgs) {
-    if (!existsSync9(join11(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync9(join12(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
     }
     const endpoint = await announcedSince(projectPath, before, {
       budgetMs,
       giveUp: () => this.dapClient?.isStopped() === true || !stillRunning(this.currentRun())
     });
+    const going = this.currentRun();
+    if (endpoint !== null && going?.throughEditor === true && going.announcedPid === undefined) {
+      going.announcedPid = endpoint.pid;
+    }
     return runtimeVerdict(endpoint, {
       addon: true,
       budgetMs,
@@ -31448,9 +31706,15 @@ class GodotServer {
       running.log.record("warning", `This run was not ended here: pid ${running.pid} no longer answers as the run that was recorded, so nothing was signalled. If that process is still the game, end it yourself; if it is not, it belongs to something else.`);
       return;
     }
+    const signalled = runningAs(running.pid);
+    const described = signalled === null ? "nothing it would name" : `${signalled.kind}: ${signalled.text}`;
+    let landed = true;
     try {
       process.kill(running.pid);
-    } catch {}
+    } catch {
+      landed = false;
+    }
+    running.log.record("info", landed ? `gdharness ended pid ${running.pid}, which the operating system described as ${described}.` : `gdharness signalled pid ${running.pid} and it was already gone; the operating system had described it as ${described}.`);
   }
   spawnGame(godotPath, cmdArgs, env) {
     const child = spawn(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
@@ -31788,7 +32052,7 @@ class GodotServer {
       notes.push(run.exitCode === 0 ? "This run quit on its own, cleanly: exit code 0." : "Nothing here ended this run: it stopped on its own or something outside this server stopped it.");
     }
     if (run.transcript !== null && selected.omitted > 0) {
-      notes.push(`Everything this run has printed is in ${run.transcript}, uncapped and still being written. Read it for output, not for whether the run is alive: running above is asked of the operating system, and a transcript that stops growing is a run between prints.`);
+      notes.push(`Everything this run has printed is in ${run.transcript}, uncapped and still being written. Read it for output, not for whether the run is alive: a transcript that stops growing is a run between prints. running above is asked of the operating system while there is a process to ask about, and for an editor-played run that announced no runtime it is the editor's answer instead, which can lag after the game has gone.`);
     }
     return this.jsonTextResponse({
       running: stillRunning(run),
@@ -31990,8 +32254,8 @@ class GodotServer {
       return this.createErrorResponse(choice.problem);
     }
     const expectsScreenshot = command === "capture_screenshot" || command === "capture_viewport";
-    const screenshotDir = expectsScreenshot ? mkdtempSync2(join11(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join11(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? mkdtempSync2(join12(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
+    const screenshotPath = screenshotDir ? join12(screenshotDir, "capture.png") : null;
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs);
       if (!reply.ok) {
@@ -32012,7 +32276,7 @@ class GodotServer {
       return {
         content: [
           { type: "text", text: `Screenshot captured: ${dimensions}` },
-          { type: "image", data: readFileSync11(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync12(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {