gdharness 1.0.12 → 1.0.14

package/build/cli.js

@@ -7531,11 +7531,20 @@ var init_update_check = __esm(() => {
 
 // src/server-version.ts
 import { readFileSync as readFileSync3 } from "node:fs";
-function addonMismatch(addonVersion, serverVersion) {
-  if (addonVersion === serverVersion) {
+function editorIsStale(addonVersion, serverVersion, addonDigest, shippedDigest) {
+  if (addonDigest !== undefined && addonDigest !== "" && shippedDigest !== undefined) {
+    return addonDigest !== shippedDigest;
+  }
+  return addonVersion !== serverVersion;
+}
+function addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest) {
+  if (!editorIsStale(addonVersion, serverVersion, addonDigest, shippedDigest)) {
     return;
   }
   const reported = addonVersion ?? "";
+  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.`;
+  }
   const editor = reported === "" ? UNVERSIONED : `the ${reported} addon`;
   const both = `The editor is running ${editor} while this server ships ${serverVersion}.`;
   if (reported !== "" && isNewer(reported, serverVersion)) {
@@ -7543,8 +7552,8 @@ function addonMismatch(addonVersion, serverVersion) {
   }
   return `${both} Restart it with editor_launch restart to pick the new one up.`;
 }
-function markIfStale(answer, addonVersion, serverVersion) {
-  const staleNote = addonMismatch(addonVersion, serverVersion);
+function markIfStale(answer, addonVersion, serverVersion, addonDigest, shippedDigest) {
+  const staleNote = addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest);
   if (staleNote === undefined || typeof answer !== "object" || answer === null || Array.isArray(answer)) {
     return answer;
   }
@@ -7690,6 +7699,19 @@ function cacheWrittenAt(projectPath) {
     return null;
   }
 }
+function declaredSince(projectPath, paths, names, since) {
+  return names.filter((name) => {
+    const path = paths.get(name);
+    if (path === undefined || !path.startsWith("res://")) {
+      return false;
+    }
+    try {
+      return statSync2(join6(projectPath, path.slice("res://".length))).mtimeMs > since;
+    } catch {
+      return false;
+    }
+  });
+}
 function cachedAtMissingPaths(cached, projectPath) {
   return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync6(join6(projectPath, path.slice("res://".length)))).map(([name]) => name).sort();
 }
@@ -15308,8 +15330,57 @@ function readParams(params, key) {
 }
 
 // src/setup.ts
-import { cpSync as cpSync2, existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync8, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
+import { createHash as createHash3 } from "node:crypto";
+import {
+  cpSync as cpSync2,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync4,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync8,
+  rmSync as rmSync4,
+  statSync as statSync4,
+  writeFileSync as writeFileSync6
+} from "node:fs";
 import { dirname as dirname4, join as join9 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function editorAddonDigest2(from = shippedAddonsDirectory2()) {
+  const hash = createHash3("sha256");
+  const walk = (directory, relative) => {
+    for (const name of readdirSync4(directory).sort()) {
+      if (name === VERSION_MARKER2 || name === DIGEST_MARKER2) {
+        continue;
+      }
+      const path = join9(directory, name);
+      const inside = `${relative}/${name}`;
+      if (statSync4(path).isDirectory()) {
+        walk(path, inside);
+      } else {
+        hash.update(`${inside}
+`);
+        hash.update(readFileSync8(path));
+        hash.update(`
+`);
+      }
+    }
+  };
+  for (const name of EDITOR_PLUGINS2) {
+    walk(join9(from, name), name);
+  }
+  return hash.digest("hex");
+}
+function shippedEditorDigest() {
+  if (shippedDigest === undefined) {
+    try {
+      shippedDigest = editorAddonDigest2();
+    } catch {
+      shippedDigest = null;
+    }
+  }
+  return shippedDigest ?? undefined;
+}
+function shippedAddonsDirectory2() {
+  return join9(dirname4(fileURLToPath2(import.meta.url)), "godot", "addons");
+}
 function installedAddonVersion(projectPath) {
   const marker = join9(projectPath, "addons", ADDONS2[0], VERSION_MARKER2);
   if (!existsSync8(marker)) {
@@ -15318,13 +15389,14 @@ function installedAddonVersion(projectPath) {
   const said = readFileSync8(marker, "utf8").trim();
   return said === "" ? null : said;
 }
-var ADDONS2, RUNTIME_AUTOLOAD2, SCRIPT_RUNS_SETTING = "gdharness/runtime/serve_script_runs", BIND_ADDRESS_SETTING = "gdharness/runtime/bind_address", PORT_SETTING = "gdharness/runtime/port", VERSION_MARKER2 = ".gdharness-version";
+var ADDONS2, EDITOR_PLUGINS2, RUNTIME_AUTOLOAD2, SCRIPT_RUNS_SETTING = "gdharness/runtime/serve_script_runs", BIND_ADDRESS_SETTING = "gdharness/runtime/bind_address", PORT_SETTING = "gdharness/runtime/port", VERSION_MARKER2 = ".gdharness-version", DIGEST_MARKER2 = ".gdharness-digest", shippedDigest;
 var init_setup = __esm(() => {
   init_class_cache();
   init_headless();
   init_resources();
   init_server_version();
   ADDONS2 = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
+  EDITOR_PLUGINS2 = ["gdharness_editor", "auto_reload"];
   RUNTIME_AUTOLOAD2 = {
     name: "GdharnessRuntime",
     path: "addons/gdharness_runtime/runtime_autoload.gd"
@@ -31490,7 +31562,7 @@ var init_process_children = __esm(() => {
 });
 
 // src/runtime-client.ts
-import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync3, unlinkSync } from "node:fs";
+import { existsSync as existsSync10, readdirSync as readdirSync6, readFileSync as readFileSync10, statSync as statSync5, unlinkSync } from "node:fs";
 import { createConnection } from "node:net";
 import { tmpdir as tmpdir4 } from "node:os";
 import { dirname as dirname7, join as join12, resolve as resolve3 } from "node:path";
@@ -31599,8 +31671,7 @@ function announcedAndGone(projectPath) {
     return [];
   }
   const since = Date.now() - GONE_WINDOW_MS;
-  const wanted = resolve3(projectPath);
-  return gone.filter((one) => one.noticedAt >= since && resolve3(one.project) === wanted);
+  return gone.filter((one) => one.noticedAt >= since && isSameDirectory(one.project, projectPath));
 }
 function strangersAmong(candidates, now, startTimes = startTimesOf) {
   const toJudge = candidates.filter((one) => {
@@ -31627,7 +31698,7 @@ function announcedIn(directory) {
   const found = [];
   const candidates = [];
   const entries = [];
-  for (const entry of readdirSync4(directory)) {
+  for (const entry of readdirSync6(directory)) {
     const report = ERROR_REPORT_PATTERN.exec(entry);
     if (report) {
       sweepErrorReport(join12(directory, entry), Number.parseInt(report[1] ?? "", 10));
@@ -31643,7 +31714,7 @@ function announcedIn(directory) {
     entries.push({ file, pid, alive });
     if (alive) {
       try {
-        candidates.push({ file, pid, writtenAt: statSync3(file).mtimeMs });
+        candidates.push({ file, pid, writtenAt: statSync5(file).mtimeMs });
       } catch {}
     }
   }
@@ -31700,17 +31771,16 @@ function sweepErrorReport(path, pid, now = Date.now()) {
     return;
   }
   try {
-    if (now - statSync3(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
+    if (now - statSync5(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
       unlinkSync(path);
     }
   } catch {}
 }
 async function announcedSince(projectPath, before, waiting = {}) {
-  const wanted = resolve3(projectPath);
   const directories = waiting.directories ?? runtimeDirectories();
   const until = Date.now() + Math.max(waiting.budgetMs ?? ANNOUNCE_BUDGET_MS, 0);
   for (;; ) {
-    const fresh = discoverRuntimes(directories).find((endpoint) => !before.has(endpoint.pid) && resolve3(endpoint.project.path) === wanted && (waiting.accept?.(endpoint) ?? true));
+    const fresh = discoverRuntimes(directories).find((endpoint) => !before.has(endpoint.pid) && isSameDirectory(endpoint.project.path, projectPath) && (waiting.accept?.(endpoint) ?? true));
     if (fresh !== undefined) {
       return fresh;
     }
@@ -31731,7 +31801,7 @@ function theOneProject(endpoints) {
   if (endpoints.some((endpoint) => endpoint.project.path === "")) {
     return;
   }
-  const paths = new Set(endpoints.map((endpoint) => resolve3(endpoint.project.path)));
+  const paths = new Set(endpoints.map((endpoint) => realPathOr(resolve3(endpoint.project.path))));
   const only = [...paths][0];
   return paths.size === 1 ? only : undefined;
 }
@@ -31760,7 +31830,7 @@ function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
   if (pid !== undefined) {
     const named = endpoints.find((endpoint) => endpoint.pid === pid);
     if (named !== undefined) {
-      if (projectPath !== undefined && resolve3(named.project.path) !== resolve3(projectPath)) {
+      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("; ")}.`
         };
@@ -31803,7 +31873,7 @@ function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
   }
   if (projectPath !== undefined) {
     const wanted = resolve3(projectPath);
-    const matching = endpoints.filter((endpoint) => resolve3(endpoint.project.path) === wanted);
+    const matching = endpoints.filter((endpoint) => isSameDirectory(endpoint.project.path, wanted));
     if (matching.length === 0) {
       return {
         problem: `No running game is from ${wanted}. Running: ${endpoints.map(describe2).join("; ")}.`
@@ -31914,6 +31984,7 @@ function runtimeRequest(endpoint, command, params, timeoutMs) {
 }
 var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, ERROR_REPORT_PATTERN, ERROR_REPORT_KEEP_MS, GONE_WINDOW_MS = 120000, GONE_KEPT = 32, gone, STARTED_AFTER_ANNOUNCING_MS = 2000, CONFIRMED_FOR_MS = 60000, JUDGED_AFTER_MS = 60000, verdicts, ENDED_WITHIN_MS = 3000, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1;
 var init_runtime_client = __esm(() => {
+  init_paths();
   init_process_children();
   ANNOUNCEMENT_PATTERN = /^runtime-(\d+)\.json$/;
   ERROR_REPORT_PATTERN = /^runtime-(\d+)\.log$/;
@@ -32879,7 +32950,7 @@ import {
   readFileSync as readFileSync16,
   readSync,
   rmSync as rmSync8,
-  statSync as statSync4,
+  statSync as statSync6,
   writeFileSync as writeFileSync12
 } from "node:fs";
 import { dirname as dirname12, join as join18 } from "node:path";
@@ -32942,7 +33013,7 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
   return { log, path, ...of === undefined ? {} : { readBytes: text.length, of } };
 }
 function theFirstOf(path) {
-  const whole = statSync4(path).size;
+  const whole = statSync6(path).size;
   if (whole <= MOST_CONSOLE_BYTES) {
     return { text: readFileSync16(path, "utf8") };
   }
@@ -36160,6 +36231,7 @@ var init_godot_bridge = __esm(() => {
         connectedAt: this.connectionInfo?.connectedAt,
         lastPongAt: this.connectionInfo?.lastPongAt,
         addonVersion: this.connectionInfo?.addonVersion,
+        addonDigest: this.connectionInfo?.addonDigest,
         editorPid: this.connectionInfo?.editorPid,
         lspPort: this.connectionInfo?.lspPort,
         dapPort: this.connectionInfo?.dapPort,
@@ -36303,6 +36375,7 @@ var init_godot_bridge = __esm(() => {
             }
             this.connectionInfo.projectPath = message.project_path;
             this.connectionInfo.addonVersion = message.addon_version ?? "";
+            this.connectionInfo.addonDigest = message.addon_digest;
             this.connectionInfo.editorPid = message.editor_pid;
             this.connectionInfo.lspPort = servedPort(message.lsp_port);
             this.connectionInfo.dapPort = servedPort(message.dap_port);
@@ -36556,7 +36629,7 @@ var init_godot_path = __esm(() => {
 });
 
 // src/issues.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import process7 from "node:process";
 function feedbackNotice() {
   return JSON.stringify({
@@ -36574,7 +36647,7 @@ function runtime2() {
 function defectSignature2(where, message) {
   const normalised = `${where}
 ${message}`.toLowerCase().replaceAll("\\", "/").replaceAll(/(?:[a-z]:)?(?:\/+[\w.-]+){2,}/gu, "<path>").replaceAll(/\d+/gu, "0");
-  return createHash2("sha256").update(normalised).digest("hex").slice(0, 8);
+  return createHash4("sha256").update(normalised).digest("hex").slice(0, 8);
 }
 function facts2(where, message, godotVersion) {
   return [
@@ -36911,7 +36984,7 @@ import { realpathSync as realpathSync2 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
 import { dirname as dirname13, resolve as resolve4 } from "node:path";
-import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
+import { fileURLToPath as fileURLToPath4, pathToFileURL } from "node:url";
 function diagnosticsKey(uri) {
   let decoded;
   try {
@@ -36923,7 +36996,7 @@ function diagnosticsKey(uri) {
     return decoded;
   }
   try {
-    return realpathSync2.native(fileURLToPath3(decoded)).toLowerCase();
+    return realpathSync2.native(fileURLToPath4(decoded)).toLowerCase();
   } catch {
     return decoded.toLowerCase();
   }
@@ -37483,7 +37556,7 @@ var init_process_time = __esm(() => {
 });
 
 // src/project-scan.ts
-import { existsSync as existsSync14, readdirSync as readdirSync5, readFileSync as readFileSync17 } from "node:fs";
+import { existsSync as existsSync14, readdirSync as readdirSync7, readFileSync as readFileSync17 } from "node:fs";
 import { join as join19 } from "node:path";
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
@@ -37497,7 +37570,7 @@ function projectStructure(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
@@ -37526,7 +37599,7 @@ function scriptsWithoutUid(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
@@ -37567,7 +37640,7 @@ function searchProject(projectPath, options) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
       if (full()) {
         return;
       }
@@ -37657,7 +37730,7 @@ var init_restart_note = __esm(() => {
 
 // src/run-record.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { mkdirSync as mkdirSync12, openSync as openSync2, readdirSync as readdirSync6, readFileSync as readFileSync19, rmSync as rmSync10, statSync as statSync5, writeFileSync as writeFileSync14 } from "node:fs";
+import { mkdirSync as mkdirSync12, openSync as openSync2, readdirSync as readdirSync8, readFileSync as readFileSync19, rmSync as rmSync10, statSync as statSync7, writeFileSync as writeFileSync14 } from "node:fs";
 import { basename as basename3, join as join21 } from "node:path";
 function runsDirectory() {
   return join21(runtimeDirectory(), "runs");
@@ -37912,7 +37985,7 @@ function clearRunRecord(ours = () => true) {
 }
 function ageMs(path, now) {
   try {
-    return now - statSync5(path).mtimeMs;
+    return now - statSync7(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -37922,7 +37995,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
   const keep = readRunRecord()?.transcript;
   let entries;
   try {
-    entries = readdirSync6(directory);
+    entries = readdirSync8(directory);
   } catch {
     return;
   }
@@ -37957,16 +38030,16 @@ import {
   mkdirSync as mkdirSync13,
   mkdtempSync as mkdtempSync3,
   openSync as openSync3,
-  readdirSync as readdirSync7,
+  readdirSync as readdirSync9,
   readFileSync as readFileSync20,
   readSync as readSync2,
   rmdirSync,
-  statSync as statSync6
+  statSync as statSync8
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
 import { basename as basename4, dirname as dirname15, isAbsolute as isAbsolute3, join as join22, normalize as normalize3, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { promisify as promisify7 } from "node:util";
 function patienceForFrames(frames, atLeast) {
   return Math.max(atLeast, frames / SLOWEST_FRAME_RATE * 1000 + atLeast);
@@ -38212,7 +38285,7 @@ function elsewhereIn(projectPath, asked) {
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
   let near = [];
   try {
-    near = readdirSync7(projectPath, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.toLowerCase() !== root).map((entry) => entry.name).filter((name) => name.toLowerCase().startsWith("test") || root.startsWith(name.toLowerCase()));
+    near = readdirSync9(projectPath, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.toLowerCase() !== root).map((entry) => entry.name).filter((name) => name.toLowerCase().startsWith("test") || root.startsWith(name.toLowerCase()));
   } catch {
     return "";
   }
@@ -39372,7 +39445,7 @@ class GodotServer {
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync15(reportsDir) ? readdirSync7(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync15(reportsDir) ? readdirSync9(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
       const newest = written.at(-1);
       if (newest !== undefined) {
         report = parseJUnit(readFileSync20(join22(reportsDir, newest, "results.xml"), "utf8"));
@@ -39501,7 +39574,7 @@ class GodotServer {
       warnings: diagnostics.length - errors,
       diagnostics,
       ...disagrees
-    }, this.godotBridge.getStatus().addonVersion, SERVER_VERSION));
+    }, this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest()));
   }
   whereTheFileDisagrees(diagnostics, args) {
     const messages = diagnostics.map((entry) => asParams(entry)["message"]).filter((message) => typeof message === "string");
@@ -39688,7 +39761,7 @@ class GodotServer {
   getEditorStatusPayload() {
     const status = this.godotBridge.getStatus();
     const isPortConflict = this.bridgeStartupError?.includes("EADDRINUSE") ?? false;
-    const stale = status.connected && status.addonVersion !== SERVER_VERSION;
+    const stale = status.connected && editorIsStale(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest());
     const unfinished = this.restartLeftUnfinished(status.connected);
     return {
       ...status,
@@ -39705,7 +39778,7 @@ class GodotServer {
       awaitingLaunchedEditor: status.connected || !this.launchedEditorIsUp() ? undefined : this.launchedEditor?.pid ?? undefined,
       ...status.connected ? this.whatTheLaunchedEditorDropped() : {},
       startupError: this.bridgeStartupError,
-      staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION) : undefined,
+      staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest()) : undefined,
       ...this.breakpointsAtRisk(),
       retryingBridge: this.bridgeRetry === null ? undefined : true,
       announcedAt: this.announcedAt ?? undefined,
@@ -39837,8 +39910,8 @@ class GodotServer {
       editorPid: now.editorPid,
       addonVersion: now.addonVersion,
       serverVersion: SERVER_VERSION,
-      addonIsStale: now.addonVersion !== SERVER_VERSION,
-      staleNote: addonMismatch(now.addonVersion, SERVER_VERSION),
+      addonIsStale: editorIsStale(now.addonVersion, SERVER_VERSION, now.addonDigest, shippedEditorDigest()),
+      staleNote: addonMismatch(now.addonVersion, SERVER_VERSION, now.addonDigest, shippedEditorDigest()),
       ...this.whatTheEditorDropped(settingsBefore, after),
       tookMs: Date.now() - began
     });
@@ -40115,7 +40188,7 @@ class GodotServer {
     }
     let announcedAt;
     try {
-      announcedAt = statSync6(endpoint.file).mtimeMs;
+      announcedAt = statSync8(endpoint.file).mtimeMs;
     } catch {
       return;
     }
@@ -40725,7 +40798,15 @@ class GodotServer {
         "editor_launch opens one, and an editor opened here has its console captured"
       ]);
     }
-    const console2 = editorConsole(projectPath, status.editorPid ?? null, status.openedByAServer === true);
+    const launched = status.connected ? null : this.launchedEditor?.pid ?? null;
+    if (!status.connected && 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);
     if ("kind" in console2) {
       return this.createErrorResponse(theConsoleWasNotCaptured(console2, projectPath), [
         "editor_launch restart replaces this editor with one whose console is captured",
@@ -40743,8 +40824,9 @@ class GodotServer {
     const grouped = bursts(everything, readPositiveNumber(args, "before") ?? 3);
     const shown = grouped.slice(0, MOST_GROUPS);
     return this.jsonTextResponse({
-      editorPid: status.editorPid,
+      editorPid: editorPid ?? undefined,
       projectPath,
+      ...status.connected ? {} : this.launchedEditorIsUp() ? { stillConnecting: true } : { exitedBeforeConnecting: true },
       capturedIn: console2.path,
       ...console2.of === undefined ? {} : {
         readFromTheStart: console2.readBytes,
@@ -41043,6 +41125,7 @@ class GodotServer {
   }
   async rebuildClassCache(projectPath) {
     const before = cachedClasses(projectPath);
+    const writtenBefore = cacheWrittenAt(projectPath);
     const noted = readClassNote(projectPath);
     const rebuilt = await this.operation("refresh_class_cache", {}, projectPath);
     if (!rebuilt.ok) {
@@ -41053,21 +41136,30 @@ class GodotServer {
       return rebuilt;
     }
     const lost = noted === null || before === null ? [] : noted.rebuiltWith.filter((name) => !before.has(name) && after.has(name)).sort();
-    const seenLosing = lost.length > 0 && this.godotBridge.isConnected();
+    const cameBack = writtenBefore === null ? [] : declaredSince(projectPath, after, lost, writtenBefore);
+    const droppedByTheEditor = lost.filter((name) => !cameBack.includes(name));
+    const seenLosing = droppedByTheEditor.length > 0 && this.godotBridge.isConnected();
     writeClassNote(projectPath, {
       rebuiltWith: [...after.keys()].sort(),
       ...seenLosing ? { shortListEditorPid: this.godotBridge.getStatus().editorPid ?? null } : noted?.shortListEditorPid === undefined ? {} : { shortListEditorPid: noted.shortListEditorPid }
     });
-    if (!seenLosing) {
+    const notes = [];
+    if (seenLosing) {
+      const them = droppedByTheEditor.length === 1 ? "it" : "them";
+      notes.push(`The cache held ${droppedByTheEditor.join(", ")} after the last rebuild and not when this one began, so the editor holding this project wrote it without ${them} in between: it holds a list shorter than the files and writes that list on every save and scan, and each rebuild puts ${them} back. editor_launch restart is what ends it.`);
+    }
+    if (cameBack.length > 0) {
+      notes.push(`${cameBack.join(", ")} left the cache while ${cameBack.length === 1 ? "its script was" : "their scripts were"} gone: the script${cameBack.length === 1 ? " is" : "s are"} newer than the cache the editor last wrote, so it listed what was on disk then. editor_rescan picks ${cameBack.length === 1 ? "it" : "them"} up.`);
+    }
+    if (notes.length === 0) {
       return rebuilt;
     }
-    const them = lost.length === 1 ? "it" : "them";
     return {
       ...rebuilt,
       payload: {
         ...rebuilt.payload,
         lostSinceLastRebuild: lost,
-        note: `The cache held ${lost.join(", ")} after the last rebuild and not when this one began, so the editor holding this project wrote it without ${them} in between: it holds a list shorter than the files and writes that list on every save and scan, and each rebuild puts ${them} back. editor_launch restart is what ends it.`
+        note: notes.join(" ")
       }
     };
   }
@@ -41143,7 +41235,7 @@ class GodotServer {
       ]);
     }
     try {
-      return this.jsonTextResponse(markIfStale(await this.godotBridge.invokeTool(toolName, args), this.godotBridge.getStatus().addonVersion, SERVER_VERSION));
+      return this.jsonTextResponse(markIfStale(await this.godotBridge.invokeTool(toolName, args), this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest()));
     } catch (error) {
       return this.createErrorResponse(`The editor answered ${toolName} with an error: ${errorMessage(error)}`);
     }
@@ -41196,8 +41288,59 @@ class GodotServer {
     }
     return { heldAt: undefined, heldUnknown: true, heldNote: reply.message };
   }
+  async ownRunOnItsWay(projectPath, budgetMs) {
+    const run = this.currentRun();
+    const project = projectPath ?? run?.projectPath ?? null;
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync15(join22(project, RUNTIME_AUTOLOAD2.path)) || !await this.runStillGoing(run)) {
+      return null;
+    }
+    const already = runtimesAnnounced().running;
+    const announcedSinceTheStart = (one) => {
+      if (run.announcedBefore !== undefined) {
+        return !run.announcedBefore.has(one.pid);
+      }
+      try {
+        return statSync8(one.file).mtimeMs >= run.startedAt;
+      } catch {
+        return false;
+      }
+    };
+    if (already.some((one) => announcedSinceTheStart(one) && this.isTheGameOf(run, one, project))) {
+      return null;
+    }
+    const which = run.throughEditor ? "the game the editor is playing for it" : `pid ${run.pid ?? "unknown"}`;
+    const comingUpUntil = run.startedAt + waitSizedTo(readBootNote(project)) + budgetMs;
+    const remaining = comingUpUntil - Date.now();
+    if (remaining <= 0) {
+      const seconds = Math.round((Date.now() - run.startedAt) / 1000);
+      return `The game this server started (${which}) has been running for ${seconds}s and has not announced its runtime, so there is nothing to talk to. A game that keeps the runtime off, as a project's own loader can for some scenes, never announces; editor_output says what it has printed.`;
+    }
+    const endpoint = await announcedSince(project, new Set(already.map((one) => one.pid)), {
+      budgetMs: Math.min(budgetMs, remaining),
+      accept: (one) => this.isTheGameOf(this.currentRun(), one, project),
+      giveUp: () => this.currentRun() !== run || this.dapClient?.isStopped() === true || !stillRunning(run)
+    });
+    if (endpoint !== null) {
+      const tiedMeanwhile = () => run.announcedPid !== undefined;
+      if (!tiedMeanwhile()) {
+        this.tie(run, endpoint);
+      }
+      return null;
+    }
+    if (this.currentRun() !== run || !await this.runStillGoing(run)) {
+      return null;
+    }
+    return `The game this server started (${which}) is still coming up and has not announced its runtime after a wait of ${Math.min(budgetMs, remaining)}ms, so there is nothing to talk to yet. It is still running: ask again in a moment rather than starting another.`;
+  }
   async handleRuntimeCommand(command, args, timeoutMs = this.runtimeTimeoutMs()) {
     const { op: _op, projectPath, pid, ...params } = asParams(args);
+    const waited = typeof pid === "number" ? null : await this.ownRunOnItsWay(typeof projectPath === "string" ? projectPath : this.ownProject, timeoutMs);
+    if (waited !== null) {
+      return this.createErrorResponse(waited, [
+        "editor_status lists it under runtimes once it has announced",
+        "editor_output says what it has printed so far"
+      ]);
+    }
     const announced = runtimesAnnounced();
     const wanted = typeof projectPath === "string" ? projectPath : this.ownProject ?? undefined;
     const own = typeof pid === "number" ? undefined : this.ownGameAmong(announced.running, wanted) ?? await this.ownGameThroughTheTree(announced.running, wanted);
@@ -41346,7 +41489,7 @@ var init_server3 = __esm(() => {
   init_tool_definitions();
   init_update_check();
   run7 = promisify7(execFile7);
-  __dirname2 = dirname15(fileURLToPath4(import.meta.url));
+  __dirname2 = dirname15(fileURLToPath5(import.meta.url));
   CONSOLE_WRAPPER = /_console(\.exe)?$/i;
   LONGEST_BOOT_NOTED_MS = 5 * 60000;
   VALUE_NAMES = {
@@ -42565,7 +42708,17 @@ init_headless();
 init_resources();
 init_server_version();
 import { spawnSync } from "node:child_process";
-import { cpSync, existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync7, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { createHash as createHash2 } from "node:crypto";
+import {
+  cpSync,
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync7,
+  rmSync as rmSync3,
+  statSync as statSync3,
+  writeFileSync as writeFileSync5
+} from "node:fs";
 import { dirname as dirname3, join as join8 } from "node:path";
 import { fileURLToPath } from "node:url";
 var ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
@@ -42575,6 +42728,40 @@ var RUNTIME_AUTOLOAD = {
   path: "addons/gdharness_runtime/runtime_autoload.gd"
 };
 var VERSION_MARKER = ".gdharness-version";
+var DIGEST_MARKER = ".gdharness-digest";
+function editorAddonDigest(from = shippedAddonsDirectory()) {
+  const hash = createHash2("sha256");
+  const walk = (directory, relative) => {
+    for (const name of readdirSync3(directory).sort()) {
+      if (name === VERSION_MARKER || name === DIGEST_MARKER) {
+        continue;
+      }
+      const path = join8(directory, name);
+      const inside = `${relative}/${name}`;
+      if (statSync3(path).isDirectory()) {
+        walk(path, inside);
+      } else {
+        hash.update(`${inside}
+`);
+        hash.update(readFileSync7(path));
+        hash.update(`
+`);
+      }
+    }
+  };
+  for (const name of EDITOR_PLUGINS) {
+    walk(join8(from, name), name);
+  }
+  return hash.digest("hex");
+}
+function installedEditorDigest(projectPath) {
+  const marker = join8(projectPath, "addons", ADDONS[0], DIGEST_MARKER);
+  if (!existsSync7(marker)) {
+    return null;
+  }
+  const said = readFileSync7(marker, "utf8").trim();
+  return said === "" ? null : said;
+}
 function shippedAddonsDirectory() {
   return join8(dirname3(fileURLToPath(import.meta.url)), "godot", "addons");
 }
@@ -42597,6 +42784,8 @@ function installAddons(projectPath, from = shippedAddonsDirectory()) {
 `);
     installed.push({ name, path: target, replaced });
   }
+  writeFileSync5(join8(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
+`);
   return installed;
 }
 function removeAddons(projectPath) {
@@ -42741,7 +42930,7 @@ function inspectProject(projectPath) {
 // src/skill.ts
 init_setup();
 init_tool_definitions();
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, readdirSync as readdirSync3, rmSync as rmSync5, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readdirSync as readdirSync5, rmSync as rmSync5, writeFileSync as writeFileSync7 } from "node:fs";
 import { basename, dirname as dirname5, join as join10 } from "node:path";
 
 // src/tool-reference.ts
@@ -42863,7 +43052,8 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
   this server is connected to. There is no ambient project, and an argument a tool does not declare is refused
   rather than ignored.
 - \`editor_status\` says whether an editor is connected and whether its addon matches the server.
-  \`addonIsStale\` means they differ, and \`staleNote\` says which half is behind: an editor that
+  \`addonIsStale\` means the editor is running different addon code from what the server ships
+  (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.
@@ -43050,7 +43240,7 @@ function pruneEmpty(directory, projectPath) {
   const shared = join10(projectPath, ".agents");
   let path = directory;
   while (path !== projectPath && (basename(path) === "skills" || path === shared)) {
-    if (readdirSync3(path).length > 0) {
+    if (readdirSync5(path).length > 0) {
       return;
     }
     rmSync5(path, { recursive: true, force: true });
@@ -43074,9 +43264,9 @@ function writeSkill(directories, version) {
 // src/version.ts
 import { readFileSync as readFileSync9 } from "node:fs";
 import { dirname as dirname6, join as join11 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 function getLocalVersion() {
-  const currentDirectory = dirname6(fileURLToPath2(import.meta.url));
+  const currentDirectory = dirname6(fileURLToPath3(import.meta.url));
   const packageCandidates = [
     join11(currentDirectory, "..", "package.json"),
     join11(currentDirectory, "..", "..", "package.json")
@@ -43338,6 +43528,7 @@ async function upgrade() {
   }
   const godot = await engine(projectPath);
   console.log(installed === version ? `already ${version}; reinstalling` : `${installed} -> ${version}`);
+  const digestBefore = installedEditorDigest(projectPath);
   for (const addon of installAddons(projectPath)) {
     console.log(`${addon.replaced ? "replaced" : "installed"} ${addon.path}`);
   }
@@ -43369,8 +43560,10 @@ async function upgrade() {
     console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
   }
   console.log(`
-On ${version}. Two things this could not do for you:`);
-  console.log(`  1. The open editor is still running the addons it loaded at startup. Restart it with the
+On ${version}. What is left for you:`);
+  console.log(digestBefore !== null && digestBefore === installedEditorDigest(projectPath) ? `  1. Nothing for the editor: this upgrade left the editor addons the same code as before,
+` + `     so it gives an open editor nothing to restart for. editor_status says addonIsStale
+` + "     if the editor is older than that." : `  1. The open editor is still running the addons it loaded at startup. Restart it with the
 ` + "     editor_launch restart tool, which closes and reopens the window.");
   console.log(harnessNote({ moved, written, byHand }, [launch.command, ...launch.args].join(" ")));
 }