gdharness 1.1.23 → 1.1.24

package/build/cli.js

@@ -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;
   }
@@ -8462,6 +8529,33 @@ function addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest,
   }
   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, onDisk) {
   const staleNote = addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest, onDisk);
   if (staleNote === undefined || typeof answer !== "object" || answer === null || Array.isArray(answer)) {
@@ -8609,75 +8703,8 @@ var init_issues = __esm(() => {
   ENHANCEMENT_URL = `${NEW_ISSUE}?template=feature_request.md`;
 });
 
-// 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/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));
@@ -8973,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;
   }
@@ -8985,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;
     }
@@ -16120,13 +16147,13 @@ var init_types = __esm(() => {
 
 // src/resources.ts
 import { readFileSync as readFileSync8, realpathSync as realpathSync3 } from "node:fs";
-import { extname, resolve as resolve2 } from "node:path";
+import { extname, resolve as resolve3 } from "node:path";
 function ensureProjectPath(getProjectPath) {
   const projectPath = getProjectPath();
   if (!projectPath) {
     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();
@@ -16447,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()) {
@@ -16461,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}
@@ -16472,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");
@@ -16487,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;
   }
@@ -16505,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);
@@ -16518,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;
 }
@@ -16672,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();
@@ -17566,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. 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.",
+      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: []
     },
@@ -32796,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);
@@ -32815,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) {
@@ -32868,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: {
@@ -32884,7 +32936,8 @@ 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") ?? "" } }
     }
   };
 }
@@ -32980,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 {}
     }
   }
@@ -33037,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 {}
@@ -33067,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;
 }
@@ -33098,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 };
@@ -33138,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 {
@@ -33347,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");
 }
@@ -33362,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]
       }))
     };
@@ -33399,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(() => {
@@ -34262,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";
@@ -34325,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") };
   }
@@ -38230,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 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;
@@ -38364,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) {
@@ -38506,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);
@@ -38550,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", {
@@ -38719,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);
@@ -39139,10 +39234,10 @@ import {
   readFileSync as readFileSync19,
   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");
@@ -39158,13 +39253,13 @@ function realAsFarAsItExists(path) {
       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);
 }
@@ -39274,6 +39369,7 @@ function recordAt(path) {
     ...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"] } : {},
@@ -39295,11 +39391,8 @@ async function runningAs(pid) {
       }
     }
     const image = await windowsImage(pid);
-    return image === null ? null : {
-      kind: "image",
-      text: image,
-      unread: "unread" in read ? read.unread : "Windows gave an empty command line"
-    };
+    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);
@@ -39384,9 +39477,11 @@ 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 whyNotStillTheRecordedRun(record) {
@@ -39402,11 +39497,14 @@ function whyNotTheRun(record, running, needed) {
   if (running === null) {
     return "the operating system would not describe that process";
   }
+  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)) {
@@ -39457,7 +39555,7 @@ function clearRunRecord(projectPath) {
 }
 function ageMs(path, now) {
   try {
-    return now - statSync7(path).mtimeMs;
+    return now - statSync8(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -39510,9 +39608,9 @@ 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";
@@ -39537,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.`;
@@ -39551,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"] };
@@ -40495,6 +40593,10 @@ class GodotServer {
     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);
   }
@@ -41429,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),
@@ -41500,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 {
@@ -42081,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
       };
@@ -42532,7 +42639,7 @@ class GodotServer {
     }
     let announcedAt;
     try {
-      announcedAt = statSync8(endpoint.file).mtimeMs;
+      announcedAt = statSync9(endpoint.file).mtimeMs;
     } catch {
       return;
     }
@@ -42769,6 +42876,13 @@ 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 ?? "",
@@ -42786,7 +42900,7 @@ class GodotServer {
       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 {
@@ -42810,6 +42924,23 @@ class GodotServer {
     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) {
     const child = spawn4(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
     const cancelled = callSignal();
@@ -42899,6 +43030,8 @@ class GodotServer {
     }
     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,
@@ -42907,6 +43040,7 @@ class GodotServer {
       projectPath,
       startedAt,
       startedBy,
+      ...keeper === undefined ? {} : { keeper },
       command: godotPath,
       exitCode: null,
       exitSignal: null,
@@ -43139,6 +43273,7 @@ class GodotServer {
       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,
@@ -44106,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;
       }
@@ -44182,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) {
@@ -44191,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) {
@@ -44220,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" }
         ]
@@ -44323,7 +44466,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-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, 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();
@@ -44348,6 +44491,7 @@ var init_server3 = __esm(() => {
   init_headless_operations();
   init_issues();
   init_junit();
+  init_keeper_channel();
   init_lsp_client();
   init_outside();
   init_paths();
@@ -44415,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
@@ -44563,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()) {
@@ -45135,6 +45280,35 @@ function recordedEnginePath(projectPath) {
   }
   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;
@@ -45326,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();
@@ -45451,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\`
@@ -45653,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;
     }
@@ -45704,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.`);
   }
@@ -45716,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) {