gdharness 0.13.35 → 0.13.37

package/build/cli.js

@@ -133,6 +133,28 @@ function godotCandidates(platform, home) {
 }
 var init_detection = () => {};
 
+// src/errors.ts
+function errorMessage(error, fallback = "Unknown error") {
+  if (error instanceof Error) {
+    return error.message || fallback;
+  }
+  if (typeof error === "string") {
+    return error || fallback;
+  }
+  if (typeof error === "number" || typeof error === "boolean") {
+    return String(error);
+  }
+  return fallback;
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(errorMessage(error), { cause: error });
+}
+var Refusal2;
+var init_errors = __esm(() => {
+  Refusal2 = class Refusal2 extends Error {
+  };
+});
+
 // src/launch.ts
 function envValue(name, variables = process.env) {
   const value = variables[name];
@@ -176,7 +198,10 @@ function userDataIn(home, variables = process.env) {
   }
   return carried;
 }
-var OPENED_BY_A_SERVER = "GDHARNESS_OPENED_BY_A_SERVER";
+function savesStayPut(platform = process.platform) {
+  return platform === "darwin";
+}
+var OPENED_BY_A_SERVER = "GDHARNESS_OPENED_BY_A_SERVER", 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.";
 
 // node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS(function(exports) {
@@ -7120,28 +7145,6 @@ var require_public_api = __commonJS(function(exports) {
   exports.stringify = stringify;
 });
 
-// src/errors.ts
-function errorMessage(error, fallback = "Unknown error") {
-  if (error instanceof Error) {
-    return error.message || fallback;
-  }
-  if (typeof error === "string") {
-    return error || fallback;
-  }
-  if (typeof error === "number" || typeof error === "boolean") {
-    return String(error);
-  }
-  return fallback;
-}
-function toError(error) {
-  return error instanceof Error ? error : new Error(errorMessage(error), { cause: error });
-}
-var Refusal2;
-var init_errors = __esm(() => {
-  Refusal2 = class Refusal2 extends Error {
-  };
-});
-
 // src/runner.ts
 import { existsSync as existsSync3 } from "node:fs";
 import { dirname, join as join2 } from "node:path";
@@ -7200,7 +7203,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(`
@@ -7257,10 +7260,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;
@@ -7274,11 +7281,16 @@ class GameLog {
     return { entries: matching.slice(omitted), omitted };
   }
 }
-var HEADLINE, COLOUR_CODE, STREAMS;
+var HEADLINE, COLOUR_CODE, STREAMS, ADMITTED;
 var init_game_log = __esm(() => {
   HEADLINE = /^(USER )?(SCRIPT ERROR|ERROR|WARNING):\s?(.*)$/;
   COLOUR_CODE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
   STREAMS = ["stdout", "stderr", "transcript"];
+  ADMITTED = {
+    error: new Set(["error"]),
+    warning: new Set(["error", "warning"]),
+    info: new Set(["error", "warning", "info"])
+  };
 });
 
 // src/scratch.ts
@@ -7311,6 +7323,20 @@ var init_scratch = __esm(() => {
 import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
 import { join as join5 } from "node:path";
+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);
+  }
+}
 function cacheDirectory(environment) {
   const set = (name) => {
     const value = environment[name];
@@ -7380,8 +7406,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)
@@ -7413,16 +7439,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;
@@ -7430,11 +7459,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;
@@ -7473,10 +7503,10 @@ class UpdateCheck {
     };
   }
 }
-var REGISTRY = "https://registry.npmjs.org/gdharness/latest", RELEASES = "https://github.com/Aureliolo/gdharness/releases/tag", CACHE_MS, REQUEST_TIMEOUT_MS = 1e4, MAX_BODY_BYTES, FIRST_RETRY_MS = 30000, MAX_RETRY_MS, VERSION;
+var REGISTRY_ROOT = "https://registry.npmjs.org", RELEASES = "https://github.com/Aureliolo/gdharness/releases/tag", CACHE_MS, REQUEST_TIMEOUT_MS = 1e4, MAX_BODY_BYTES, FIRST_RETRY_MS = 30000, MAX_RETRY_MS, VERSION;
 var init_update_check = __esm(() => {
   init_runner();
-  CACHE_MS = 4 * 60 * 60 * 1000;
+  CACHE_MS = 10 * 60 * 1000;
   MAX_BODY_BYTES = 1 << 20;
   MAX_RETRY_MS = 60 * 60 * 1000;
   VERSION = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
@@ -7625,7 +7655,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) {
@@ -15048,6 +15078,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 {};
@@ -15665,7 +15700,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       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: {
@@ -15932,7 +15967,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       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: {
@@ -15994,7 +16029,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       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",
@@ -16003,7 +16038,7 @@ var init_tool_definitions = __esm(() => {
         },
         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",
@@ -16022,7 +16057,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       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: []
     },
@@ -35225,57 +35260,77 @@ import { execFile as execFile4 } from "node:child_process";
 import { existsSync as existsSync11 } from "node:fs";
 import { normalize as normalize2 } from "node:path";
 import { promisify as promisify4 } from "node:util";
-var run4, GodotLocator2;
-var init_godot_path = __esm(() => {
-  init_detection();
-  run4 = promisify4(execFile4);
-  GodotLocator2 = class GodotLocator2 {
-    answered = new Map;
-    found = null;
-    async find() {
-      if (this.found !== null && await this.answers(this.found)) {
-        return this.found;
-      }
-      this.found = null;
-      const named = envValue("GODOT_PATH");
-      if (named !== undefined) {
-        const path = normalize2(named);
-        if (await this.answers(path)) {
-          this.found = path;
-        }
-        return this.found;
-      }
-      for (const candidate of godotCandidates(process.platform, resolveHomeDirectory())) {
-        const path = normalize2(candidate);
-        if (await this.answers(path)) {
-          this.found = path;
-          return path;
-        }
+
+class GodotLocator2 {
+  answered = new Map;
+  found = null;
+  async find() {
+    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 = normalize2(named);
+      const reason = await this.whyNot(path);
+      if (reason === null) {
+        this.found = path;
+        return { ok: true, path };
       }
-      return null;
+      return { ok: false, named: path, reason };
     }
-    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) {
-      const known = this.answered.get(path);
-      if (known !== undefined) {
-        return known;
+    for (const candidate of godotCandidates(process.platform, resolveHomeDirectory())) {
+      const path = normalize2(candidate);
+      if (await this.whyNot(path) === null) {
+        this.found = path;
+        return { ok: true, path };
       }
-      let ok = false;
-      if (path === "godot" || existsSync11(path)) {
-        try {
-          await run4(path, ["--version"]);
-          ok = true;
-        } catch {
-          ok = false;
-        }
+    }
+    return { ok: false, named: null };
+  }
+  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 reason;
+    if (path !== "godot" && !existsSync11(path)) {
+      reason = "does not exist";
+    } else {
+      try {
+        await run4(path, ["--version"]);
+        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;
+  }
+}
+var run4;
+var init_godot_path = __esm(() => {
+  init_detection();
+  init_errors();
+  run4 = promisify4(execFile4);
 });
 
 // src/issues.ts
@@ -35344,15 +35399,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 ?? ""}`),
     "",
@@ -36315,11 +36391,53 @@ var init_project_scan = __esm(() => {
   CARRIES_A_UID = new Set(["gd", "shader", "gdshader"]);
 });
 
+// src/restart-note.ts
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync13, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname9, join as join15 } from "node:path";
+function restartNotePath(projectPath) {
+  return join15(projectPath, ".godot", "gdharness-restart.json");
+}
+function noteRestartBegun(note) {
+  const path = restartNotePath(note.projectPath);
+  try {
+    mkdirSync7(dirname9(path), { recursive: true });
+    writeFileSync9(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(readFileSync13(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 {
+    rmSync7(restartNotePath(projectPath), { force: true });
+  } catch (error) {
+    console.error(`[SERVER] Could not clear the restart note: ${errorMessage(error)}`);
+  }
+}
+var init_restart_note = __esm(() => {
+  init_errors();
+});
+
 // src/runtime-client.ts
-import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync13, unlinkSync } from "node:fs";
+import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync14, unlinkSync } from "node:fs";
 import { createConnection as createConnection3 } from "node:net";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join15, resolve as resolve4 } from "node:path";
+import { join as join16, resolve as resolve4 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
 function runtimeDirectory(variables = process.env) {
   const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
@@ -36327,13 +36445,13 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join15(perUser ?? tmpdir4(), "gdharness");
+  return join16(perUser ?? tmpdir4(), "gdharness");
 }
 function runtimeDirectories(variables = process.env) {
   const candidates = [runtimeDirectory(variables)];
   const fallbacks = process.platform === "win32" ? [envValue("SystemRoot", variables) ?? envValue("windir", variables) ?? "C:\\Windows"] : ["/tmp", "/var/tmp"];
   for (const base of fallbacks) {
-    candidates.push(join15(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+    candidates.push(join16(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
   return [...new Set(candidates.map((path) => resolve4(path)))];
 }
@@ -36348,7 +36466,7 @@ function processAlive(pid) {
 function parseAnnouncement(file, pid) {
   let fields;
   try {
-    fields = asParams(JSON.parse(readFileSync13(file, "utf8")));
+    fields = asParams(JSON.parse(readFileSync14(file, "utf8")));
   } catch {
     return { kind: "rubbish" };
   }
@@ -36386,6 +36504,28 @@ function runtimesAnnounced(directories = runtimeDirectories()) {
 function discoverRuntimes(directories = runtimeDirectories()) {
   return runtimesAnnounced(directories).running;
 }
+function wentAway(file, pid) {
+  let project = "";
+  try {
+    const fields = asParams(JSON.parse(readFileSync14(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 (!existsSync13(directory)) {
     return [];
@@ -36396,10 +36536,14 @@ function announcedIn(directory) {
     if (!match) {
       continue;
     }
-    const file = join15(directory, entry);
+    const file = join16(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 {}
@@ -36438,6 +36582,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."
     };
@@ -36551,43 +36705,44 @@ function runtimeRequest(endpoint, command, params, timeoutMs) {
     });
   });
 }
-var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1;
+var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, GONE_WINDOW_MS = 120000, GONE_KEPT = 32, gone, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1;
 var init_runtime_client = __esm(() => {
   ANNOUNCEMENT_PATTERN = /^runtime-(\d+)\.json$/;
+  gone = [];
 });
 
 // src/run-record.ts
 import { execFileSync } from "node:child_process";
-import { mkdirSync as mkdirSync7, openSync, readdirSync as readdirSync6, readFileSync as readFileSync14, rmSync as rmSync7, statSync as statSync3, writeFileSync as writeFileSync9 } from "node:fs";
-import { basename as basename2, join as join16 } from "node:path";
+import { mkdirSync as mkdirSync8, openSync, readdirSync as readdirSync6, readFileSync as readFileSync15, rmSync as rmSync8, statSync as statSync3, writeFileSync as writeFileSync10 } from "node:fs";
+import { basename as basename2, join as join17 } from "node:path";
 function runsDirectory() {
-  return join16(runtimeDirectory(), "runs");
+  return join17(runtimeDirectory(), "runs");
 }
 function recordPath() {
-  return join16(runsDirectory(), "run.json");
+  return join17(runsDirectory(), "run.json");
 }
 function recordPaths() {
-  return runtimeDirectories().map((directory) => join16(directory, "runs", "run.json"));
+  return runtimeDirectories().map((directory) => join17(directory, "runs", "run.json"));
 }
 function openTranscript(startedAt) {
-  mkdirSync7(runsDirectory(), { recursive: true });
-  const path = join16(runsDirectory(), `run-${startedAt}.log`);
+  mkdirSync8(runsDirectory(), { recursive: true });
+  const path = join17(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync(path, "a") };
 }
 function writeRunRecord(record) {
-  mkdirSync7(runsDirectory(), { recursive: true });
-  writeFileSync9(recordPath(), JSON.stringify(record, null, 2), "utf8");
+  mkdirSync8(runsDirectory(), { recursive: true });
+  writeFileSync10(recordPath(), JSON.stringify(record, null, 2), "utf8");
 }
 function editorNotePath() {
-  return join16(runsDirectory(), "editor-run.json");
+  return join17(runsDirectory(), "editor-run.json");
 }
 function writeEditorRunNote(note) {
-  mkdirSync7(runsDirectory(), { recursive: true });
-  writeFileSync9(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
+  mkdirSync8(runsDirectory(), { recursive: true });
+  writeFileSync10(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
 }
 function readEditorRunNote() {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(join16(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(join17(directory, "runs", "editor-run.json"));
     if (note !== null) {
       return note;
     }
@@ -36597,7 +36752,7 @@ function readEditorRunNote() {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync14(path, "utf8"));
+    parsed = JSON.parse(readFileSync15(path, "utf8"));
   } catch {
     return null;
   }
@@ -36620,7 +36775,7 @@ function recordRunEnded(pid, exitCode) {
     return;
   }
   try {
-    writeFileSync9(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
+    writeFileSync10(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
   } catch {}
 }
 function readRunRecord() {
@@ -36635,7 +36790,7 @@ function readRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync14(path, "utf8"));
+    parsed = JSON.parse(readFileSync15(path, "utf8"));
   } catch {
     return null;
   }
@@ -36662,23 +36817,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 = readFileSync14(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
-      return raw === "" ? null : { kind: "commandLine", text: raw };
+      const raw = readFileSync15(`/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;
   }
@@ -36717,13 +36881,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"], {
@@ -36746,6 +36927,9 @@ 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 : basename2(record.command);
   const said = process.platform === "win32" ? running.text.toLowerCase() : running.text;
   const wanted = engine === null || process.platform !== "win32" ? engine : engine.toLowerCase();
@@ -36771,7 +36955,7 @@ function clearRunRecord(ours = () => true) {
       continue;
     }
     try {
-      rmSync7(path);
+      rmSync8(path);
     } catch {}
   }
 }
@@ -36795,16 +36979,16 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join16(directory, entry);
+    const path = join17(directory, entry);
     if (path === keep || ageMs(path, now) < keepMs) {
       continue;
     }
     try {
-      rmSync7(path);
+      rmSync8(path);
     } catch {}
   }
 }
-var AN_EDITOR;
+var AN_EDITOR, SAME_RUN_WINDOW_MS = 1e4;
 var init_run_record = __esm(() => {
   init_runtime_client();
   AN_EDITOR = /(?:^|\s)(?:-e|--editor)(?:\s|$)/;
@@ -36818,15 +37002,15 @@ import {
   closeSync,
   existsSync as existsSync14,
   fstatSync,
-  mkdirSync as mkdirSync8,
+  mkdirSync as mkdirSync9,
   mkdtempSync as mkdtempSync3,
   openSync as openSync2,
   readdirSync as readdirSync7,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   readSync
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename3, dirname as dirname9, join as join17, normalize as normalize3 } from "node:path";
+import { basename as basename3, dirname as dirname10, join as join18, normalize as normalize3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { promisify as promisify6 } from "node:util";
@@ -36840,12 +37024,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) {
@@ -36975,7 +37165,7 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync14(join17(projectPath, wanted))) {
+  if (wanted === "" || existsSync14(join18(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -36989,11 +37179,11 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync15(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync16(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync15(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync16(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -37009,7 +37199,7 @@ function camelCased(params) {
 class GodotServer {
   mcp;
   locator = new GodotLocator2;
-  operationsScript = join17(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join18(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -37017,6 +37207,8 @@ class GodotServer {
   noticedUpdate = false;
   callsSinceNotice = 0;
   callsSinceFeedback = 0;
+  defectsSeen = new DefectsSeen;
+  lastGodotVersion = null;
   lspClient = null;
   dapClient = null;
   bridgeStartupError = null;
@@ -37061,11 +37253,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] ${GodotLocator2.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);
@@ -37265,7 +37457,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) {
@@ -37626,21 +37830,19 @@ class GodotServer {
     }
   }
   async engine() {
-    const godotPath = await this.locator.find();
-    if (godotPath === null) {
-      return {
-        ok: false,
-        response: this.createErrorResponse("No Godot executable found.", GodotLocator2.ADVICE)
-      };
+    const located = await this.locator.find();
+    if (!located.ok) {
+      const refusal = GodotLocator2.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 = join17(path, "project.godot");
+    const file = join18(path, "project.godot");
     if (!existsSync14(file)) {
       return {
         ok: false,
@@ -37782,7 +37984,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);
@@ -37805,7 +38007,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 runOperation2({ godotPath: engine.value, script: this.operationsScript, debug: GODOT_DEBUG_MODE_DEFAULT }, operation, params, projectPath);
@@ -37837,7 +38043,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync15(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync16(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -37898,18 +38104,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname9(output.absolutePath);
+    const folder = dirname10(output.absolutePath);
     try {
-      mkdirSync8(folder, { recursive: true });
+      mkdirSync9(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname9(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname10(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
-    const exportLogs = mkdtempSync3(join17(tmpdir5(), "gdharness-export-"));
+    const exportLogs = mkdtempSync3(join18(tmpdir5(), "gdharness-export-"));
     const exportArgs = [
       "--headless",
       "--log-file",
-      join17(exportLogs, "engine.log"),
+      join18(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -37967,7 +38173,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync14(join17(project.value.path, runner))) {
+    if (!existsSync14(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"
       ]);
@@ -38002,7 +38208,7 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync3(join17(tmpdir5(), "gdharness-tests-"));
+    const userData = mkdtempSync3(join18(tmpdir5(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const hung = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -38018,14 +38224,14 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join17(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join18(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
       const written = existsSync14(reportsDir) ? readdirSync7(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(readFileSync15(join17(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync16(join18(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -38046,6 +38252,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 {
@@ -38060,7 +38267,8 @@ class GodotServer {
               exitCode,
               hung,
               arguments: cmdArgs,
-              entries: forAnswer(printed.slice(0, 60))
+              entries: forAnswer(printed.slice(0, 60)),
+              savesNote
             }, null, 2)
           }
         ],
@@ -38093,6 +38301,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,
@@ -38115,7 +38324,8 @@ class GodotServer {
   async godotVersion(godotPath) {
     try {
       const { stdout } = await run6(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;
@@ -38161,7 +38371,7 @@ class GodotServer {
         return null;
       }
       try {
-        return readFileSync15(contained.absolutePath, "utf8");
+        return readFileSync16(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -38203,7 +38413,7 @@ class GodotServer {
       return null;
     }
     try {
-      return readFileSync15(contained.absolutePath, "utf8");
+      return readFileSync16(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -38273,16 +38483,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,
@@ -38318,7 +38549,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());
@@ -38338,8 +38569,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 : GodotLocator2.refusal(located).message
       },
       game: {
         processActive: runIsUp(this.currentRun(), playing === null ? null : playing.playing),
@@ -38358,12 +38590,12 @@ class GodotServer {
   }
   settingKeysOf(projectPath) {
     if (projectPath === undefined) {
-      return new Map;
+      return null;
     }
     try {
-      return settingKeys(readFileSync15(join17(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync16(join18(projectPath, "project.godot"), "utf8"));
     } catch {
-      return new Map;
+      return null;
     }
   }
   async handleRestartEditor() {
@@ -38423,12 +38655,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}`]);
     }
@@ -38464,10 +38705,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,
@@ -38475,7 +38718,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) {
@@ -38592,13 +38836,17 @@ class GodotServer {
     return runIsUp(run, editorSays);
   }
   async runtimeUp(projectPath, before, budgetMs, withArgs) {
-    if (!existsSync14(join17(projectPath, RUNTIME_AUTOLOAD2.path))) {
+    if (!existsSync14(join18(projectPath, RUNTIME_AUTOLOAD2.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,
@@ -38708,9 +38956,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 } : {} });
@@ -39048,7 +39302,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),
@@ -39250,8 +39504,8 @@ class GodotServer {
       return this.createErrorResponse(choice.problem);
     }
     const expectsScreenshot = command === "capture_screenshot" || command === "capture_viewport";
-    const screenshotDir = expectsScreenshot ? mkdtempSync3(join17(tmpdir5(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join17(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? mkdtempSync3(join18(tmpdir5(), "gdharness-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);
       if (!reply.ok) {
@@ -39272,7 +39526,7 @@ class GodotServer {
       return {
         content: [
           { type: "text", text: `Screenshot captured: ${dimensions}` },
-          { type: "image", data: readFileSync15(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync16(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
@@ -39361,6 +39615,7 @@ var init_server3 = __esm(() => {
   init_process_time();
   init_project_scan();
   init_resources();
+  init_restart_note();
   init_run_record();
   init_runtime_client();
   init_scratch();
@@ -39369,7 +39624,7 @@ var init_server3 = __esm(() => {
   init_tool_definitions();
   init_update_check();
   run6 = promisify6(execFile6);
-  __dirname2 = dirname9(fileURLToPath4(import.meta.url));
+  __dirname2 = dirname10(fileURLToPath4(import.meta.url));
   VALUE_NAMES = {
     string: "a string",
     number: "a number",
@@ -39408,7 +39663,7 @@ var init_server3 = __esm(() => {
 
 // src/cli.ts
 import { existsSync as existsSync15 } from "fs";
-import { join as join18, resolve as resolve5 } from "path";
+import { join as join19, resolve as resolve5 } from "path";
 
 // src/errors.ts
 class Refusal extends Error {
@@ -39416,6 +39671,7 @@ class Refusal extends Error {
 
 // src/godot-path.ts
 init_detection();
+init_errors();
 import { execFile } from "node:child_process";
 import { existsSync as existsSync2 } from "node:fs";
 import { normalize } from "node:path";
@@ -39426,47 +39682,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" || existsSync2(path)) {
+    let reason;
+    if (path !== "godot" && !existsSync2(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;
   }
 }
 
@@ -40246,15 +40520,27 @@ function disconnect(harness, projectPath) {
 `, "utf8");
   return { harness, path, action: "removed" };
 }
-function harnessNote(moved, now) {
-  if (moved.length === 0) {
+function harnessNote(repinned, now) {
+  const alsoByHand = repinned.byHand === 0 ? "" : `
+     ${repinned.byHand === 1 ? "One harness above was" : `${repinned.byHand} harnesses above were`} handed a command to run instead; run it too.`;
+  if (repinned.moved.length > 0) {
+    return `  2. Your harness is still running the server it spawned from ${repinned.moved.join(", ")}.
+` + `     Its config names ${now} now.
+` + `     Reconnect the MCP server, or restart the harness.${alsoByHand}`;
+  }
+  if (repinned.written > 0) {
     return `  2. Your harness config already named this version, but the server it is running is
 ` + `     whichever one it spawned when the session started, which this cannot see from here.
-` + "     Reconnect the MCP server, or restart the harness.";
+` + `     Reconnect the MCP server, or restart the harness.${alsoByHand}`;
   }
-  return `  2. Your harness is still running the server it spawned from ${moved.join(", ")}.
-` + `     Its config names ${now} now.
-` + "     Reconnect the MCP server, or restart the harness.";
+  if (repinned.byHand > 0) {
+    return `  2. None of the harness configs found here can be written for you, so nothing was
+` + `     re-pinned and a reconnect on its own would come back on the same server.
+` + "     Run what is printed above, then reconnect the MCP server or restart the harness.";
+  }
+  return `  2. No harness config here names gdharness, so nothing was re-pinned and there is no
+` + `     config for a reconnect to read. Run  gdharness setup  to write one, or point your
+` + `     harness at  ${now}  yourself, then restart it.`;
 }
 function launchedBy(entry) {
   if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
@@ -40470,15 +40756,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 ?? ""}`),
     "",
@@ -40615,14 +40912,14 @@ function loaderAmong(projectPath, named) {
     if (entry === RUNTIME_AUTOLOAD.name || path === RUNTIME_AUTOLOAD.path) {
       continue;
     }
-    let source = "";
+    let source = null;
     try {
       source = readFileSync7(join8(projectPath, path), "utf8");
     } catch {}
-    if (source.includes(RUNTIME_AUTOLOAD.path)) {
-      return { name: entry, path };
+    if (source?.includes(RUNTIME_AUTOLOAD.path)) {
+      return { name: entry, path, exists: true };
     }
-    byName ??= path.toLowerCase().includes("gdharness") ? { name: entry, path } : null;
+    byName ??= path.toLowerCase().includes("gdharness") ? { name: entry, path, exists: source !== null } : null;
   }
   return byName;
 }
@@ -40685,8 +40982,15 @@ function inspectProject(projectPath) {
   const runtimeLoaderAutoload = loaderAmong(projectPath, named);
   const runtimeAutoload = runtimeAutoloadPath !== null || runtimeLoaderAutoload !== null;
   const tracked = trackedByGit(projectPath, [...named.values()]);
+  const addonMissing = (path) => addons.some((addon) => !addon.installed && path.startsWith(`addons/${addon.name}/`));
   for (const [name, path] of named) {
-    if (tracked !== null && !tracked.has(path) && existsSync7(join8(projectPath, path))) {
+    if (!existsSync7(join8(projectPath, path))) {
+      if (!addonMissing(path)) {
+        problems.push(`the ${name} autoload names res://${path}, which is not in this project, so it boots with a missing script; restore that file, or point the autoload at one that is here`);
+      }
+      continue;
+    }
+    if (tracked !== null && !tracked.has(path)) {
       problems.push(`the ${name} autoload names res://${path}, which git does not carry, so a clone boots with a missing script; commit that file, or point the autoload at one the project tracks`);
     }
   }
@@ -40844,8 +41148,13 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
   with their backtraces, and a \`clean\` verdict, so a run that printed an error is one call away
   from being known. For a long run it also names a transcript file: read that for output and this
   answer for state. Never decide a run has ended by watching the file stop growing, or a process
-  list, or a timeout. \`running\` is asked of the operating system and \`endedBy\` says whether
-  gdharness ended it; a bench between prints looks exactly like a bench that died to everything else.
+  list, or a timeout; a bench between prints looks exactly like a bench that died to everything else.
+  \`endedBy\` says whether gdharness ended it, and \`running\` is asked of the operating system
+  whenever there is a process to ask about: every run started through \`editor_run\`, and every
+  editor-played run whose game announced its runtime. An editor-played run in a project with no
+  runtime addon announces nothing, so there is no process id and \`running\` is the editor's answer,
+  which can lag by seconds after the game has gone. \`editor_status\` names the game under
+  \`runtimes\`, which does not depend on the editor answering.
 - One server, one editor. A second project is a second harness session with its own server, and
   that works: each editor is opened on its own language server and debug adapter ports, and says
   where it serves. Two editors on one project is the thing to refuse.
@@ -40856,10 +41165,12 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | --- | --- |
 | What a screen says | \`runtime_inspect text\`, which reads what is drawn and leaves out what is hidden. Read \`omitted\`: a long list above a dialog pushes it past the limit, and what comes back then is the top of the screen rather than the screen |
 | Find a control by the word on it | \`runtime_inspect find\` with \`says\`, rather than listing a screen and reading each one |
+| What a control is showing | \`runtime_inspect find\` with \`property\` as well: the value comes back on each match in the same answer, so the game cannot tick between finding the node and reading it. A \`find\` followed by a \`property\` read of the path it answered is two calls with a frame between them, and a panel that rebuilds itself answers the second with "Node not found" |
 | Where a control is, and whether it is visible | \`runtime_inspect\` \`find\`, \`rect\` |
-| What a property reads right now | \`runtime_inspect\` \`property\`, \`runtime_invoke\` |
+| What a property reads right now, on a node whose path you already hold | \`runtime_inspect\` \`property\`, \`runtime_invoke\` |
 | What a property on an object a node holds reads | the same two, with colons: \`_game:clock:speed\` |
 | Press a button | \`runtime_input click\`, which says what was under the pointer |
+| Press the next thing after a click that changed screen | \`runtime_wait until\` with \`says\` and a word the new screen shows, then the click. A click sent straight after a screen change lands on a control the new screen is about to free, answers \`landed: true\`, and does nothing; a frame count is a number nobody can pick correctly across a cold start and a warm one, and waiting for the words answered in about 130ms where twenty frames had not been enough |
 | Fill in a field | \`runtime_input click\` on it, then \`runtime_input text\` with \`replace\`; a submitted field has to be clicked again |
 | Click somebody standing in a 3D room | \`runtime_input click\` on the Node3D, which aims at what it draws |
 | Pick something out of a dropdown | \`runtime_input choose\` on it, by what the item says |
@@ -40915,8 +41226,9 @@ its own copy. So a long run is not a reason to stop editing, and the new code ar
 A wall of "Could not find type" on the project's own classes means the editor is not holding
 them. \`editor_rescan\` asks it to scan and names any class it still cannot resolve under
 \`unseenByEditor\`: its walk skips a file a headless engine has already imported, so the
-declaration and the cache can both be right while the editor stays blind to it. Change the
-declaring script, or restart the editor.
+declaration and the cache can both be right while the editor stays blind to it. Rescan again on
+its own, which is the measured cure and needs no change to the declaring script; \`editor_launch
+restart\` also does it and costs a window.
 
 The scan writes \`.godot/global_script_class_cache.cfg\` from the list the editor is holding, so
 a class it cannot resolve is dropped out of that file too, and the next fresh engine, CI run or
@@ -41039,17 +41351,22 @@ class UsageError extends Refusal {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve5(named ?? ".");
-  if (!existsSync15(join18(projectPath, "project.godot"))) {
+  if (!existsSync15(join19(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
 }
 async function engine(projectPath) {
-  const godotPath = await new GodotLocator().find() ?? (projectPath === undefined ? null : recordedEnginePath(projectPath));
-  if (godotPath === null) {
-    throw new UsageError(`No Godot executable found. ${GodotLocator.ADVICE.join(". ")}.`);
+  const located = await new GodotLocator().find();
+  if (located.ok) {
+    return { godotPath: located.path, script: shippedOperationsScript(), debug: GODOT_DEBUG_MODE_DEFAULT2 };
+  }
+  const recorded = located.named === null && projectPath !== undefined ? recordedEnginePath(projectPath) : null;
+  if (recorded === null) {
+    const refusal = GodotLocator.refusal(located);
+    throw new UsageError(`${refusal.message} ${refusal.advice.join(". ")}.`);
   }
-  return { godotPath, script: shippedOperationsScript(), debug: GODOT_DEBUG_MODE_DEFAULT2 };
+  return { godotPath: recorded, script: shippedOperationsScript(), debug: GODOT_DEBUG_MODE_DEFAULT2 };
 }
 function said2(outcome, what) {
   if (!outcome.ok) {
@@ -41073,7 +41390,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync15(join18(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync15(join19(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
     console.log(`  that file is not in this project, so it boots with a missing script: restore it, or point the entry at res://${RUNTIME_AUTOLOAD.path}`);
   }
 }
@@ -41131,7 +41448,7 @@ function reportConnection(group, launch, projectPath) {
   const written = connect(group.writer, projectPath, launch);
   if (written.action === "command") {
     console.log(`${who}: run  ${(written.command ?? []).join(" ")}`);
-    return;
+    return { kind: "byHand" };
   }
   if (written.action === "snippet") {
     console.log(`${who}: put this in ${written.path}`);
@@ -41139,7 +41456,7 @@ function reportConnection(group, launch, projectPath) {
 `)) {
       console.log(`  ${line}`);
     }
-    return;
+    return { kind: "byHand" };
   }
   console.log(`${who}: ${written.action} ${written.path}`);
   if (written.wasLaunchedBy !== undefined) {
@@ -41151,7 +41468,7 @@ function reportConnection(group, launch, projectPath) {
       console.log(`  ${harness.name}: ${harness.manual}`);
     }
   }
-  return written.wasLaunchedBy;
+  return { kind: "written", from: written.wasLaunchedBy ?? null };
 }
 function nextSteps(projectPath, runtime) {
   console.log(`
@@ -41285,14 +41602,18 @@ async function upgrade() {
   const launch = launchFor(version, godot.godotPath, projectPath);
   const already = HARNESSES.filter((harness) => registered(harness, projectPath));
   const moved = [];
+  let written = 0;
+  let byHand = 0;
   for (const group of groupByFile(already, projectPath)) {
-    const was = reportConnection(group, launch, projectPath);
-    if (was !== undefined && !moved.includes(was)) {
-      moved.push(was);
+    const took = reportConnection(group, launch, projectPath);
+    if (took.kind === "byHand") {
+      byHand += 1;
+      continue;
+    }
+    written += 1;
+    if (took.from !== null && !moved.includes(took.from)) {
+      moved.push(took.from);
     }
-  }
-  if (already.length === 0) {
-    console.log("no harness config names gdharness, so none was re-pinned");
   }
   for (const written of writeSkill(skillDirectories(already, projectPath, existsSync15), version)) {
     console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
@@ -41301,7 +41622,7 @@ async function upgrade() {
 On ${version}. Two things this could not do for you:`);
   console.log(`  1. The open editor is still running the addons it loaded at startup. Restart it with the
 ` + "     editor_launch restart tool, which closes and reopens the window.");
-  console.log(harnessNote(moved, [launch.command, ...launch.args].join(" ")));
+  console.log(harnessNote({ moved, written, byHand }, [launch.command, ...launch.args].join(" ")));
 }
 function doctorReport(projectPath) {
   const report = inspectProject(projectPath);
@@ -41312,7 +41633,8 @@ function doctorReport(projectPath) {
       console.log(`addons/${addon.name}: ${addon.installed ? `installed, ${addon.version ?? "unknown version"}${addon.current ? "" : " (not this version)"}` : "missing"}`);
     }
     console.log(`editor plugins enabled: ${report.pluginsEnabled.join(", ") || "none"}`);
-    console.log(`runtime autoload: ${report.runtimeLoaderAutoload === null ? report.runtimeAutoload ? "registered" : "not registered" : `registered through res://${report.runtimeLoaderAutoload.path}, as ${report.runtimeLoaderAutoload.name}`}`);
+    const loader = report.runtimeLoaderAutoload;
+    console.log(`runtime autoload: ${loader === null ? report.runtimeAutoload ? "registered" : "not registered" : `registered through res://${loader.path}, as ${loader.name}${loader.exists ? "" : ", and that file is not in this project"}`}`);
     console.log(report.classCacheExists ? `class cache: ${report.staleClasses.length === 0 ? "current" : `stale for ${report.staleClasses.join(", ")}`}` : "class cache: missing");
     for (const problem of report.problems) {
       console.log(`problem: ${problem}`);