gdharness 1.1.22 → 1.1.24

package/build/cli.js

@@ -662,7 +662,7 @@ function environmentFor(options, variables = process.env) {
   const base = options.savesIn === undefined ? { ...variables } : userDataIn(options.savesIn, variables);
   return { ...base, ...options.env, GDHARNESS_RUNTIME_DIR: options.runtimeDirectory };
 }
-var OPENED_BY_A_SERVER = "GDHARNESS_OPENED_BY_A_SERVER", RESERVED_VARIABLE_PREFIX = "GDHARNESS_", 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.";
+var OPENED_BY_A_SERVER = "GDHARNESS_OPENED_BY_A_SERVER", EDITOR_PID_VARIABLE = "GDHARNESS_EDITOR_PID", RESERVED_VARIABLE_PREFIX = "GDHARNESS_", 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
 import { execFile as execFile2 } from "node:child_process";
@@ -7684,6 +7684,73 @@ var require_public_api = __commonJS(function(exports) {
   exports.stringify = stringify;
 });
 
+// src/paths.ts
+import { realpathSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+function realPathOr(path) {
+  try {
+    return realpathSync.native(path);
+  } catch {
+    return path;
+  }
+}
+function isSameDirectory(onePath, otherPath) {
+  return relative(realPathOr(resolve(onePath)), realPathOr(resolve(otherPath))) === "";
+}
+function isWithinRoot(rootPath, candidatePath) {
+  const step = relative(resolve(rootPath), resolve(candidatePath));
+  return step !== ".." && !step.startsWith(`..${sep}`) && !isAbsolute(step);
+}
+function resolveWithinProject(projectPath, candidatePath) {
+  const trimmed = candidatePath.trim();
+  if (trimmed === "") {
+    return { ok: false, reason: "Path is empty." };
+  }
+  if (trimmed.includes("\x00")) {
+    return { ok: false, reason: "Path contains a null byte." };
+  }
+  const withoutScheme = trimmed.startsWith(RESOURCE_SCHEME) ? trimmed.slice(RESOURCE_SCHEME.length) : trimmed;
+  if (withoutScheme.startsWith("uid://")) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' is a UID, and a file is judged here by where it is on disk, which a UID does not say. Give the file's res:// path.`
+    };
+  }
+  const scheme = OTHER_SCHEME.exec(withoutScheme);
+  if (scheme) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' uses the '${scheme[0]}' scheme, which names somewhere other than this project.`
+    };
+  }
+  if (withoutScheme.startsWith("/") || withoutScheme.startsWith("\\") || isAbsolute(withoutScheme)) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' is absolute; give a path inside the project, such as 'scenes/main.tscn'.`
+    };
+  }
+  if (withoutScheme.includes(":")) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' contains ':', which no file inside a project is named with.`
+    };
+  }
+  const root = resolve(projectPath);
+  const absolutePath = resolve(root, withoutScheme);
+  if (!isWithinRoot(root, absolutePath)) {
+    return { ok: false, reason: `Path '${trimmed}' resolves outside the project directory.` };
+  }
+  const relativePath = relative(root, absolutePath).split(sep).join("/");
+  if (relativePath === "") {
+    return { ok: false, reason: `Path '${trimmed}' is the project directory itself, not a file in it.` };
+  }
+  return { ok: true, absolutePath, relativePath };
+}
+var RESOURCE_SCHEME = "res://", OTHER_SCHEME;
+var init_paths = __esm(() => {
+  OTHER_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]+:\/\//;
+});
+
 // src/runner.ts
 import { existsSync as existsSync3 } from "node:fs";
 import { dirname as dirname2, join as join3 } from "node:path";
@@ -7897,22 +7964,22 @@ var init_engine_run = __esm(() => {
 
 // src/reimport.ts
 import { createHash } from "node:crypto";
-import { existsSync as existsSync5, readFileSync as readFileSync3, rmSync as rmSync3, statSync as statSync2, utimesSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { basename as basename2, join as join5 } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync3, rmSync as rmSync3, statSync as statSync3, utimesSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename as basename3, join as join5 } from "node:path";
 function forceNextImport(projectPath, resourcePath) {
   const relative = resourcePath.replace(/^res:\/\//, "");
   const sidecar = join5(projectPath, `${relative}.import`);
   if (!existsSync5(sidecar)) {
     return;
   }
-  const { atime, mtimeMs } = statSync2(sidecar);
+  const { atime, mtimeMs } = statSync3(sidecar);
   writeFileSync3(sidecar, readFileSync3(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
   utimesSync(sidecar, atime, new Date(mtimeMs + 2000));
   rmSync3(importRecord(projectPath, resourcePath), { force: true });
 }
 function importRecord(projectPath, resourcePath) {
   const digest = createHash("md5").update(resourcePath).digest("hex");
-  return join5(projectPath, ".godot", "imported", `${basename2(resourcePath)}-${digest}.md5`);
+  return join5(projectPath, ".godot", "imported", `${basename3(resourcePath)}-${digest}.md5`);
 }
 var init_reimport = () => {};
 
@@ -8038,7 +8105,7 @@ var init_scratch = __esm(() => {
 });
 
 // src/headless.ts
-import { existsSync as existsSync7, readFileSync as readFileSync4, realpathSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync4, realpathSync as realpathSync2, writeFileSync as writeFileSync4 } from "node:fs";
 import { dirname as dirname4, join as join7 } from "node:path";
 function snakeCased(params) {
   const result = emptyRecord();
@@ -8093,7 +8160,7 @@ function scriptFault(problems, script) {
 }
 function resolvedOr(path) {
   try {
-    return realpathSync.native(path);
+    return realpathSync2.native(path);
   } catch {
     return path;
   }
@@ -8446,23 +8513,51 @@ function sameCodeNote(addonVersion, serverVersion, addonDigest, shippedDigest) {
   }
   return `The editor loaded the ${addonVersion} addons, which are the same code this ${serverVersion} server ships, so nothing needs restarting; addonVersion changes at the next editor start.`;
 }
-function addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest) {
+function addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest, onDisk) {
   if (!editorIsStale(addonVersion, serverVersion, addonDigest, shippedDigest)) {
     return;
   }
   const reported = addonVersion ?? "";
+  const restart = onDisk !== undefined && onDisk !== shippedDigest ? `The project's own addons are not this server's either, so a restart would load the same code again: gdharness upgrade in the project installs the ${serverVersion} addons, and editor_launch restart then picks them up.` : "Restart it with editor_launch restart to pick this one up.";
   if (reported === serverVersion) {
-    return `The editor is running a different build of the ${reported} addon from the one this server ships. Restart it with editor_launch restart to pick this one up.`;
+    return `The editor is running a different build of the ${reported} addon from the one this server ships. ${restart}`;
   }
   const editor = reported === "" ? UNVERSIONED : `the ${reported} addon`;
   const both = `The editor is running ${editor} while this server ships ${serverVersion}.`;
   if (reported !== "" && isNewer(reported, serverVersion)) {
     return `${both} This server is the older half: reconnect it in your harness so it spawns ${reported}.`;
   }
-  return `${both} Restart it with editor_launch restart to pick the new one up.`;
+  return `${both} ${restart}`;
+}
+function runtimeAddonUnknown(addon) {
+  return addon?.version === "" && addon.digest === "";
+}
+function runtimeMismatch(pid, addon, serverVersion, shippedDigest, onDisk, projectPath) {
+  if (runtimeAddonUnknown(addon)) {
+    return;
+  }
+  if (addon !== undefined && !editorIsStale(addon.version, serverVersion, addon.digest, shippedDigest)) {
+    return;
+  }
+  const game = `The game (pid ${pid})`;
+  if (addon !== undefined && addon.version !== "" && isNewer(addon.version, serverVersion)) {
+    return `${game} is running the ${addon.version} runtime addon while this server ships ${serverVersion}. This server is the older half: reconnect it in your harness so it spawns ${addon.version}.`;
+  }
+  let loaded;
+  if (addon === undefined) {
+    loaded = `a runtime addon from before games reported theirs, while this server ships ${serverVersion}`;
+  } else if (addon.version === serverVersion) {
+    loaded = `a different build of the ${serverVersion} runtime addon from the one this server ships`;
+  } else if (addon.version === "") {
+    loaded = `a runtime addon with no version marker, while this server ships ${serverVersion}`;
+  } else {
+    loaded = `the ${addon.version} runtime addon, while this server ships ${serverVersion}`;
+  }
+  const remedy = onDisk !== undefined && onDisk !== shippedDigest ? `The project's own runtime addon is not this server's either, so starting the game again loads the same code: gdharness upgrade in ${projectPath} installs the ${serverVersion} addons, and the game picks them up when it next starts.` : `The project holds this server's runtime addon, so the game picks it up when it next starts.`;
+  return `${game} is running ${loaded}, and its answers come from that code. ${remedy}`;
 }
-function markIfStale(answer, addonVersion, serverVersion, addonDigest, shippedDigest) {
-  const staleNote = addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest);
+function markIfStale(answer, addonVersion, serverVersion, addonDigest, shippedDigest, onDisk) {
+  const staleNote = addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest, onDisk);
   if (staleNote === undefined || typeof answer !== "object" || answer === null || Array.isArray(answer)) {
     return answer;
   }
@@ -8609,7 +8704,7 @@ var init_issues = __esm(() => {
 });
 
 // src/class-cache.ts
-import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync7, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync7, statSync as statSync4 } from "node:fs";
 import { join as join9 } from "node:path";
 function isToolScript(source) {
   return TOOL.test(codeOf(source));
@@ -8905,7 +9000,7 @@ function uncachedClassNote(types) {
 function cacheWrittenAt(projectPath) {
   const cache = join9(projectPath, ".godot", "global_script_class_cache.cfg");
   try {
-    return statSync3(cache).mtimeMs;
+    return statSync4(cache).mtimeMs;
   } catch {
     return null;
   }
@@ -8917,7 +9012,7 @@ function declaredSince(projectPath, paths, names, since) {
       return false;
     }
     try {
-      return statSync3(join9(projectPath, path.slice("res://".length))).mtimeMs > since;
+      return statSync4(join9(projectPath, path.slice("res://".length))).mtimeMs > since;
     } catch {
       return false;
     }
@@ -16050,82 +16145,15 @@ var init_types = __esm(() => {
   };
 });
 
-// src/paths.ts
-import { realpathSync as realpathSync2 } from "node:fs";
-import { isAbsolute, relative, resolve, sep } from "node:path";
-function realPathOr(path) {
-  try {
-    return realpathSync2.native(path);
-  } catch {
-    return path;
-  }
-}
-function isSameDirectory(onePath, otherPath) {
-  return relative(realPathOr(resolve(onePath)), realPathOr(resolve(otherPath))) === "";
-}
-function isWithinRoot(rootPath, candidatePath) {
-  const step = relative(resolve(rootPath), resolve(candidatePath));
-  return step !== ".." && !step.startsWith(`..${sep}`) && !isAbsolute(step);
-}
-function resolveWithinProject(projectPath, candidatePath) {
-  const trimmed = candidatePath.trim();
-  if (trimmed === "") {
-    return { ok: false, reason: "Path is empty." };
-  }
-  if (trimmed.includes("\x00")) {
-    return { ok: false, reason: "Path contains a null byte." };
-  }
-  const withoutScheme = trimmed.startsWith(RESOURCE_SCHEME) ? trimmed.slice(RESOURCE_SCHEME.length) : trimmed;
-  if (withoutScheme.startsWith("uid://")) {
-    return {
-      ok: false,
-      reason: `Path '${trimmed}' is a UID, and a file is judged here by where it is on disk, which a UID does not say. Give the file's res:// path.`
-    };
-  }
-  const scheme = OTHER_SCHEME.exec(withoutScheme);
-  if (scheme) {
-    return {
-      ok: false,
-      reason: `Path '${trimmed}' uses the '${scheme[0]}' scheme, which names somewhere other than this project.`
-    };
-  }
-  if (withoutScheme.startsWith("/") || withoutScheme.startsWith("\\") || isAbsolute(withoutScheme)) {
-    return {
-      ok: false,
-      reason: `Path '${trimmed}' is absolute; give a path inside the project, such as 'scenes/main.tscn'.`
-    };
-  }
-  if (withoutScheme.includes(":")) {
-    return {
-      ok: false,
-      reason: `Path '${trimmed}' contains ':', which no file inside a project is named with.`
-    };
-  }
-  const root = resolve(projectPath);
-  const absolutePath = resolve(root, withoutScheme);
-  if (!isWithinRoot(root, absolutePath)) {
-    return { ok: false, reason: `Path '${trimmed}' resolves outside the project directory.` };
-  }
-  const relativePath = relative(root, absolutePath).split(sep).join("/");
-  if (relativePath === "") {
-    return { ok: false, reason: `Path '${trimmed}' is the project directory itself, not a file in it.` };
-  }
-  return { ok: true, absolutePath, relativePath };
-}
-var RESOURCE_SCHEME = "res://", OTHER_SCHEME;
-var init_paths = __esm(() => {
-  OTHER_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]+:\/\//;
-});
-
 // src/resources.ts
-import { readFileSync as readFileSync8 } from "node:fs";
-import { extname, resolve as resolve2 } from "node:path";
+import { readFileSync as readFileSync8, realpathSync as realpathSync3 } from "node:fs";
+import { extname, resolve as resolve3 } from "node:path";
 function ensureProjectPath(getProjectPath) {
   const projectPath = getProjectPath();
   if (!projectPath) {
-    throw new Refusal("Project path is not set. Set a Godot project path first.");
+    throw new Refusal("This server knows no project to read from: start it with GDHARNESS_PROJECT, connect an editor, or make any tool call naming a projectPath that holds project.godot.");
   }
-  return resolve2(projectPath);
+  return resolve3(projectPath);
 }
 function uriPathToProjectPath(inputPath) {
   const normalized = inputPath.replace(/\\/g, "/").trim();
@@ -16139,7 +16167,22 @@ function resolveProjectFile(projectPath, resourcePath) {
   if (!contained.ok) {
     throw new Refusal(contained.reason);
   }
-  return contained.absolutePath;
+  let root;
+  try {
+    root = realpathSync3.native(projectPath);
+  } catch {
+    throw new Refusal(`The project directory ${projectPath} is not there.`);
+  }
+  let real;
+  try {
+    real = realpathSync3.native(contained.absolutePath);
+  } catch {
+    throw new Refusal(`No file at ${resourcePath} in the project.`);
+  }
+  if (!isWithinRoot(root, real)) {
+    throw new Refusal(`${resourcePath} leads outside the project through a link, so it is not read.`);
+  }
+  return real;
 }
 function parseGodotUri(uri) {
   if (uri === "godot://project/info") {
@@ -16431,12 +16474,18 @@ import {
   readFileSync as readFileSync9,
   rmdirSync,
   rmSync as rmSync5,
-  statSync as statSync4,
+  statSync as statSync5,
   writeFileSync as writeFileSync6
 } from "node:fs";
 import { dirname as dirname5, join as join10 } from "node:path";
 import { fileURLToPath } from "node:url";
 function editorAddonDigest(from = shippedAddonsDirectory()) {
+  return addonsDigest(EDITOR_PLUGINS, from);
+}
+function runtimeAddonDigest(from = shippedAddonsDirectory()) {
+  return addonsDigest([RUNTIME_ADDON], from);
+}
+function addonsDigest(names, from) {
   const hash = createHash3("sha256");
   const walk = (directory, relative) => {
     for (const name of readdirSync4(directory).sort()) {
@@ -16445,7 +16494,7 @@ function editorAddonDigest(from = shippedAddonsDirectory()) {
       }
       const path = join10(directory, name);
       const inside = `${relative}/${name}`;
-      if (statSync4(path).isDirectory()) {
+      if (statSync5(path).isDirectory()) {
         walk(path, inside);
       } else {
         hash.update(`${inside}
@@ -16456,7 +16505,7 @@ function editorAddonDigest(from = shippedAddonsDirectory()) {
       }
     }
   };
-  for (const name of EDITOR_PLUGINS) {
+  for (const name of names) {
     walk(join10(from, name), name);
   }
   return hash.digest("hex");
@@ -16471,8 +16520,24 @@ function shippedEditorDigest() {
   }
   return shippedDigest ?? undefined;
 }
+function shippedRuntimeDigest() {
+  if (shippedRuntime === undefined) {
+    try {
+      shippedRuntime = runtimeAddonDigest();
+    } catch {
+      shippedRuntime = null;
+    }
+  }
+  return shippedRuntime ?? undefined;
+}
 function installedEditorDigest(projectPath) {
-  const marker = join10(projectPath, "addons", ADDONS[0], DIGEST_MARKER);
+  return digestMarker(projectPath, ADDONS[0]);
+}
+function installedRuntimeDigest(projectPath) {
+  return digestMarker(projectPath, RUNTIME_ADDON);
+}
+function digestMarker(projectPath, addon) {
+  const marker = join10(projectPath, "addons", addon, DIGEST_MARKER);
   if (!existsSync10(marker)) {
     return null;
   }
@@ -16489,7 +16554,7 @@ function installAddons(projectPath, from = shippedAddonsDirectory()) {
   const installed = [];
   for (const name of ADDONS) {
     const source = join10(from, name);
-    if (!existsSync10(join10(source, name === "gdharness_runtime" ? "runtime_autoload.gd" : "plugin.cfg"))) {
+    if (!existsSync10(join10(source, name === RUNTIME_ADDON ? "runtime_autoload.gd" : "plugin.cfg"))) {
       throw new Error(`The package holds no ${name} addon at ${source}.`);
     }
     const target = join10(projectPath, "addons", name);
@@ -16502,6 +16567,8 @@ function installAddons(projectPath, from = shippedAddonsDirectory()) {
     installed.push({ name, path: target, replaced });
   }
   writeFileSync6(join10(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
+`);
+  writeFileSync6(join10(projectPath, "addons", RUNTIME_ADDON, DIGEST_MARKER), `${runtimeAddonDigest(from)}
 `);
   return installed;
 }
@@ -16656,7 +16723,7 @@ function inspectProject(projectPath) {
     problems
   };
 }
-var ADDONS, EDITOR_PLUGINS, RUNTIME_AUTOLOAD, SCRIPT_RUNS_SETTING = "gdharness/runtime/serve_script_runs", BIND_ADDRESS_SETTING = "gdharness/runtime/bind_address", PORT_SETTING = "gdharness/runtime/port", VERSION_MARKER = ".gdharness-version", DIGEST_MARKER = ".gdharness-digest", shippedDigest;
+var ADDONS, EDITOR_PLUGINS, RUNTIME_AUTOLOAD, SCRIPT_RUNS_SETTING = "gdharness/runtime/serve_script_runs", BIND_ADDRESS_SETTING = "gdharness/runtime/bind_address", PORT_SETTING = "gdharness/runtime/port", VERSION_MARKER = ".gdharness-version", DIGEST_MARKER = ".gdharness-digest", RUNTIME_ADDON = "gdharness_runtime", shippedDigest, shippedRuntime;
 var init_setup = __esm(() => {
   init_class_cache();
   init_headless();
@@ -17395,13 +17462,13 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_launch",
-      description: "Opens the Godot editor on a project, or restarts the one already connected. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, visible unless hidden: true is passed again. One opened by hand restarts itself, which only one with a window can do, 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.",
+      description: "Opens the Godot editor on a project, or restarts the one already connected. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, visible unless hidden: true is passed again, once the old one has gone: it waits 90 seconds for that, or GDHARNESS_EDITOR_RESTART_TIMEOUT_MS, and an old editor still running after it is not replaced, since the new one would find its ports held. One opened by hand restarts itself, which only one with a window can do, 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. An open is refused when the editor it would start could never reach this server: a project other than the one this server serves, whose editor dials that project's own server; a project without the gdharness editor addon installed and enabled; and a project whose editor a restart is already bringing back.",
       parameters: {
         projectPath: { ...PROJECT_PATH, ops: ["open"] },
         hidden: {
           type: "boolean",
           ops: ["open", "restart"],
-          description: "Open the editor headless and, on Windows, on a desktop of its own, so no window of it or of the games it plays appears. Default false: one visible editor, shown without taking the focus."
+          description: "Open the editor headless and, on Windows, on a desktop of its own, so no window of it or of the games it plays appears. Default false: one visible editor, shown without taking the focus. On restart only for an editor a server opened; one opened by hand comes back as it was, so hidden is refused there."
         }
       },
       requires: [],
@@ -17489,7 +17556,7 @@ var init_tool_definitions = __esm(() => {
           requires: ["projectPath"]
         },
         stop: {
-          summary: "end the run and answer with what it printed last, naming the process ended under endedPid: for a run the editor plays, the number its game announced under, read at the stop rather than remembered, and the operating system hands a freed number to the next process, so it can equal the game before it. A game that started processes of its own keeps them unless andChildren says to end those too. stopped is false, with the number under notSignalled, when that number no longer answers as the process the run was started as and nothing was signalled",
+          summary: "end the run and answer with what it printed last, naming the process ended under endedPid: for a run the editor plays, the number its game announced under, read at the stop rather than remembered, and the operating system hands a freed number to the next process, so it can equal the game before it. A game that started processes of its own keeps them unless andChildren says to end those too. stopped is false, with the number under notSignalled, when that number no longer answers as the process the run was started as and nothing was signalled, and false with the number under stillGoing when what was told to end was still running ten seconds later",
           requires: []
         },
         check: {
@@ -17550,7 +17617,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: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. 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. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. 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. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait.",
+      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: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. 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. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs gdharness upgrade, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. Every runtime_* answer from such a game carries addonIsStale and staleNote too. 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. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. 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. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs.",
       parameters: {},
       requires: []
     },
@@ -17589,6 +17656,7 @@ var init_tool_definitions = __esm(() => {
             "physics2d",
             "physics3d",
             "audio",
+            "visual",
             "animation",
             "ui"
           ],
@@ -17628,7 +17696,7 @@ var init_tool_definitions = __esm(() => {
         property: {
           type: "string",
           ops: ["property", "find"],
-          description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A packed list, such as a PackedStringArray, steps the same way. A negative number counts from the end. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that takes no arguments and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. A list or a map answers the calls that read it and take no arguments, "_game:run:board:size()" or "_game:inbox:keys()", and not those that change it, such as clear() or sort(). A step that is not there is named, and says what was there instead.'
+          description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A packed list, such as a PackedStringArray, steps the same way. A negative number counts from the end. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that takes no arguments and only reads (an engine method the engine marks as reading, or a game method not declared -> void, so queue_free() is refused) and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. A list or a map answers the calls that read it and take no arguments, "_game:run:board:size()" or "_game:inbox:keys()", and not those that change it, such as clear() or sort(). A step that is not there is named, and says what was there instead.'
         },
         depth: {
           type: "integer",
@@ -17667,13 +17735,14 @@ var init_tool_definitions = __esm(() => {
         limit: {
           type: "integer",
           minimum: 1,
+          maximum: 5000,
           ops: ["find", "text"],
-          description: "find: the most nodes to answer with, default 100. text: the most lines, default 500, with omitted saying how many lines that left behind. A screen whose dialog sits under a long list is a screen read with omitted greater than zero, so raise this or point root at the dialog rather than reading the answer as what is on screen."
+          description: "find: the most nodes to answer with, default 100. text: the most lines, default 500, with omitted saying how many lines that left behind. At most 5000 for either. A screen whose dialog sits under a long list is a screen read with omitted greater than zero, so raise this or point root at the dialog rather than reading the answer as what is on screen."
         },
         includeHidden: {
           type: "boolean",
           ops: ["text", "find"],
-          description: "text: read hidden nodes as well, for checking that something is not showing. Default false. find: default true, since a find means the node whether or not it is drawn; false answers with what the player can actually see, which is how a panel that keeps a label for every line and hides the ones that do not is read. A node counts as hidden when anything above it is, and how many matches were left out comes back under hidden."
+          description: "text: read hidden nodes as well, for checking that something is not showing. Default false. find: default true, since a find means the node whether or not it is drawn; false answers with what the player can actually see, which is how a panel that keeps a label for every line and hides the ones that do not is read. A node counts as hidden when the engine would not draw it: a hidden Control, Node2D or Node3D above it hides it, a plain Node in between breaks that chain as it does for the engine, and a hidden canvas layer or window hides everything in it. How many matches were left out comes back under hidden."
         },
         metrics: {
           type: "array",
@@ -17772,7 +17841,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "runtime_capture",
-      description: "A picture of the running game: the whole screen or one viewport, as an image. Needs the game running with a window. A capture asked for before the game's first frame is drawn waits for that frame, since the game announces itself before it and the viewport holds nothing it drew until then.",
+      description: "A picture of the running game: the whole screen or one viewport, as an image. The whole screen includes the game's own dialogs and popups where they sit, also when a project opens them as windows of their own (subwindows not embedded). Needs the game running with a window. A capture asked for before the game's first frame is drawn waits for that frame, since the game announces itself before it and the viewport holds nothing it drew until then.",
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         pid: RUNNING_PID,
@@ -17946,7 +18015,7 @@ var init_tool_definitions = __esm(() => {
         },
         value: {
           ops: ["until"],
-          description: "until: the value to wait for, fitted to the property's type. On a property holding an object, whether declared to or untyped and holding one or null, the text null means null. One declared to hold an object refuses any value other than null, since it can never hold it."
+          description: "until: the value to wait for, fitted to the property's type and compared at the precision the property keeps, so -1.1 meets a 32-bit float holding -1.10000002. A value the property would have to cut is refused: a fraction on a whole number, a number other than 0 or 1 on a bool. On a property holding an object, whether declared to or untyped and holding one or null, the text null means null. One declared to hold an object refuses any value other than null, since it can never hold it."
         },
         says: {
           type: "string",
@@ -32778,10 +32847,10 @@ var init_stdio2 = __esm(() => {
 });
 
 // src/runtime-client.ts
-import { existsSync as existsSync12, readdirSync as readdirSync6, readFileSync as readFileSync11, statSync as statSync5, unlinkSync } from "node:fs";
+import { existsSync as existsSync12, readdirSync as readdirSync6, readFileSync as readFileSync11, statSync as statSync6, unlinkSync } from "node:fs";
 import { createConnection } from "node:net";
 import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname8, join as join13, resolve as resolve3 } from "node:path";
+import { dirname as dirname8, join as join13, resolve as resolve4 } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 function runtimeDirectory(variables = process.env) {
   const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
@@ -32797,7 +32866,7 @@ function runtimeDirectories(variables = process.env) {
   for (const base of fallbacks) {
     candidates.push(join13(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
-  return [...new Set(candidates.map((path) => resolve3(path)))];
+  return [...new Set(candidates.map((path) => resolve4(path)))];
 }
 function errorReportOf(pid, directories = runtimeDirectories()) {
   for (const directory of directories) {
@@ -32850,13 +32919,14 @@ function parseAnnouncement(file, pid) {
   };
   let announcedAt;
   try {
-    announcedAt = statSync5(file).mtimeMs;
+    announcedAt = statSync6(file).mtimeMs;
   } catch {}
   const when = announcedAt === undefined ? {} : { announcedAt };
   if (protocol !== RUNTIME_PROTOCOL) {
     return { kind: "unspoken", unspoken: { pid, protocol: protocol ?? 0, project: named, ...when } };
   }
   const editorPid = readNumber(fields, "editor_pid");
+  const addonVersion = readString(fields, "addon_version");
   return {
     kind: "runtime",
     endpoint: {
@@ -32866,10 +32936,17 @@ function parseAnnouncement(file, pid) {
       project: named,
       file,
       ...editorPid !== undefined && Number.isInteger(editorPid) && editorPid > 0 ? { editorPid } : {},
-      ...when
+      ...when,
+      ...addonVersion === undefined ? {} : { addon: { version: addonVersion, digest: readString(fields, "addon_digest") ?? "" } }
     }
   };
 }
+function dialAddress(address) {
+  if (address === "*" || address === "0.0.0.0") {
+    return "127.0.0.1";
+  }
+  return address === "::" ? "::1" : address;
+}
 function runtimesAnnounced(directories = runtimeDirectories()) {
   const running = new Map;
   const unspoken = new Map;
@@ -32956,7 +33033,7 @@ function announcedIn(directory) {
     entries.push({ file, pid, running });
     if (running) {
       try {
-        candidates.push({ file, pid, writtenAt: statSync5(file).mtimeMs });
+        candidates.push({ file, pid, writtenAt: statSync6(file).mtimeMs });
       } catch {}
     }
   }
@@ -33013,7 +33090,7 @@ function sweepErrorReport(path, pid, now = Date.now()) {
     return;
   }
   try {
-    if (now - statSync5(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
+    if (now - statSync6(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
       unlinkSync(path);
     }
   } catch {}
@@ -33043,7 +33120,7 @@ function theOneProject(endpoints) {
   if (endpoints.some((endpoint) => endpoint.project.path === "")) {
     return;
   }
-  const paths = new Set(endpoints.map((endpoint) => realPathOr(resolve3(endpoint.project.path))));
+  const paths = new Set(endpoints.map((endpoint) => realPathOr(resolve4(endpoint.project.path))));
   const only = [...paths][0];
   return paths.size === 1 ? only : undefined;
 }
@@ -33074,7 +33151,7 @@ function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
     if (named !== undefined) {
       if (projectPath !== undefined && !isSameDirectory(named.project.path, projectPath)) {
         return {
-          problem: `The game with pid ${pid} is running ${named.project.path}, not ${resolve3(projectPath)}. Running: ${endpoints.map(describe2).join("; ")}.`
+          problem: `The game with pid ${pid} is running ${named.project.path}, not ${resolve4(projectPath)}. Running: ${endpoints.map(describe2).join("; ")}.`
         };
       }
       return { endpoint: named };
@@ -33114,7 +33191,7 @@ function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
     };
   }
   if (projectPath !== undefined) {
-    const wanted = resolve3(projectPath);
+    const wanted = resolve4(projectPath);
     const matching = endpoints.filter((endpoint) => isSameDirectory(endpoint.project.path, wanted));
     if (matching.length === 0) {
       return {
@@ -33159,7 +33236,7 @@ function runtimeRequest(endpoint, command, params, timeoutMs, keepListening = fa
     let late = false;
     let buffered = "";
     let welcomed = false;
-    const socket = createConnection({ port: endpoint.port, host: endpoint.address });
+    const socket = createConnection({ port: endpoint.port, host: dialAddress(endpoint.address) });
     let lateTimer = null;
     const finish = (reply) => {
       if (late) {
@@ -33323,7 +33400,7 @@ var init_boot_note = __esm(() => {
 
 // src/breakpoint-note.ts
 import { mkdirSync as mkdirSync7, readFileSync as readFileSync13, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname10, isAbsolute as isAbsolute2, join as join15, relative as relative2 } from "node:path";
+import { dirname as dirname10, isAbsolute as isAbsolute2, join as join15, relative as relative3 } from "node:path";
 function breakpointNotePath(projectPath) {
   return join15(projectPath, ".godot", "gdharness-breakpoints.json");
 }
@@ -33338,7 +33415,7 @@ function writeBreakpointNote(projectPath, held) {
     }
     const note = {
       breakpoints: inside.map((one) => ({
-        script: relative2(root, one.scriptPath).replaceAll("\\", "/"),
+        script: relative3(root, one.scriptPath).replaceAll("\\", "/"),
         lines: [...one.lines]
       }))
     };
@@ -33375,7 +33452,7 @@ function readBreakpointNote(projectPath) {
   }
 }
 function withinProject(projectPath, scriptPath) {
-  const rel = relative2(projectPath, scriptPath);
+  const rel = relative3(projectPath, scriptPath);
   return rel !== "" && !rel.startsWith("..") && !isAbsolute2(rel);
 }
 var init_breakpoint_note = __esm(() => {
@@ -34238,7 +34315,7 @@ import {
   readFileSync as readFileSync16,
   readSync,
   rmSync as rmSync8,
-  statSync as statSync6,
+  statSync as statSync7,
   writeFileSync as writeFileSync11
 } from "node:fs";
 import { dirname as dirname12, join as join18 } from "node:path";
@@ -34301,7 +34378,7 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
   return { log, path, ...of === undefined ? {} : { readBytes: text.length, of } };
 }
 function theFirstOf(path) {
-  const whole = statSync6(path).size;
+  const whole = statSync7(path).size;
   if (whole <= MOST_CONSOLE_BYTES) {
     return { text: readFileSync16(path, "utf8") };
   }
@@ -37372,7 +37449,10 @@ function mayYetConnect(listeningSince, now = Date.now()) {
   return listeningSince === undefined || now - listeningSince.getTime() < CONNECT_WINDOW_MS;
 }
 function theEditorHasComeBack(status, startedAt) {
-  return status.connected && (status.connectedAt?.getTime() ?? 0) > startedAt && status.addonVersion !== undefined;
+  return hasSaidWhoItIs(status) && (status.connectedAt?.getTime() ?? 0) > startedAt;
+}
+function hasSaidWhoItIs(status) {
+  return status.connected && status.addonVersion !== undefined;
 }
 function anEditorIsStillComing(listeningSince, launchedEditorIsAlive, now = Date.now()) {
   return mayYetConnect(listeningSince, now) || launchedEditorIsAlive;
@@ -37531,6 +37611,7 @@ var init_godot_bridge = __esm(() => {
         dapPort: this.connectionInfo?.dapPort,
         debugPort: this.connectionInfo?.debugPort,
         openedByAServer: this.connectionInfo?.openedByAServer,
+        startedByAnEditor: this.connectionInfo?.startedByAnEditor,
         syncsBreakpoints: this.connectionInfo?.syncsBreakpoints,
         pendingRequests: this.pendingRequests.size,
         queuedResources: this.resourceQueues.size,
@@ -37676,6 +37757,7 @@ var init_godot_bridge = __esm(() => {
             this.connectionInfo.dapPort = servedPort(message.dap_port);
             this.connectionInfo.debugPort = servedPort(message.debug_port);
             this.connectionInfo.openedByAServer = message.opened_by_a_server === true;
+            this.connectionInfo.startedByAnEditor = typeof message.started_by_an_editor === "boolean" ? message.started_by_an_editor : undefined;
             this.connectionInfo.syncsBreakpoints = typeof message.syncs_breakpoints === "boolean" ? message.syncs_breakpoints : undefined;
             this.log("info", `Godot ready: ${message.project_path}`);
             this.emitBridgeEvent("godot_connected", { projectPath: message.project_path });
@@ -37999,6 +38081,7 @@ function parseJUnit(xml) {
     const cases = suite.children.filter((child) => child.name === "testcase").map((element) => caseOf(suite, element));
     const failures = cases.filter((entry) => entry.status === "failed").length;
     const errors = cases.filter((entry) => entry.status === "error").length;
+    const written = (kind) => suite.children.filter((child) => child.name === "testcase").reduce((sum, element) => sum + element.children.filter((child) => child.name === kind).length, 0);
     return {
       name: suite.attributes["name"] ?? "",
       path: pathOf(suite),
@@ -38006,8 +38089,8 @@ function parseJUnit(xml) {
       discovered: count(suite.attributes, "tests"),
       failures,
       errors,
-      hookFailures: Math.max(0, count(suite.attributes, "failures") - failures),
-      hookErrors: Math.max(0, count(suite.attributes, "errors") - errors),
+      hookFailures: Math.max(0, count(suite.attributes, "failures") - written("failure")),
+      hookErrors: Math.max(0, count(suite.attributes, "errors") - written("error")),
       skipped: cases.filter((entry) => entry.status === "skipped").length,
       time: count(suite.attributes, "time"),
       cases
@@ -38200,11 +38283,53 @@ var init_junit = __esm(() => {
   ORPHANS = /(\d+)\s+orphans/;
 });
 
+// src/keeper-channel.ts
+import { connect as connect2, createServer as createServer2 } from "node:net";
+function askTheKeeperToStop(address, withinMs) {
+  return new Promise((resolve) => {
+    let said = "";
+    let settled = false;
+    const settle = (answer) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        socket.destroy();
+        resolve(answer);
+      }
+    };
+    const socket = connect2(address);
+    const timer = setTimeout(() => {
+      settle({ unreached: `it did not answer within ${withinMs} ms` });
+    }, withinMs);
+    socket.setEncoding("utf8");
+    socket.on("connect", () => {
+      socket.write(`stop
+`);
+    });
+    socket.on("data", (chunk) => {
+      said += chunk;
+      const line = said.split(`
+`)[0] ?? "";
+      if (said.includes(`
+`)) {
+        settle(line === "signalled" || line === "gone" ? line : { unreached: `it answered ${JSON.stringify(line)}` });
+      }
+    });
+    socket.on("error", (error) => {
+      settle({ unreached: error.code ?? error.message });
+    });
+    socket.on("close", () => {
+      settle({ unreached: "it closed the connection without answering" });
+    });
+  });
+}
+var init_keeper_channel = () => {};
+
 // src/lsp_client.ts
-import { existsSync as existsSync15, realpathSync as realpathSync3 } from "node:fs";
+import { existsSync as existsSync15, realpathSync as realpathSync4 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname13, join as join19, resolve as resolve4 } from "node:path";
+import { dirname as dirname13, join as join19, resolve as resolve5 } from "node:path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function diagnosticsKey(uri) {
   let decoded;
@@ -38217,7 +38342,7 @@ function diagnosticsKey(uri) {
     return decoded;
   }
   try {
-    return realpathSync3.native(fileURLToPath3(decoded)).toLowerCase();
+    return realpathSync4.native(fileURLToPath3(decoded)).toLowerCase();
   } catch {
     return decoded.toLowerCase();
   }
@@ -38334,7 +38459,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname13(resolve4(filePath));
+    const rootPath = this.rootPath ?? dirname13(resolve5(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params) {
@@ -38476,7 +38601,7 @@ class GodotLSPClient {
     });
   }
   toFileUri(filePath) {
-    return pathToFileURL(resolve4(filePath)).href;
+    return pathToFileURL(resolve5(filePath)).href;
   }
   syncDocument(filePath, content) {
     const uri = this.toFileUri(filePath);
@@ -38520,7 +38645,7 @@ class GodotLSPClient {
   }
   async initialize(rootPath) {
     await this.ensureConnected();
-    const resolvedRootPath = resolve4(rootPath);
+    const resolvedRootPath = resolve5(rootPath);
     const rootUri = pathToFileURL(resolvedRootPath).href;
     this.forgetServedWorkspace();
     const result = await this.sendRequest("initialize", {
@@ -38689,7 +38814,7 @@ function normalizeLSPError(error, port) {
   return String(error);
 }
 async function resolveLSPPaths(projectPathValue, scriptPathValue) {
-  const requestedProjectPath = resolve4(projectPathValue);
+  const requestedProjectPath = resolve5(projectPathValue);
   let projectPath;
   try {
     projectPath = await realpath(requestedProjectPath);
@@ -38917,7 +39042,7 @@ function projectStructure(projectPath) {
         visit(join20(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-        if (extension === "tscn") {
+        if (SCENE_EXTENSIONS.has(extension)) {
           structure.scenes += 1;
         } else if (extension === "gd" || extension === "cs") {
           structure.scripts += 1;
@@ -38959,8 +39084,11 @@ function scriptsWithoutUid(projectPath) {
   visit(projectPath, "");
   return found.sort();
 }
+function isBinary(bytes) {
+  return bytes.subarray(0, 8000).includes(0);
+}
 function searchProject(projectPath, options) {
-  const extensions = new Set(options.fileTypes.map((ext) => ext.replace(/^\./, "").toLowerCase()).filter(Boolean));
+  const extensions = options.fileTypes === undefined ? null : new Set(options.fileTypes.map((ext) => ext.replace(/^\./, "").toLowerCase()).filter(Boolean));
   const result = {
     query: options.query,
     results: [],
@@ -38968,13 +39096,7 @@ function searchProject(projectPath, options) {
   };
   const regex = options.regex ? new RegExp(options.query, options.caseSensitive ? "" : "i") : null;
   const needle = options.caseSensitive ? options.query : options.query.toLowerCase();
-  const full = () => {
-    if (result.summary.total_matches >= options.maxResults) {
-      result.summary.truncated = true;
-      return true;
-    }
-    return false;
-  };
+  const full = () => result.summary.truncated;
   const visit = (directory) => {
     if (steppedOver(directory)) {
       return;
@@ -38992,21 +39114,26 @@ function searchProject(projectPath, options) {
         continue;
       }
       const extension = entry.name.includes(".") ? entry.name.split(".").pop()?.toLowerCase() ?? "" : "";
-      if (!entry.isFile() || !extensions.has(extension)) {
+      if (!entry.isFile() || extensions !== null && !extensions.has(extension)) {
+        continue;
+      }
+      const bytes = readFileSync17(entryPath);
+      if (extensions === null && isBinary(bytes)) {
         continue;
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync17(entryPath, "utf8").split(`
-`).entries()) {
-        if (full()) {
-          break;
+      for (const [index, line] of bytes.toString("utf8").split(/\r?\n/).entries()) {
+        const found = regex ? regex.exec(line) : (options.caseSensitive ? line : line.toLowerCase()).includes(needle) ? [options.query] : null;
+        if (found === null) {
+          continue;
         }
-        const match = regex ? regex.exec(line)?.[0] : (options.caseSensitive ? line : line.toLowerCase()).includes(needle) ? options.query : "";
-        if (match) {
-          matches.push({ line: index + 1, content: line.trim(), match });
-          result.summary.total_matches += 1;
+        if (result.summary.total_matches >= options.maxResults) {
+          result.summary.truncated = true;
+          break;
         }
+        matches.push({ line: index + 1, content: line.trim(), match: found[0] ?? "" });
+        result.summary.total_matches += 1;
       }
       if (matches.length > 0) {
         const relativePath = entryPath.slice(projectPath.length + 1).replace(/\\/g, "/");
@@ -39018,10 +39145,40 @@ function searchProject(projectPath, options) {
   visit(projectPath);
   return result;
 }
-var SKIPPED, ASSET_EXTENSIONS, CARRIES_A_UID;
+var SKIPPED, SCENE_EXTENSIONS, ASSET_EXTENSIONS, CARRIES_A_UID;
 var init_project_scan = __esm(() => {
   SKIPPED = new Set(["node_modules"]);
-  ASSET_EXTENSIONS = new Set(["png", "jpg", "jpeg", "webp", "svg", "ttf", "otf", "wav", "mp3", "ogg"]);
+  SCENE_EXTENSIONS = new Set(["tscn", "scn"]);
+  ASSET_EXTENSIONS = new Set([
+    "png",
+    "jpg",
+    "jpeg",
+    "webp",
+    "svg",
+    "bmp",
+    "tga",
+    "exr",
+    "hdr",
+    "ktx",
+    "dds",
+    "ttf",
+    "otf",
+    "woff",
+    "woff2",
+    "fnt",
+    "wav",
+    "mp3",
+    "ogg",
+    "glb",
+    "gltf",
+    "obj",
+    "fbx",
+    "blend",
+    "dae",
+    "ogv",
+    "gdshader",
+    "shader"
+  ]);
   CARRIES_A_UID = new Set(["gd", "shader", "gdshader"]);
 });
 
@@ -39075,12 +39232,12 @@ import {
   openSync as openSync2,
   readdirSync as readdirSync8,
   readFileSync as readFileSync19,
-  realpathSync as realpathSync4,
+  realpathSync as realpathSync5,
   rmSync as rmSync10,
-  statSync as statSync7,
+  statSync as statSync8,
   writeFileSync as writeFileSync13
 } from "node:fs";
-import { basename as basename4, dirname as dirname15, join as join22, resolve as resolve5 } from "node:path";
+import { basename as basename5, dirname as dirname15, join as join22, resolve as resolve6 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 function runsDirectory() {
   return join22(runtimeDirectory(), "runs");
@@ -39090,19 +39247,19 @@ function realAsFarAsItExists(path) {
   let at = path;
   for (;; ) {
     try {
-      return join22(realpathSync4.native(at), ...missing);
+      return join22(realpathSync5.native(at), ...missing);
     } catch {
       const parent = dirname15(at);
       if (parent === at) {
         return path;
       }
-      missing.unshift(basename4(at));
+      missing.unshift(basename5(at));
       at = parent;
     }
   }
 }
 function projectKey(projectPath) {
-  const real = realAsFarAsItExists(resolve5(projectPath)).replace(/[\\/]+$/, "");
+  const real = realAsFarAsItExists(resolve6(projectPath)).replace(/[\\/]+$/, "");
   const folded = process.platform === "win32" || process.platform === "darwin" ? real.toLowerCase() : real;
   return createHash4("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
@@ -39209,7 +39366,10 @@ function recordAt(path) {
     pid,
     transcript,
     startedAt,
+    ...typeof fields["startedBy"] === "number" ? { startedBy: fields["startedBy"] } : {},
     projectPath: typeof fields["projectPath"] === "string" ? fields["projectPath"] : "",
+    ...typeof fields["servedBy"] === "string" && fields["servedBy"] !== "" ? { servedBy: fields["servedBy"] } : {},
+    ...typeof fields["keeper"] === "string" && fields["keeper"] !== "" ? { keeper: fields["keeper"] } : {},
     arguments: Array.isArray(args) ? args.filter((value) => typeof value === "string") : [],
     ...typeof fields["command"] === "string" ? { command: fields["command"] } : {},
     ...typeof fields["exitCode"] === "number" ? { exitCode: fields["exitCode"] } : {},
@@ -39218,7 +39378,8 @@ function recordAt(path) {
 }
 async function runningAs(pid) {
   if (process.platform === "win32") {
-    const answer = await windowsCommandLine(pid);
+    const read = await readWindowsCommandLine(pid);
+    const answer = "answer" in read ? read.answer : null;
     if (answer !== null) {
       const [, ...rest] = answer.split(`
 `);
@@ -39230,7 +39391,8 @@ async function runningAs(pid) {
       }
     }
     const image = await windowsImage(pid);
-    return image === null ? null : { kind: "image", text: image };
+    const unread = "unread" in read ? read.unread : "Windows gave an empty command line";
+    return "image" in image ? { kind: "image", text: image.image, unread } : { kind: "none", text: "", unread: `${unread}; tasklist ${image.why}` };
   }
   try {
     const began = await startedAt(pid, null);
@@ -39281,13 +39443,18 @@ function listeningPidInNetstat(printed, port) {
   }
   return null;
 }
-async function windowsCommandLine(pid) {
-  try {
-    const answer = (await askWindows(`$p = Get-CimInstance Win32_Process -Filter "ProcessId=${pid}"; if ($p) { $p.CreationDate.ToUniversalTime().ToString("o"); $p.CommandLine }`, 15000)).trim();
-    return answer === "" ? null : answer;
-  } catch {
-    return null;
+async function readWindowsCommandLine(pid, ask = askWindows) {
+  const query = `$p = Get-CimInstance Win32_Process -Filter "ProcessId=${pid}"; if ($p) { $p.CreationDate.ToUniversalTime().ToString("o"); $p.CommandLine }`;
+  let unread = "";
+  for (const withinMs of [15000, 45000]) {
+    try {
+      const answer = (await ask(query, withinMs)).trim();
+      return answer === "" ? { unread: "Windows gave no command line for it" } : { answer };
+    } catch (error) {
+      unread = errorMessage(error);
+    }
   }
+  return { unread };
 }
 async function startedAt(pid, windowsAnswer) {
   if (process.platform === "win32") {
@@ -39310,41 +39477,53 @@ async function windowsImage(pid) {
       timeout: 15000,
       windowsHide: true
     });
-    return /^"([^"]+)"/.exec(csv.trim())?.[1] ?? null;
-  } catch {
-    return null;
+    const image = /^"([^"]+)"/.exec(csv.trim())?.[1];
+    return image === undefined ? { why: "named no process under that number" } : { image };
+  } catch (error) {
+    const failed = error;
+    return { why: failed.killed === true ? "did not answer within 15000 ms" : errorMessage(error) };
   }
 }
-async function stillTheRecordedRun(record) {
-  return judgeRun(record, await runningAs(record.pid), "confirmed");
+async function whyNotStillTheRecordedRun(record) {
+  return whyNotTheRun(record, await runningAs(record.pid), "confirmed");
 }
 async function couldStillBeTheRecordedRun(record) {
   return judgeRun(record, await runningAs(record.pid), "possible");
 }
 function judgeRun(record, running, needed) {
+  return whyNotTheRun(record, running, needed) === null;
+}
+function whyNotTheRun(record, running, needed) {
   if (running === null) {
-    return false;
+    return "the operating system would not describe that process";
   }
-  if (running.startedAt !== undefined && running.startedAt - record.startedAt > SAME_RUN_WINDOW_MS) {
-    return false;
+  if (running.kind === "none") {
+    return `the operating system would not describe that process (${running.unread ?? "no reason given"})`;
+  }
+  const after = running.startedAt === undefined ? 0 : running.startedAt - (record.startedBy ?? record.startedAt);
+  if (after > SAME_RUN_WINDOW_MS) {
+    return `that process started ${Math.round(after / 1000)} seconds after the run had`;
   }
-  const engine = record.command === undefined ? null : basename4(record.command);
+  const engine = record.command === undefined ? null : basename5(record.command);
   const said = process.platform === "win32" ? running.text.toLowerCase() : running.text;
   const wanted = engine === null || process.platform !== "win32" ? engine : engine.toLowerCase();
   if (wanted !== null && !said.includes(wanted)) {
-    return false;
+    return `that process is not ${engine ?? "the engine"}, which the run was started with`;
   }
   if (running.kind === "commandLine" && readCommandLine(running.text).editor) {
-    return false;
+    return "that process is an editor";
   }
   if (record.projectPath === "") {
-    return wanted !== null;
+    return wanted !== null ? null : "the record names neither the project nor the engine";
   }
   if (running.kind === "image") {
-    return needed === "possible" && wanted !== null;
+    if (wanted === null) {
+      return "the operating system named only its executable, and the record names no engine";
+    }
+    return needed === "possible" ? null : `the operating system named only its executable and not its command line (${running.unread ?? "no reason given"}), which is not enough to signal it on`;
   }
   const project = process.platform === "win32" ? record.projectPath.toLowerCase() : record.projectPath;
-  return said.includes(project);
+  return said.includes(project) ? null : `that process's command line does not name ${record.projectPath}`;
 }
 async function stillTheAnnouncedGame(pid, projectPath, announcedAt) {
   return judgeAnnouncedGame(await runningAs(pid), projectPath, announcedAt);
@@ -39376,7 +39555,7 @@ function clearRunRecord(projectPath) {
 }
 function ageMs(path, now) {
   try {
-    return now - statSync7(path).mtimeMs;
+    return now - statSync8(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -39405,6 +39584,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
 }
 var execFileAsync, SHARED_NOTE = "run.json", SAME_RUN_WINDOW_MS = 1e4;
 var init_run_record = __esm(() => {
+  init_errors();
   init_paths();
   init_process_children();
   init_runtime_client();
@@ -39428,12 +39608,19 @@ import {
   readFileSync as readFileSync20,
   readSync as readSync2,
   rmdirSync as rmdirSync2,
-  statSync as statSync8
+  statSync as statSync9
 } from "node:fs";
-import { basename as basename5, dirname as dirname16, extname as extname2, isAbsolute as isAbsolute3, join as join23, normalize as normalize2, relative as relative3 } from "node:path";
+import { basename as basename6, dirname as dirname16, extname as extname2, isAbsolute as isAbsolute3, join as join23, normalize as normalize2, relative as relative4 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { promisify as promisify5 } from "node:util";
+function editorRestartTimeoutMs() {
+  const override = Number.parseInt(envValue("GDHARNESS_EDITOR_RESTART_TIMEOUT_MS") ?? "", 10);
+  return Number.isInteger(override) && override > 0 ? override : 90000;
+}
+function restartUnderway(note, now = Date.now()) {
+  return alive(note.byPid) && now - Date.parse(note.quitAt) < editorRestartTimeoutMs() + 30000;
+}
 function captureDestinationRefusal(outputPath, projects) {
   if (/^(res|user):\/\//.test(outputPath)) {
     return `outputPath ${outputPath} is a Godot path; a capture is saved outside the project, at an absolute path on this machine.`;
@@ -39448,7 +39635,7 @@ function captureDestinationRefusal(outputPath, projects) {
   if (!existsSync17(directory)) {
     return `outputPath's directory ${dirname16(outputPath)} does not exist; a capture creates no directories.`;
   }
-  const where = join23(directory, basename5(outputPath));
+  const where = join23(directory, basename6(outputPath));
   const inside = projects.find((project) => project !== "" && isWithinRoot(realPathOr(project), where));
   if (inside !== undefined) {
     return `outputPath ${outputPath} is inside the project at ${inside}; a capture is saved outside it, so it never becomes part of the game.`;
@@ -39462,7 +39649,7 @@ function patienceForFrames(frames, atLeast) {
   return Math.max(atLeast, frames / SLOWEST_FRAME_RATE * 1000 + atLeast);
 }
 function projectSpelling(projectPath, absolutePath) {
-  return `res://${relative3(realPathOr(projectPath), realPathOr(absolutePath)).replaceAll("\\", "/")}`;
+  return `res://${relative4(realPathOr(projectPath), realPathOr(absolutePath)).replaceAll("\\", "/")}`;
 }
 function whichGame(args) {
   return { projectPath: args["projectPath"], pid: args["pid"] };
@@ -39584,22 +39771,31 @@ function stopVerdict(stop) {
       withChildren: false
     };
   }
+  if (stop.ending === "lingering") {
+    const told = stop.throughEditor ? stop.endedPid === null ? "The editor was asked to stop the scene it is playing and was still playing it" : `The editor was asked to stop the scene it is playing, and its game, pid ${stop.endedPid}, was still running` : `pid ${stop.endedPid ?? "unknown"} was told to end and was still running`;
+    return {
+      stopped: false,
+      stillGoing: stop.endedPid,
+      note: `${told} ${STOP_WAIT_MS / 1000} seconds later, so it has not stopped. editor_status says when it has gone, and editor_run stop asks again.`,
+      withChildren: true
+    };
+  }
   return {
     stopped: true,
     endedPid: stop.endedPid,
     clean: stop.clean,
-    note: `${stop.throughEditor ? stop.endedPid === null ? "The editor was asked to stop the scene it is playing. Its game had not announced a runtime, so no process was named under endedPid, and its exit code stays with the editor." : "The editor was asked to stop the scene it is playing." : "The process named under endedPid was ended."}${stop.exitSignal === null ? "" : ` It was ended by ${stop.exitSignal} and so has no exit code.`}${stop.ending === "gone" ? "" : ` It had not exited ${STOP_WAIT_MS / 1000} seconds after being told to, so it may still be going: editor_status says whether it is.`}`,
+    note: `${stop.throughEditor ? stop.endedPid === null ? "The editor was asked to stop the scene it is playing. Its game had not announced a runtime, so no process was named under endedPid, and its exit code stays with the editor." : "The editor was asked to stop the scene it is playing." : "The process named under endedPid was ended."}${stop.exitSignal === null ? "" : ` It was ended by ${stop.exitSignal} and so has no exit code.`}`,
     withChildren: true
   };
 }
 function endedPreviousRun(ended) {
-  if (ended === null || ended.ending === "refused" || ended.ending === "unreached") {
+  if (ended?.ending !== "gone") {
     return;
   }
   return ended.pid ?? true;
 }
 function previousRunLeft(ended) {
-  return ended?.ending === "refused" && ended.pid !== null ? ended.pid : undefined;
+  return (ended?.ending === "refused" || ended?.ending === "lingering") && ended.pid !== null ? ended.pid : undefined;
 }
 function engineNamesOf(executable) {
   return CONSOLE_WRAPPER.test(executable) ? [executable, executable.replace(CONSOLE_WRAPPER, "$1")] : [executable];
@@ -39678,8 +39874,10 @@ function endedToStartThis(ended) {
   if (ended.ending === "unreached") {
     return ` ${which} was not ended here: the editor could not be asked to stop it. The editor stops a play before starting the next, so it is not running beside this one if this start reached the editor.`;
   }
-  const after = ended.ending === "lingering" ? ` It had not exited ${STOP_WAIT_MS / 1000} seconds after being told to, so it may still be running beside this one: editor_status says whether it is.` : "";
-  return ` ${which} was ended to start this one; its output is no longer what editor_output answers about.${after}`;
+  if (ended.ending === "lingering") {
+    return ` ${which} was told to end to start this one and was still running ${STOP_WAIT_MS / 1000} seconds later, so it is running beside this one: editor_status says when it has gone.`;
+  }
+  return ` ${which} was ended to start this one; its output is no longer what editor_output answers about.`;
 }
 function runtimeVerdict(endpoint, after) {
   if (endpoint !== null) {
@@ -40009,6 +40207,7 @@ class GodotServer {
   shutdownInitiated = false;
   launchedEditor = null;
   launchedFrom = null;
+  launchedDropped = null;
   ownProject;
   announcedAt = null;
   handingOverFrom = null;
@@ -40016,9 +40215,12 @@ class GodotServer {
   constructor() {
     this.ownProject = envValue("GDHARNESS_PROJECT") ?? null;
     this.godotBridge = getDefaultBridge(this.ownProject);
+    this.godotBridge.on("godot_connected", () => {
+      this.settleTheLaunchReading();
+    });
     this.mcp = new McpServer({ name: "gdharness", version: SERVER_VERSION }, { capabilities: { tools: {}, resources: {} } });
     this.setupToolHandlers();
-    setupResourceHandlers(this.mcp, () => this.lastProjectPath);
+    setupResourceHandlers(this.mcp, () => this.ourProject() ?? this.lastProjectPath);
     this.mcp.server.onerror = (error) => {
       console.error("[MCP Error]", error);
     };
@@ -40284,8 +40486,9 @@ class GodotServer {
       if (!checked.ok) {
         return checked.response;
       }
-      if (typeof args["projectPath"] === "string") {
-        this.lastProjectPath = args["projectPath"];
+      const named = args["projectPath"];
+      if (typeof named === "string" && existsSync17(join23(named, "project.godot"))) {
+        this.lastProjectPath = named;
       }
       this.updates.refresh();
       const answer = await withCallSignal(extra.signal, () => this.answered(spec.name, checked.op ?? "", args));
@@ -40325,6 +40528,17 @@ class GodotServer {
       return answer;
     }
     const moved = this.projectHasMovedOn();
+    if (moved !== null && !isNewer(moved, SERVER_VERSION)) {
+      this.noticedUpdate = true;
+      this.callsSinceNotice = 0;
+      return this.saying(answer, {
+        project_addons_behind_this_server: {
+          server_is: SERVER_VERSION,
+          project_is: moved,
+          what_to_do: `The project's gdharness addons are ${moved}, older than this ${SERVER_VERSION} server, so an ` + "editor restart loads the old code and reconnecting spawns this same server again. Tell the " + "user, and offer to run gdharness upgrade in the project, which replaces the addons with " + "this server's; ask first, since it changes files in their project. editor_launch restart " + "then loads them."
+        }
+      });
+    }
     if (moved !== null) {
       this.noticedUpdate = true;
       this.callsSinceNotice = 0;
@@ -40357,7 +40571,7 @@ class GodotServer {
     return this.saying(answer, {
       update_available: {
         ...notice,
-        what_to_do: "Tell the user a newer gdharness is out, with what changed, and offer to take it. " + "Only run the upgrade command if they say yes: it restarts their editor and the " + "MCP server has to be reconnected afterwards."
+        what_to_do: "Tell the user a newer gdharness is out, with what changed, and offer to take it. " + "Only run the upgrade command if they say yes: it replaces the addons in their project, " + "and afterwards the MCP server has to be reconnected and the editor restarted with " + "editor_launch restart."
       }
     });
   }
@@ -40374,6 +40588,15 @@ class GodotServer {
     const installed = installedAddonVersion(this.ownProject);
     return installed === null || installed === SERVER_VERSION ? null : installed;
   }
+  editorCodeOnDisk() {
+    const status = this.godotBridge.getStatus();
+    const project = (status.connected ? status.projectPath : undefined) ?? this.ownProject;
+    return project === null || project === "" ? undefined : installedEditorDigest(project);
+  }
+  runtimeStaleNote(endpoint) {
+    const project = endpoint.project.path;
+    return runtimeMismatch(endpoint.pid, endpoint.addon, SERVER_VERSION, shippedRuntimeDigest(), project === "" ? undefined : installedRuntimeDigest(project), project);
+  }
   configDisagreement() {
     return this.ownProject === null ? null : configDisagrees(this.ownProject, SERVER_VERSION);
   }
@@ -41308,7 +41531,7 @@ class GodotServer {
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
-      name: typeof name === "string" && name !== "" ? name : basename5(project.value.path),
+      name: typeof name === "string" && name !== "" ? name : basename6(project.value.path),
       path: project.value.path,
       mainScene: typeof mainScene === "string" && mainScene !== "" ? mainScene : null,
       godotVersion: await this.godotVersion(engine.value),
@@ -41325,6 +41548,10 @@ class GodotServer {
     }
     return this.jsonTextResponse(info);
   }
+  fileTypes(args) {
+    const named = readStringArray(args, "fileTypes");
+    return named === undefined ? {} : { fileTypes: named };
+  }
   handleSearchProject(args) {
     const project = this.project(args);
     if (!project.ok) {
@@ -41333,16 +41560,7 @@ class GodotServer {
     try {
       return this.jsonTextResponse(searchProject(project.value.path, {
         query: readString(args, "query") ?? "",
-        fileTypes: readStringArray(args, "fileTypes") ?? [
-          "gd",
-          "tscn",
-          "tres",
-          "gdshader",
-          "cfg",
-          "md",
-          "txt",
-          "json"
-        ],
+        ...this.fileTypes(args),
         regex: readBoolean(args, "regex") ?? false,
         caseSensitive: readBoolean(args, "caseSensitive") ?? false,
         maxResults: readPositiveNumber(args, "maxResults") ?? 100
@@ -41384,7 +41602,7 @@ class GodotServer {
       output.absolutePath
     ];
     this.logDebug(`Exporting: ${engine.value} ${exportArgs.join(" ")}`);
-    const writtenAt = () => existsSync17(output.absolutePath) ? statSync8(output.absolutePath).mtimeMs : null;
+    const writtenAt = () => existsSync17(output.absolutePath) ? statSync9(output.absolutePath).mtimeMs : null;
     const before = writtenAt();
     let ending;
     try {
@@ -41653,7 +41871,7 @@ class GodotServer {
       warnings: diagnostics.length - errors,
       diagnostics,
       ...disagrees
-    }, this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest()));
+    }, this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()));
   }
   whereTheFileDisagrees(diagnostics, args) {
     const messages = diagnostics.map((entry) => asParams(entry)["message"]).filter((message) => typeof message === "string");
@@ -41804,7 +42022,7 @@ class GodotServer {
   }
   breakpointsAtRisk() {
     const status = this.godotBridge.getStatus();
-    if (!status.connected || status.syncsBreakpoints === true) {
+    if (!hasSaidWhoItIs(status) || status.syncsBreakpoints === true) {
       return {};
     }
     return {
@@ -41859,26 +42077,34 @@ class GodotServer {
       restartSettled(this.ownProject);
       return null;
     }
-    return owed;
+    return { note: owed, underway: restartUnderway(owed) };
   }
   async getEditorStatusPayload() {
     const status = this.godotBridge.getStatus();
     const launchedIsUp = !status.connected && await this.launchedEditorIsUp();
     const isPortConflict = this.bridgeStartupError?.includes("EADDRINUSE") ?? false;
-    const stale = status.connected && editorIsStale(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest());
+    const greeted = hasSaidWhoItIs(status);
+    const stale = greeted && editorIsStale(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest());
     const unfinished = this.restartLeftUnfinished(status.connected);
     return {
       ...status,
       serverVersion: SERVER_VERSION,
-      addonIsStale: status.connected ? stale : undefined,
+      addonIsStale: greeted ? stale : undefined,
+      greeting: status.connected && !greeted ? "The editor has connected and has not yet said who it is: its project, pid, addon version and ports arrive with its greeting a moment after the socket opens, later while it imports. Ask again for them." : undefined,
       bridgeAvailable: this.bridgeStartupError === null,
-      mayYetConnect: status.connected ? undefined : unfinished !== null ? false : anEditorIsStillComing(status.listeningSince, launchedIsUp),
-      restartInterrupted: unfinished === null ? undefined : {
-        quitEditorPid: unfinished.editorPid,
-        quitAt: unfinished.quitAt,
-        byServerPid: unfinished.byPid,
+      mayYetConnect: status.connected ? undefined : unfinished !== null ? unfinished.underway : anEditorIsStillComing(status.listeningSince, launchedIsUp),
+      restartInterrupted: unfinished === null || unfinished.underway ? undefined : {
+        quitEditorPid: unfinished.note.editorPid,
+        quitAt: unfinished.note.quitAt,
+        byServerPid: unfinished.note.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."
       },
+      restartUnderway: unfinished === null || !unfinished.underway ? undefined : {
+        quitEditorPid: unfinished.note.editorPid,
+        quitAt: unfinished.note.quitAt,
+        byServerPid: unfinished.note.byPid,
+        note: `A restart of this project's editor is under way: gdharness server pid ${unfinished.note.byPid} asked it to quit at ${unfinished.note.quitAt} and is starting it again. Wait for it rather than opening another.`
+      },
       awaitingLaunchedEditor: status.connected || !launchedIsUp ? undefined : this.launchedEditor?.pid ?? undefined,
       ...status.connected ? this.whatTheLaunchedEditorDropped() : {},
       startupError: this.bridgeStartupError,
@@ -41888,8 +42114,9 @@ class GodotServer {
         port: this.godotBridge.configuredPort,
         note: `The gdharness server this one replaced, pid ${this.handingOverFrom}, still holds port ${this.godotBridge.configuredPort} and is standing down; this server takes the port when it lets go, and takes another after ${HANDOVER_MS / 1000} seconds if it does not.`
       },
-      staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest()) : undefined,
-      addonNote: status.connected ? sameCodeNote(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest()) : undefined,
+      staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()) : undefined,
+      addonNote: greeted ? sameCodeNote(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest()) : undefined,
+      startedByAnEditorNote: status.startedByAnEditor === true ? "Another editor started this one: Godot's own restart, or the project manager opening a project. None of the arguments a server gave the editor before it reached this one, so it serves the ports its editor settings name (and none at all while another editor holds those, when the script and debug tools reach that editor instead), its console is not captured, and it restarts itself. Close it and use editor_launch open to have an editor this server started." : undefined,
       ...this.breakpointsAtRisk(),
       retryingBridge: this.bridgeRetry === null ? undefined : true,
       announcedAt: this.announcedAt ?? undefined,
@@ -41956,12 +42183,17 @@ class GodotServer {
         ok: false,
         message: `The game is held by the editor's debugger, ${describeHalt(held)}, and answers no runtime call while it is. debug_control continue lets it go.`
       };
+      const staleNote = this.runtimeStaleNote(endpoint);
+      const unknown = runtimeAddonUnknown(endpoint.addon);
       return {
         pid: endpoint.pid,
         port: endpoint.port,
         project: endpoint.project,
         ...this.ownProject === null ? {} : { ofThisProject: isSameDirectory(endpoint.project.path, this.ownProject) },
         editorPid: endpoint.editorPid,
+        addonVersion: endpoint.addon === undefined || endpoint.addon.version === "" ? null : endpoint.addon.version,
+        ...unknown ? {} : { addonIsStale: staleNote !== undefined },
+        ...staleNote === undefined ? {} : { staleNote },
         reachable: reply.ok,
         problem: reply.ok ? null : reply.message
       };
@@ -42028,17 +42260,33 @@ class GodotServer {
         "editor_status says whether the bridge is up and what has reached it"
       ]);
     }
-    const settingsBefore = this.settingKeysOf(before.projectPath);
+    if (!hasSaidWhoItIs(before)) {
+      const settled = await this.waitForBridge(() => hasSaidWhoItIs(this.godotBridge.getStatus()) || !this.godotBridge.isConnected(), Date.now() + GREETING_WAIT_MS);
+      if (!settled) {
+        return this.createErrorResponse(`The editor has connected and has not said who it is within ${GREETING_WAIT_MS / 1000}s, so whether this server or the editor itself restarts it cannot be told.`, [
+          "editor_status says when it has, under greeting while it has not",
+          "Then ask for the restart again"
+        ]);
+      }
+      return this.handleRestartEditor(args);
+    }
     const mine = before.openedByAServer === true && before.projectPath !== undefined;
+    if (!mine && args["hidden"] === true) {
+      return this.createErrorResponse("This editor was opened by hand, and restarts itself as it was, so it cannot come back hidden.", [
+        "Close it, then editor_launch open with hidden: true starts a hidden one this server can restart",
+        "editor_launch restart without hidden restarts it as it is"
+      ]);
+    }
+    const settingsBefore = this.settingKeysOf(before.projectPath);
     const asked = mine ? await this.startItAgain(before.projectPath ?? "", before.editorPid, args["hidden"] === true) : await this.handleViaBridge("restart_editor", {});
     if (asked.isError === true) {
       return asked;
     }
     const startedAt = before.connectedAt?.getTime() ?? 0;
     const began = Date.now();
-    const back = await this.waitForBridge(() => theEditorHasComeBack(this.godotBridge.getStatus(), startedAt), began + EDITOR_RESTART_TIMEOUT_MS);
+    const back = await this.waitForBridge(() => theEditorHasComeBack(this.godotBridge.getStatus(), startedAt), began + editorRestartTimeoutMs());
     if (!back) {
-      return this.createErrorResponse(`The editor was asked to restart and has not come back within ${EDITOR_RESTART_TIMEOUT_MS / 1000}s.`, [
+      return this.createErrorResponse(`The editor was asked to restart and has not come back within ${editorRestartTimeoutMs() / 1000}s.`, [
         "It may be asking what to do about an unsaved scene: look at the editor window",
         "An addon that no longer parses stops the editor reaching this server",
         "editor_status says whether anything has reached the bridge since"
@@ -42052,18 +42300,27 @@ class GodotServer {
       addonVersion: now.addonVersion,
       serverVersion: SERVER_VERSION,
       addonIsStale: editorIsStale(now.addonVersion, SERVER_VERSION, now.addonDigest, shippedEditorDigest()),
-      staleNote: addonMismatch(now.addonVersion, SERVER_VERSION, now.addonDigest, shippedEditorDigest()),
+      staleNote: addonMismatch(now.addonVersion, SERVER_VERSION, now.addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()),
       ...this.whatTheEditorDropped(settingsBefore, after),
       tookMs: Date.now() - began
     });
   }
-  whatTheLaunchedEditorDropped() {
+  settleTheLaunchReading() {
     const watched = this.launchedFrom;
-    if (watched === null) {
-      return {};
+    const status = this.godotBridge.getStatus();
+    if (watched === null || !hasSaidWhoItIs(status)) {
+      return;
     }
     this.launchedFrom = null;
-    return this.whatTheEditorDropped(watched.before, this.settingKeysOf(watched.projectPath));
+    if (status.editorPid === undefined || status.editorPid !== this.launchedEditor?.pid) {
+      return;
+    }
+    this.launchedDropped = this.whatTheEditorDropped(watched.before, this.settingKeysOf(watched.projectPath));
+  }
+  whatTheLaunchedEditorDropped() {
+    const dropped = this.launchedDropped ?? {};
+    this.launchedDropped = null;
+    return dropped;
   }
   whatTheEditorDropped(before, after) {
     return settingsDroppedReport(before, after);
@@ -42089,7 +42346,14 @@ class GodotServer {
       restartSettled(projectPath);
       return asked;
     }
-    await this.waitForBridge(() => !alive(editorPid), Date.now() + EDITOR_RESTART_TIMEOUT_MS);
+    const gone = await this.waitForBridge(() => !alive(editorPid), Date.now() + editorRestartTimeoutMs());
+    if (!gone) {
+      restartSettled(projectPath);
+      return this.createErrorResponse(`The editor was asked to go and pid ${editorPid ?? "unknown"} is still running after ${editorRestartTimeoutMs() / 1000}s, so no replacement was started: it would find the language server and debug adapter ports still held.`, [
+        "It may be asking what to do about unsaved changes, or a script may be holding up its exit",
+        `editor_launch open starts one on ${projectPath} once it has gone`
+      ]);
+    }
     const opened = await this.openAnEditor(engine.value, projectPath, ports, hidden);
     restartSettled(projectPath);
     if (opened.error !== null) {
@@ -42120,6 +42384,10 @@ class GodotServer {
         "Another project wants its own gdharness server, which is its own harness session"
       ]);
     }
+    const refused = this.anEditorThatCannotConnect(project.value.path);
+    if (refused !== null) {
+      return refused;
+    }
     const engine = await this.engine();
     if (!engine.ok) {
       return engine.response;
@@ -42144,6 +42412,27 @@ class GodotServer {
       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."
     });
   }
+  anEditorThatCannotConnect(projectPath) {
+    if (this.ownProject !== null && !isSameDirectory(this.ownProject, projectPath)) {
+      return this.createErrorResponse(`This server serves ${this.ownProject}, and an editor of ${projectPath} would dial that project's own server rather than this one.`, [
+        "Open it from that project's own gdharness session",
+        `editor_launch with projectPath ${this.ownProject} opens the editor this server serves`
+      ]);
+    }
+    const report = inspectProject(projectPath);
+    const installed = report.addons.some((addon) => addon.name === "gdharness_editor" && addon.installed);
+    if (!installed || !report.pluginsEnabled.includes("gdharness_editor")) {
+      return this.createErrorResponse(`The gdharness editor addon is not ${installed ? "enabled" : "installed"} in ${projectPath}, so an editor opened on it would never reach this server.`, installed ? [
+        "gdharness setup in the project enables it",
+        "Or enable it under Project Settings, Plugins, in an editor opened by hand"
+      ] : ["gdharness setup in the project installs and enables it"]);
+    }
+    const owed = restartOwed(projectPath);
+    if (owed !== null && restartUnderway(owed)) {
+      return this.createErrorResponse(`A restart of this project's editor is under way: gdharness server pid ${owed.byPid} asked it to quit at ${owed.quitAt} and is starting it again, so opening another would put two editors on one project.`, ["editor_status says when it has connected"]);
+    }
+    return null;
+  }
   async openAnEditor(engine, projectPath, ports, hidden) {
     clearEditorLog(projectPath);
     const launched = await launchOutsideTheTree({
@@ -42350,7 +42639,7 @@ class GodotServer {
     }
     let announcedAt;
     try {
-      announcedAt = statSync8(endpoint.file).mtimeMs;
+      announcedAt = statSync9(endpoint.file).mtimeMs;
     } catch {
       return;
     }
@@ -42587,27 +42876,41 @@ class GodotServer {
     if (running.pid === null) {
       return "gone";
     }
+    if (running.keeper !== undefined) {
+      const ended = await this.endThroughTheKeeper(running, running.pid, running.keeper);
+      if (ended !== null) {
+        clearTheRecord();
+        return ended;
+      }
+    }
     const startedAs = {
       pid: running.pid,
       transcript: running.transcript ?? "",
       startedAt: running.startedAt,
+      ...running.startedBy === undefined ? {} : { startedBy: running.startedBy },
       projectPath: running.projectPath ?? "",
       arguments: [],
       ...running.command === undefined ? {} : { command: running.command }
     };
-    if (!await stillTheRecordedRun(startedAs)) {
+    const why = await whyNotStillTheRecordedRun(startedAs);
+    if (why !== null) {
       clearTheRecord();
       running.endedHere = null;
-      running.log.record("warning", `This run was not ended here: pid ${running.pid} no longer answers as the process the run was started as, so nothing was signalled. If that process is still the game, end it yourself; if it is not, it belongs to something else.`);
+      running.log.record("warning", `This run was not ended here: pid ${running.pid} no longer answers as the process the run was started as (${why}), so nothing was signalled. If that process is still the game, end it yourself; if it is not, it belongs to something else.`);
       return "refused";
     }
     const signalled = await runningAs(running.pid);
-    const described = signalled === null ? "nothing it would name" : `${signalled.kind}: ${signalled.text}`;
+    const described = signalled === null || signalled.kind === "none" ? "nothing it would name" : `${signalled.kind}: ${signalled.text}`;
     let landed = true;
+    let declined = null;
     try {
       process.kill(running.pid);
-    } catch {
+    } catch (error) {
       landed = false;
+      const code = error.code;
+      if (code !== "ESRCH") {
+        declined = code ?? errorMessage(error);
+      }
     }
     const gone = await untilGone([running.pid]);
     if (gone) {
@@ -42618,7 +42921,24 @@ class GodotServer {
       running.exitSignal = "SIGTERM";
     }
     clearTheRecord();
-    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}.`);
+    running.log.record(gone ? "info" : "warning", declined !== null ? `gdharness could not signal pid ${running.pid}: the operating system refused it (${declined}). It had described that process as ${described}.` : !gone ? `gdharness signalled pid ${running.pid}, which the operating system described as ${described}, and it was still running ${STOP_WAIT_MS / 1000} seconds later.` : 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}.`);
+    return gone ? "gone" : "lingering";
+  }
+  async endThroughTheKeeper(run, pid, keeper) {
+    const asked = await askTheKeeperToStop(keeper, KEEPER_ANSWER_MS);
+    if (typeof asked !== "string") {
+      this.logDebug(`The keeper of pid ${pid} could not be asked to end it (${asked.unreached})`);
+      return null;
+    }
+    const gone = await untilGone([pid]);
+    if (gone) {
+      await this.untilTheExitIsRecorded(run);
+    }
+    if (asked === "signalled" && gone) {
+      run.exitCode = null;
+      run.exitSignal = "SIGTERM";
+    }
+    run.log.record(gone ? "info" : "warning", !gone ? `gdharness had the keeper holding pid ${pid} end it, and it was still running ${STOP_WAIT_MS / 1000} seconds later.` : asked === "signalled" ? `gdharness ended pid ${pid} through the keeper holding it.` : `gdharness asked the keeper holding pid ${pid} to end it, and it had already gone.`);
     return gone ? "gone" : "lingering";
   }
   spawnGame(godotPath, cmdArgs, env) {
@@ -42702,13 +43022,16 @@ class GodotServer {
       command: godotPath,
       args: cmdArgs,
       ...env === undefined ? {} : { env },
-      run: { transcript: transcript.path, startedAt, projectPath },
+      run: { transcript: transcript.path, startedAt, projectPath, ...this.servedBy() },
       ...desktop === undefined ? {} : { desktop }
     });
     if ("error" in launched) {
       return launched;
     }
+    const startedBy = Date.now();
     sweepTranscripts();
+    const noted = readRunRecord(projectPath);
+    const keeper = noted?.pid === launched.pid ? noted.keeper : undefined;
     return {
       pid: launched.pid,
       log: new GameLog,
@@ -42716,6 +43039,8 @@ class GodotServer {
       readOffset: 0,
       projectPath,
       startedAt,
+      startedBy,
+      ...keeper === undefined ? {} : { keeper },
       command: godotPath,
       exitCode: null,
       exitSignal: null,
@@ -42935,8 +43260,9 @@ class GodotServer {
   }
   async adoptRecordedRun() {
     const project = this.ourProject();
-    const record = project === null ? null : readRunRecord(project);
-    if (record === null || !this.couldBeOurs(record.projectPath)) {
+    const found = project === null ? [] : [readRunRecord(project), this.startedForUs(project)];
+    const record = found.reduce((newest, one) => one !== null && (newest === null || one.startedAt > newest.startedAt) ? one : newest, null);
+    if (record === null || !(this.couldBeOurs(record.projectPath) || this.couldBeOurs(record.servedBy ?? ""))) {
       return null;
     }
     const adopted = {
@@ -42946,6 +43272,8 @@ class GodotServer {
       readOffset: 0,
       projectPath: record.projectPath === "" ? null : record.projectPath,
       startedAt: record.startedAt,
+      ...record.startedBy === undefined ? {} : { startedBy: record.startedBy },
+      ...record.keeper === undefined ? {} : { keeper: record.keeper },
       ...record.command === undefined ? {} : { command: record.command },
       exitCode: null,
       exitSignal: null,
@@ -42966,6 +43294,13 @@ class GodotServer {
     this.activeProcess = adopted;
     return adopted;
   }
+  servedBy() {
+    const mine = this.ourProject();
+    return mine === null ? {} : { servedBy: mine };
+  }
+  startedForUs(project) {
+    return everyRunRecord().find((one) => one.servedBy !== undefined && isSameDirectory(one.servedBy, project) && !(one.projectPath !== "" && isSameDirectory(one.projectPath, project))) ?? null;
+  }
   nothingOfOursIsRunning() {
     const status = this.godotBridge.getStatus();
     const noEditor = !status.connected ? " No editor is connected, so a game the editor is playing cannot be seen from here at all:" + " editor_status says whether one is on its way, and a run of yours that is still up is" + " reachable again once it is." : "";
@@ -43132,22 +43467,20 @@ class GodotServer {
   }
   async handleEditorConsole(args) {
     const status = this.godotBridge.getStatus();
-    const projectPath = status.projectPath ?? this.ownProject ?? undefined;
-    if (projectPath === undefined) {
-      return this.createErrorResponse("No editor is connected, so there is no console to read.", [
-        "editor_status says whether one is connected and whether it may yet be",
-        "editor_launch opens one, and an editor opened here has its console captured"
-      ]);
+    const greeted = hasSaidWhoItIs(status);
+    const launched = greeted ? null : this.launchedEditor?.pid ?? null;
+    if (!greeted && launched === null && status.connected) {
+      return this.createErrorResponse("The editor has connected and has not yet said who it is, so whose console to read cannot be told yet.", ["Ask again in a moment; editor_status shows greeting until it has"]);
     }
-    const launched = status.connected ? null : this.launchedEditor?.pid ?? null;
-    if (!status.connected && launched === null) {
+    const projectPath = status.projectPath ?? this.ownProject ?? undefined;
+    if (projectPath === undefined || !greeted && launched === null) {
       return this.createErrorResponse("No editor is connected, so there is no console to read.", [
         "editor_status says whether one is connected and whether it may yet be",
         "editor_launch opens one, and an editor opened here has its console captured"
       ]);
     }
-    const editorPid = status.connected ? status.editorPid ?? null : launched;
-    const console2 = editorConsole(projectPath, editorPid, status.connected ? status.openedByAServer === true : true);
+    const editorPid = greeted ? status.editorPid ?? null : launched;
+    const console2 = editorConsole(projectPath, editorPid, greeted ? status.openedByAServer === true : true);
     if ("kind" in console2) {
       return this.createErrorResponse(theConsoleWasNotCaptured(console2, projectPath), [
         "editor_launch restart replaces this editor with one whose console is captured",
@@ -43329,6 +43662,7 @@ class GodotServer {
       through: stopped.throughEditor ? "editor" : "gdharness",
       endedPid: verdict.endedPid,
       notSignalled: verdict.notSignalled,
+      stillGoing: verdict.stillGoing,
       ...childrenFields(ended),
       exitedBeforeStop: !wasRunning,
       exitCode: stopped.exitCode,
@@ -43386,12 +43720,13 @@ class GodotServer {
       await announcementEnded(pid);
     }
     return this.jsonTextResponse({
-      stopped: true,
+      stopped: gone,
       through: "gdharness",
-      endedPid: pid,
+      endedPid: gone ? pid : undefined,
+      stillGoing: gone ? undefined : pid,
       ...childrenFields(ended),
       exitedBeforeStop: !landed,
-      note: `${landed ? `pid ${pid} was ended: a game of this project that no server here was holding,` : `pid ${pid} had already gone when it was signalled: a game of this project that no server here was holding,`} identified by its announcement and by its command line, ${read.executable} run with --path ${read.projectPath ?? ""}. Nothing here read what it printed or holds its exit code, so neither is in this answer.${gone ? "" : ` It had not exited ${STOP_WAIT_MS / 1000} seconds after being told to, so it may still be going: editor_status says whether it is.`} ${aboutTheChildren(ended, false)}`
+      note: `${!gone ? `pid ${pid} was told to end and was still running ${STOP_WAIT_MS / 1000} seconds later, so it has not stopped: a game of this project that no server here was holding,` : landed ? `pid ${pid} was ended: a game of this project that no server here was holding,` : `pid ${pid} had already gone when it was signalled: a game of this project that no server here was holding,`} identified by its announcement and by its command line, ${read.executable} run with --path ${read.projectPath ?? ""}. Nothing here read what it printed or holds its exit code, so neither is in this answer.${gone ? "" : " editor_status says when it has gone."} ${aboutTheChildren(ended, false)}`
     });
   }
   async whatTheRunStarted(run) {
@@ -43538,7 +43873,8 @@ class GodotServer {
       }
     }
     const after = projectPath === "" || busy ? null : cachedClasses(projectPath);
-    const lost = before === null || after === null ? [] : [...before.keys()].filter((name) => !after.has(name));
+    const declaredNow = before === null || after === null ? null : declaredClasses(projectPath);
+    const lost = before === null || after === null || declaredNow === null ? [] : [...before.keys()].filter((name) => !after.has(name) && declaredNow.has(name));
     if (lost.length > 0) {
       this.noteAShortListEditor(projectPath);
     }
@@ -43599,7 +43935,7 @@ class GodotServer {
     }
     const checked = busy ? { unseen: [] } : await this.classesTheEditorCannotSee(args);
     const unseen = checked.unseen;
-    const broughtIn = blind.unseen.map((one) => one.className).filter((name) => !unseen.some((still) => still.className === name));
+    const broughtIn = busy ? [] : blind.unseen.map((one) => one.className).filter((name) => !unseen.some((still) => still.className === name));
     const dependents = busy || projectPath === "" || broughtIn.length === 0 ? null : await this.reloadDependents(projectPath, broughtIn);
     const stillGone = lost.filter((name) => !restored.includes(name));
     const notes = [];
@@ -43840,7 +44176,7 @@ class GodotServer {
       ]);
     }
     try {
-      return this.jsonTextResponse(markIfStale(await this.godotBridge.invokeTool(toolName, args), this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest()));
+      return this.jsonTextResponse(markIfStale(await this.godotBridge.invokeTool(toolName, args), this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()));
     } catch (error) {
       return this.createErrorResponse(`The editor answered ${toolName} with an error: ${errorMessage(error)}`);
     }
@@ -43905,7 +44241,7 @@ class GodotServer {
         return !run.announcedBefore.has(one.pid);
       }
       try {
-        return statSync8(one.file).mtimeMs >= run.startedAt;
+        return statSync9(one.file).mtimeMs >= run.startedAt;
       } catch {
         return false;
       }
@@ -43981,6 +44317,11 @@ class GodotServer {
     }
     const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
     const screenshotPath = screenshotDir ? join23(screenshotDir, "capture.png") : null;
+    const staleNote = this.runtimeStaleNote(choice.endpoint);
+    const stale = staleNote === undefined ? {} : { addonIsStale: true, staleNote };
+    const refused = (message) => this.createErrorResponse(staleNote === undefined ? message : `${message}
+
+${staleNote}`);
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs, !expectsScreenshot);
       if (!reply.ok && reply.requestId !== undefined) {
@@ -43990,22 +44331,23 @@ class GodotServer {
           command,
           waitedMs: timeoutMs,
           note: reply.message,
-          ...answeredBy
+          ...answeredBy,
+          ...stale
         });
       }
       if (!reply.ok) {
-        return this.createErrorResponse(reply.message);
+        return refused(reply.message);
       }
       const { id: _id, ...payload } = reply.payload;
       if (!expectsScreenshot) {
-        return this.jsonTextResponse({ ...payload, ...answeredBy });
+        return this.jsonTextResponse({ ...payload, ...answeredBy, ...stale });
       }
       const returnedPath = readString(payload, "path");
       if (readString(payload, "type") !== "screenshot_file" || !returnedPath || !screenshotPath) {
-        return this.createErrorResponse(`The game answered a capture with ${JSON.stringify(payload)}`);
+        return refused(`The game answered a capture with ${JSON.stringify(payload)}`);
       }
       if (normalize2(returnedPath) !== normalize2(screenshotPath)) {
-        return this.createErrorResponse(`Rejected screenshot file path outside the managed capture path: '${returnedPath}'`);
+        return refused(`Rejected screenshot file path outside the managed capture path: '${returnedPath}'`);
       }
       const dimensions = `${readNumber(payload, "width") ?? 0}x${readNumber(payload, "height") ?? 0} ${readString(payload, "format") ?? "unknown"}`;
       if (saveTo !== null) {
@@ -44019,7 +44361,9 @@ class GodotServer {
         content: [
           {
             type: "text",
-            text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}${saveTo === null ? "" : `. Saved to ${saveTo}`}`
+            text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}${saveTo === null ? "" : `. Saved to ${saveTo}`}${staleNote === undefined ? "" : `
+
+${staleNote}`}`
           },
           { type: "image", data: readFileSync20(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
@@ -44118,10 +44462,11 @@ class GodotServer {
   }
 }
 async function runGodotServer() {
+  delete process.env[EDITOR_PID_VARIABLE];
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run4, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, SCAN_WAIT_MS = 30000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run4, __dirname2, GREETING_WAIT_MS = 1e4, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, KEEPER_ANSWER_MS = 15000, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, SCAN_WAIT_MS = 30000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();
@@ -44146,6 +44491,7 @@ var init_server3 = __esm(() => {
   init_headless_operations();
   init_issues();
   init_junit();
+  init_keeper_channel();
   init_lsp_client();
   init_outside();
   init_paths();
@@ -44213,12 +44559,12 @@ init_bridge_announce();
 init_errors();
 init_godot_path();
 import { existsSync as existsSync18 } from "node:fs";
-import { join as join24, resolve as resolve6 } from "node:path";
+import { join as join24, resolve as resolve7 } from "node:path";
 
 // src/harnesses.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname3, join as join4 } from "node:path";
+import { basename as basename2, dirname as dirname3, join as join4, relative as relative2, resolve as resolve2 } from "node:path";
 import process4 from "node:process";
 
 // node_modules/yaml/dist/index.js
@@ -44361,6 +44707,7 @@ function isEmptyCollection(node) {
 
 // src/harnesses.ts
 init_errors();
+init_paths();
 init_runner();
 var SERVER_KEY = "gdharness";
 function launchFor(version, godotPath, projectPath, runner = currentRunner()) {
@@ -44923,27 +45270,66 @@ function registered(harness, projectPath) {
 }
 function recordedEnginePath(projectPath) {
   for (const harness of HARNESSES) {
-    if (harness.scope !== "project" || harness.toml || harness.yaml || harness.snippet) {
+    if (harness.scope !== "project") {
       continue;
     }
-    const path = configPath(harness, projectPath);
-    if (!existsSync4(path)) {
-      continue;
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(readFileSync2(path, "utf8"));
-    } catch {
-      continue;
-    }
-    const entry = reach(reach(parsed, harness.container), SERVER_KEY);
-    const named = reach(reach(entry, harness.shape === "opencode" ? "environment" : "env"), "GODOT_PATH");
+    const named = reach(entryEnvironment(harness, projectPath), "GODOT_PATH");
     if (typeof named === "string" && named !== "" && existsSync4(named)) {
       return named;
     }
   }
   return null;
 }
+function mainCheckoutOf(projectPath) {
+  let top = resolve2(projectPath);
+  while (!existsSync4(join4(top, ".git"))) {
+    const up = dirname3(top);
+    if (up === top) {
+      return null;
+    }
+    top = up;
+  }
+  const marker = join4(top, ".git");
+  if (!statSync2(marker).isFile()) {
+    return null;
+  }
+  const pointer = /^gitdir:\s*(.+)$/m.exec(readFileSync2(marker, "utf8"))?.[1]?.trim();
+  if (pointer === undefined) {
+    return null;
+  }
+  const entry = resolve2(top, pointer);
+  const commonFile = join4(entry, "commondir");
+  if (!existsSync4(commonFile)) {
+    return null;
+  }
+  const common = resolve2(entry, readFileSync2(commonFile, "utf8").trim());
+  if (basename2(common) !== ".git") {
+    return null;
+  }
+  const main = join4(dirname3(common), relative2(top, resolve2(projectPath)));
+  return isSameDirectory(main, projectPath) || !existsSync4(join4(main, "project.godot")) ? null : main;
+}
+function entryEnvironment(harness, projectPath) {
+  if (harness.toml || harness.yaml || harness.snippet) {
+    return;
+  }
+  const path = configPath(harness, projectPath);
+  if (!existsSync4(path)) {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return;
+  }
+  const entry = reach(reach(parsed, harness.container), SERVER_KEY);
+  return reach(entry, harness.shape === "opencode" ? "environment" : "env");
+}
+function servedProject(harness, projectPath) {
+  const named = reach(entryEnvironment(harness, projectPath), "GDHARNESS_PROJECT");
+  return typeof named === "string" && named !== "" ? named : null;
+}
 function reach(held, key) {
   return typeof held === "object" && held !== null && !Array.isArray(held) ? held[key] : undefined;
 }
@@ -45081,6 +45467,7 @@ function taken(harness, path, held, stripped) {
 // src/cli.ts
 init_headless();
 init_issues();
+init_paths();
 
 // src/prompt.ts
 import process8 from "node:process";
@@ -45113,7 +45500,7 @@ init_setup();
 init_setup();
 init_tool_definitions();
 import { existsSync as existsSync11, mkdirSync as mkdirSync5, readdirSync as readdirSync5, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
-import { basename as basename3, dirname as dirname6, join as join11 } from "node:path";
+import { basename as basename4, dirname as dirname6, join as join11 } from "node:path";
 
 // src/tool-reference.ts
 init_headless_operations();
@@ -45238,7 +45625,8 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
   (an older \`addonVersion\` on the same code is not stale), and \`staleNote\` says which half is behind: an editor that
   needs restarting, or a server that needs reconnecting in your harness. Every answer that came
   from the editor carries the same two when they differ, so a stale addon cannot answer quietly:
-  believe a restart over a diagnostic that arrived with them.
+  believe a restart over a diagnostic that arrived with them. A game's runtime addon is judged
+  the same way, under each entry in \`runtimes\` and on every \`runtime_*\` answer from it.
 - Start the game with \`editor_run start\`, never by spawning an engine. The editor plays it, so
   its debugger holds it, which is what gives the \`debug_*\` tools something to talk to. Its answer
   says under \`runtime\` whether the game can be talked to yet; when it cannot, \`mayYetAnnounce\`
@@ -45279,7 +45667,7 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | Where a control is, and whether it is visible | \`runtime_inspect\` \`find\`, \`rect\` |
 | 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\` |
-| Which control holds the focus, or anything only a method answers | the same path with a step written as a call, \`get_viewport():gui_get_focus_owner\`, which calls a method taking no arguments and walks into what it returned |
+| Which control holds the focus, or anything only a method answers | the same path with a step written as a call, \`get_viewport():gui_get_focus_owner\`, which calls a method taking no arguments that only reads and walks into what it returned |
 | Press a button | \`runtime_input click\` with \`says\` and the words on it, which finds it and presses it in the same frame and says what was under the pointer. A \`find\` and then a click by the path it answered is two calls over a generated path, and a panel that rebuilds between them frees the button first; \`nodePath\` narrows where \`says\` looks, and several matches are refused with an \`index\` for each |
 | Press the next thing after a click that changed screen | \`runtime_wait until\` with \`says\` and a word the new screen shows (no \`nodePath\` needed: without one the whole game is searched), 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 |
@@ -45440,7 +45828,7 @@ function removeSkill(directories, projectPath) {
 function pruneEmpty(directory, projectPath) {
   const shared = join11(projectPath, ".agents");
   let path = directory;
-  while (path !== projectPath && (basename3(path) === "skills" || path === shared)) {
+  while (path !== projectPath && (basename4(path) === "skills" || path === shared)) {
     if (readdirSync5(path).length > 0) {
       return;
     }
@@ -45491,7 +45879,7 @@ class UsageError extends Refusal {
 }
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
-  const projectPath = resolve6(named ?? ".");
+  const projectPath = resolve7(named ?? ".");
   if (!existsSync18(join24(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
@@ -45503,11 +45891,17 @@ async function engine(projectPath) {
     return { godotPath: located.path, script: shippedOperationsScript(), debug: GODOT_DEBUG_MODE_DEFAULT };
   }
   const recorded = located.named === null && projectPath !== undefined ? recordedEnginePath(projectPath) : null;
-  if (recorded === null) {
+  if (recorded !== null) {
+    return { godotPath: recorded, script: shippedOperationsScript(), debug: GODOT_DEBUG_MODE_DEFAULT };
+  }
+  const main = located.named === null && projectPath !== undefined ? mainCheckoutOf(projectPath) : null;
+  const theirs = main === null ? null : recordedEnginePath(main);
+  if (main === null || theirs === null) {
     const refusal = GodotLocator.refusal(located);
     throw new UsageError(`${refusal.message} ${refusal.advice.join(". ")}.`);
   }
-  return { godotPath: recorded, script: shippedOperationsScript(), debug: GODOT_DEBUG_MODE_DEFAULT };
+  console.error(`engine: ${theirs}, which the harness config of ${main} names; this project is a git worktree of it`);
+  return { godotPath: theirs, script: shippedOperationsScript(), debug: GODOT_DEBUG_MODE_DEFAULT };
 }
 function said2(outcome, what) {
   if (!outcome.ok) {
@@ -45680,12 +46074,14 @@ async function uninstall() {
   const named = namedHarnesses();
   const from = named.length > 0 ? named : HARNESSES;
   for (const harness of from) {
-    const removal = disconnect(harness, projectPath);
-    if (removal.action === "absent") {
+    if (harness.scope === "home" && named.length === 0) {
+      if (registered(harness, projectPath)) {
+        console.log(`${harness.name}: left alone. Its config is machine-wide and may serve another project; pass --${harness.id} to remove it.`);
+      }
       continue;
     }
-    if (harness.scope === "home" && named.length === 0) {
-      console.log(`${harness.name}: left alone. Its config is machine-wide and may serve another project; pass --${harness.id} to remove it.`);
+    const removal = disconnect(harness, projectPath);
+    if (removal.action === "absent") {
       continue;
     }
     if (removal.action === "manual") {
@@ -45705,15 +46101,19 @@ async function uninstall() {
     said2(outcome, `disabling ${name}`);
     console.log(`${name}: ${outcome.ok ? String(outcome.payload["action"]) : "failed"}`);
   }
-  if (before.runtimeAutoload) {
+  if (before.runtimeAutoloadPath !== null) {
     said2(await setRuntime(godot, projectPath, false), "removing the runtime autoload");
     console.log(`${RUNTIME_AUTOLOAD.name} autoload removed`);
   }
+  const loader = before.runtimeLoaderAutoload;
+  if (loader !== null && loader.name !== RUNTIME_AUTOLOAD.name) {
+    console.log(`${loader.name} names res://${loader.path}, which brings the runtime up its own way. That line is this project's, so it is left in place; the addon it brings up is gone now, so take the entry out unless that file does nothing without it.`);
+  }
   const addons = removeAddons(projectPath);
   for (const path of addons) {
     console.log(`removed ${path}`);
   }
-  const anything = addons.length > 0 || before.runtimeAutoload || enabled.length > 0;
+  const anything = addons.length > 0 || before.runtimeAutoloadPath !== null || enabled.length > 0;
   console.log(anything ? `
 Reconnect your harness so it stops spawning a server that is no longer installed.` : `
 Nothing of gdharness was in this project.`);
@@ -45722,13 +46122,13 @@ async function upgrade() {
   const projectPath = projectArgument(1);
   const version = getLocalVersion();
   const before = inspectProject(projectPath);
-  const installed = before.addons.find((addon) => addon.installed)?.version ?? null;
-  if (installed === null) {
+  const present = before.addons.find((addon) => addon.installed);
+  if (present === undefined) {
     const where = projectPath === process.cwd() ? "" : ` ${projectPath}`;
     throw new UsageError(`gdharness is not installed in ${projectPath}. Run  gdharness setup${where}  instead.`);
   }
   const godot = await engine(projectPath);
-  console.log(installed === version ? `already ${version}; reinstalling` : `${installed} -> ${version}`);
+  console.log(present.version === version ? `already ${version}; reinstalling` : `${present.version ?? "an unmarked copy"} -> ${version}`);
   const digestBefore = installedEditorDigest(projectPath);
   for (const addon of installAddons(projectPath)) {
     console.log(`${addon.replaced ? "replaced" : "installed"} ${addon.path}`);
@@ -45742,7 +46142,21 @@ async function upgrade() {
   }
   said2(await runOperation(godot, "refresh_class_cache", {}, projectPath), "rebuilding the class list");
   const launch = launchFor(version, godot.godotPath, projectPath);
-  const already = HARNESSES.filter((harness) => registered(harness, projectPath));
+  const named = namedHarnesses();
+  const already = HARNESSES.filter((harness) => {
+    if (!registered(harness, projectPath)) {
+      return false;
+    }
+    if (harness.scope !== "home" || named.includes(harness)) {
+      return true;
+    }
+    const serves = servedProject(harness, projectPath);
+    if (serves !== null && isSameDirectory(serves, projectPath)) {
+      return true;
+    }
+    console.log(`${harness.name}: left alone. Its config is machine-wide and ${serves === null ? "names no project" : `serves ${serves}`}; pass --${harness.id} to point it at this one.`);
+    return false;
+  });
   const moved = [];
   let written = 0;
   let byHand = 0;