gdharness 1.0.11 → 1.0.13

package/build/cli.js

@@ -182,8 +182,18 @@ function runArguments(options) {
   }
   return args;
 }
-function editorArguments(projectPath, ports) {
-  return ["-e", "--path", projectPath, "--lsp-port", String(ports.lsp), "--dap-port", String(ports.dap)];
+function editorArguments(projectPath, ports, logFile) {
+  return [
+    "-e",
+    "--path",
+    projectPath,
+    "--lsp-port",
+    String(ports.lsp),
+    "--dap-port",
+    String(ports.dap),
+    "--log-file",
+    logFile
+  ];
 }
 function userDataIn(home, variables = process.env) {
   const moved = ["APPDATA", "XDG_DATA_HOME"];
@@ -7263,6 +7273,9 @@ class GameLog {
   count(severity) {
     return this.entries.filter((entry) => entry.severity === severity).length;
   }
+  everything() {
+    return this.entries;
+  }
   select(options) {
     const floor = options.sinceLastCall ? this.seen[options.severity] : 0;
     const wanted = ADMITTED[options.severity];
@@ -7518,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)) {
@@ -7530,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;
   }
@@ -7677,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();
 }
@@ -15295,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)) {
@@ -15305,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"
@@ -15349,7 +15434,7 @@ function projectPathSentence(without = callsWithoutProjectPath()) {
   return `Every call takes \`projectPath\` except ${named}, which ${without.length === 1 ? "takes" : "take"} none`;
 }
 function theGamePicked() {
-  return "the game this server started or is playing when it is among those running, named under " + "`answeredBy` where there was a choice; else the only game there is; else a refusal naming " + "every game, which is what a machine running two projects at once gets";
+  return "the game this server started or is playing when it is among those running, named under " + "`answeredBy` where there was a choice; else the only game there is; else a refusal naming " + "every game and which argument tells them apart, `pid` when they are all one project and " + "`projectPath` when they are not";
 }
 function toolSpec(name) {
   return SPECS_BY_NAME[name];
@@ -16070,7 +16155,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_output",
-      description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. For a run the editor plays the reports come from the game itself, through the runtime addon, since the editor's debugger relays what a game prints and not what it reports; a played game without the runtime addon answers here with its prints alone. Answers with the counts and the verdict as well as the entries. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering.",
+      description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. For a run the editor plays the reports come from the game itself, through the runtime addon, since the editor's debugger relays what a game prints and not what it reports; a played game without the runtime addon answers here with its prints alone. Answers with the counts and the verdict as well as the entries. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering. op: \"editor\" answers about the editor itself instead, which is a different log and the only way anything here can read what an editor printed: its console reaches no plugin, so the addon cannot scrape it, and an editor gdharness opened is asked for a log file as it starts. That covers the whole session from the editor's first line, which is where the output worth reading usually is, since the class cache, the plugins and the language server all say what they have to say before any harness has connected. The answer carries the entries in the order they were printed and, beside them under repeated, each message shape several lines share: how many, what varied in each slot of it and how many different values stood there, the first occurrence, and the ordinary lines above the group, found by walking back past the group rather than by counting lines. An editor somebody opened by hand has no console here and is refused saying so rather than answered empty, because an editor that printed nothing and an editor nobody captured are not the same thing.",
       parameters: {
         severity: {
           type: "string",
@@ -16078,10 +16163,12 @@ var init_tool_definitions = __esm(() => {
           description: "The least severe entry to include. Default info, which is everything."
         },
         sinceLastCall: {
+          ops: ["run"],
           type: "boolean",
           description: "Only entries this has not already answered with at this severity. Default false. Measured per severity floor and not across them, so polling for errors leaves the rest of the output for a later read rather than consuming it, and a read with contains is a search over the whole run and consumes nothing."
         },
         cpu: {
+          ops: ["run"],
           type: "boolean",
           description: "Also answer with cpuSeconds, the processor time the run has used. Default false, because asking costs a subprocess. Worth it when elapsedMs is climbing and nothing is being printed: processor time standing still is a run that has stopped doing anything, rather than one that is slow."
         },
@@ -16092,8 +16179,24 @@ var init_tool_definitions = __esm(() => {
         limit: {
           type: "number",
           description: "The most entries to answer with, newest kept. Default 200, and omitted says how many matching entries that left out. A run long enough to pass it needs this raised, not just filtered: filtering narrows what counts as matching, and the newest of those is still all one answer carries."
+        },
+        before: {
+          ops: ["editor"],
+          type: "number",
+          description: "How many lines above a repeated group to carry with it, counting only lines that are not themselves part of a group. Default 3. The line that explains a wall of identical errors is the last ordinary line above it, so this walks past the wall rather than a fixed distance back."
         }
       },
+      operations: {
+        run: {
+          summary: "What the game a run is playing has printed, which is everything described above",
+          requires: []
+        },
+        editor: {
+          summary: "What the connected editor itself has printed, from its first line, with repeated messages grouped and the ordinary lines above each group carried with it",
+          requires: []
+        }
+      },
+      defaultOperation: "run",
       requires: []
     },
     {
@@ -31459,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";
@@ -31596,7 +31699,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));
@@ -31612,7 +31715,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 {}
     }
   }
@@ -31669,7 +31772,7 @@ 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 {}
@@ -31693,10 +31796,37 @@ async function announcedSince(projectPath, before, waiting = {}) {
 function describe2(endpoint) {
   return `pid ${endpoint.pid} on ${endpoint.address}:${endpoint.port} (${endpoint.project.name || "unnamed"} at ${endpoint.project.path})`;
 }
+function describeWithin(endpoint) {
+  return `pid ${endpoint.pid} on ${endpoint.address}:${endpoint.port}`;
+}
+function theOneProject(endpoints) {
+  if (endpoints.some((endpoint) => endpoint.project.path === "")) {
+    return;
+  }
+  const paths = new Set(endpoints.map((endpoint) => resolve3(endpoint.project.path)));
+  const only = [...paths][0];
+  return paths.size === 1 ? only : undefined;
+}
+function severalFrom(project, games) {
+  return `${games.length} games are running from ${project}: ${games.map(describeWithin).join("; ")}. ` + "Pass pid to choose one; projectPath cannot, because every one of them has this one. " + "editor_status lists them under runtimes.";
+}
+function whichHalfIsBehind(unspoken) {
+  const pids = (games) => games.map((game) => `pid ${game.pid}`).join(", ");
+  const ahead = unspoken.filter((game) => game.protocol > RUNTIME_PROTOCOL);
+  const behind = unspoken.filter((game) => game.protocol < RUNTIME_PROTOCOL);
+  if (ahead.length > 0 && behind.length > 0) {
+    return `they are on both sides of it: reconnect this server for ${pids(ahead)}, and reinstall the ` + `addon and restart ${pids(behind)}`;
+  }
+  if (ahead.length > 0) {
+    return "this server is the older half: reconnect it so it spawns the installed version";
+  }
+  return `the addon is the older half: reinstall it and restart ${behind.length === 1 ? "the game" : "those games"}`;
+}
 function tooNew(unspoken) {
   const named = unspoken.map((game) => `pid ${game.pid} speaks ${game.protocol} (${game.project.name || "unnamed"} at ${game.project.path})`).join("; ");
-  const half = unspoken.some((game) => game.protocol > RUNTIME_PROTOCOL) ? "this server is the older half: reconnect it so it spawns the installed version" : "the addon is the older half: reinstall it and restart the game";
-  return `A game is running, in a protocol this server does not speak ${named}. This server speaks ${RUNTIME_PROTOCOL}, so ${half}.`;
+  const count = unspoken.length === 1 ? "A game is running" : `${unspoken.length} games are running`;
+  const spoken = new Set(unspoken.map((game) => game.protocol)).size === 1 ? "a protocol" : "protocols";
+  return `${count}, in ${spoken} this server does not speak: ${named}. This server speaks ${RUNTIME_PROTOCOL}, so ${whichHalfIsBehind(unspoken)}.`;
 }
 function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
   if (pid !== undefined) {
@@ -31713,8 +31843,16 @@ function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
     if (tooNewToo !== undefined) {
       return { problem: tooNew([tooNewToo]) };
     }
+    if (endpoints.length > 0) {
+      return {
+        problem: `No running game has pid ${pid}. Running: ${endpoints.map(describe2).join("; ")}. editor_status lists them under runtimes as they come and go.`
+      };
+    }
+    if (unspoken.length > 0) {
+      return { problem: `No game reachable from here has pid ${pid}. ${tooNew(unspoken)}` };
+    }
     return {
-      problem: endpoints.length === 0 ? `No game with the runtime addon is running, so there is none with pid ${pid}. Start one with editor_run, or play the project from the editor with the addon enabled.` : `No running game has pid ${pid}. Running: ${endpoints.map(describe2).join("; ")}. editor_status lists them under runtimes as they come and go.`
+      problem: `No game with the runtime addon is running, so there is none with pid ${pid}. Start one with editor_run, or play the project from the editor with the addon enabled.`
     };
   }
   if (endpoints.length === 0) {
@@ -31746,15 +31884,17 @@ function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
     if (matching.length === 1 && matching[0]) {
       return { endpoint: matching[0] };
     }
-    return {
-      problem: `Several games are running from ${wanted}: ${matching.map(describe2).join("; ")}. Pass pid to choose one.`
-    };
+    return { problem: severalFrom(wanted, matching) };
   }
   if (endpoints.length === 1 && endpoints[0]) {
     return { endpoint: endpoints[0] };
   }
+  const shared = theOneProject(endpoints);
+  if (shared !== undefined) {
+    return { problem: severalFrom(shared, endpoints) };
+  }
   return {
-    problem: `Several games are running: ${endpoints.map(describe2).join("; ")}. Pass projectPath to choose one, or pid when they are from one project.`
+    problem: `Several games are running: ${endpoints.map(describe2).join("; ")}. Pass pid to choose one, or projectPath when the project you mean is running only one.`
   };
 }
 function runtimeRequest(endpoint, command, params, timeoutMs) {
@@ -32802,6 +32942,235 @@ var init_dap_client = __esm(() => {
   init_ports();
 });
 
+// src/editor-log.ts
+import {
+  closeSync,
+  existsSync as existsSync12,
+  mkdirSync as mkdirSync10,
+  openSync,
+  readFileSync as readFileSync16,
+  readSync,
+  rmSync as rmSync8,
+  statSync as statSync6,
+  writeFileSync as writeFileSync12
+} from "node:fs";
+import { dirname as dirname12, join as join18 } from "node:path";
+function editorLogPath(projectPath) {
+  return join18(projectPath, ".godot", "gdharness-editor.log");
+}
+function editorLogNotePath(projectPath) {
+  return join18(projectPath, ".godot", "gdharness-editor.json");
+}
+function readEditorLogNote(projectPath) {
+  try {
+    const fields = asParams(JSON.parse(readFileSync16(editorLogNotePath(projectPath), "utf8")));
+    const pid = readNumber(fields, "pid");
+    const startedAt = readString(fields, "startedAt");
+    return pid !== undefined && Number.isInteger(pid) && pid > 0 && startedAt !== undefined ? { pid, startedAt } : null;
+  } catch {
+    return null;
+  }
+}
+function clearEditorLog(projectPath) {
+  try {
+    const path = editorLogPath(projectPath);
+    mkdirSync10(dirname12(path), { recursive: true });
+    rmSync8(path, { force: true });
+    rmSync8(editorLogNotePath(projectPath), { force: true });
+  } catch {}
+}
+function writeEditorLogNote(projectPath, pid) {
+  try {
+    const path = editorLogNotePath(projectPath);
+    mkdirSync10(dirname12(path), { recursive: true });
+    writeFileSync12(path, JSON.stringify({ pid, startedAt: new Date().toISOString() }, null, 2), "utf8");
+  } catch {}
+}
+function theConsoleWasNotCaptured(why, projectPath) {
+  if (why.kind === "not ours") {
+    return "This editor was not opened by gdharness, so its console was never captured and nothing " + "here has it: an editor prints to a console no plugin can read, and the addon cannot get " + "at it from inside. This is not an editor that printed nothing.";
+  }
+  if (why.kind === "older server") {
+    return `This editor was opened by a gdharness server, but the console beside ${projectPath} belongs ` + `to editor ${why.notedPid ?? "none recorded"} rather than to this one, so it holds an ` + "earlier session and is not offered as this one. A server from before consoles were " + "captured leaves exactly this.";
+  }
+  return "This editor was opened by gdharness and has written nothing to its console file yet, not " + "even the engine version it prints first, so the file is missing rather than empty. An " + "editor that could not open the file for writing leaves this.";
+}
+function editorConsole(projectPath, editorPid, openedByAServer) {
+  if (!openedByAServer) {
+    return { kind: "not ours" };
+  }
+  const noted = readEditorLogNote(projectPath);
+  if (noted === null || editorPid === null || noted.pid !== editorPid) {
+    return { kind: "older server", notedPid: noted?.pid ?? null };
+  }
+  const path = editorLogPath(projectPath);
+  if (!existsSync12(path)) {
+    return { kind: "not written" };
+  }
+  const log = new GameLog;
+  const { text, of } = theFirstOf(path);
+  log.append("transcript", text);
+  log.finish();
+  return { log, path, ...of === undefined ? {} : { readBytes: text.length, of } };
+}
+function theFirstOf(path) {
+  const whole = statSync6(path).size;
+  if (whole <= MOST_CONSOLE_BYTES) {
+    return { text: readFileSync16(path, "utf8") };
+  }
+  const handle = openSync(path, "r");
+  try {
+    const buffer = Buffer.alloc(MOST_CONSOLE_BYTES);
+    const read = readSync(handle, buffer, 0, MOST_CONSOLE_BYTES, 0);
+    const decoded = buffer.subarray(0, read).toString("utf8");
+    const lastLine = decoded.lastIndexOf(`
+`);
+    return { text: lastLine === -1 ? decoded : decoded.slice(0, lastLine + 1), of: whole };
+  } finally {
+    closeSync(handle);
+  }
+}
+function shapeOf(text) {
+  const values = [];
+  let shape = "";
+  let at = 0;
+  while (at < text.length) {
+    let earliest = null;
+    for (const pattern of SLOTS) {
+      pattern.lastIndex = at;
+      const found = pattern.exec(text);
+      if (found !== null && (earliest === null || found.index < earliest.index || found.index === earliest.index && found[0].length > earliest.value.length)) {
+        earliest = { index: found.index, value: found[0] };
+      }
+    }
+    if (earliest === null) {
+      shape += text.slice(at);
+      break;
+    }
+    if (earliest.value.length === 0) {
+      shape += text.slice(at, at + 1);
+      at += 1;
+      continue;
+    }
+    shape += `${text.slice(at, earliest.index)}…`;
+    values.push(earliest.value);
+    at = earliest.index + earliest.value.length;
+  }
+  return { shape, values };
+}
+function bursts(entries, before) {
+  const shapes = new Map;
+  const shaped = entries.map((entry) => shapeOf(entry.text));
+  for (const [at, entry] of entries.entries()) {
+    const key = `${entry.severity}\x00${shaped[at]?.shape ?? entry.text}`;
+    const group = shapes.get(key) ?? { indices: [], values: [] };
+    group.indices.push(at);
+    group.values.push(shaped[at]?.values ?? []);
+    shapes.set(key, group);
+  }
+  const collapsed = new Set;
+  for (const group of shapes.values()) {
+    if (group.indices.length > 1) {
+      for (const at of group.indices) {
+        collapsed.add(at);
+      }
+    }
+  }
+  const repeated = [];
+  for (const [key, group] of shapes) {
+    const first = group.indices[0];
+    if (group.indices.length < 2 || first === undefined) {
+      continue;
+    }
+    const entry = entries[first];
+    if (entry === undefined) {
+      continue;
+    }
+    repeated.push({
+      shape: key.slice(key.indexOf("\x00") + 1),
+      count: group.indices.length,
+      severity: entry.severity,
+      first: { index: entry.index, text: entry.text },
+      slots: slotsOf(group.values, group.indices.length),
+      before: linesBefore(entries, first, collapsed, before)
+    });
+  }
+  return repeated.sort((one, other) => other.count - one.count);
+}
+function slotsOf(values, count) {
+  const width = Math.max(0, ...values.map((row) => row.length));
+  const distinct = [];
+  for (let at = 0;at < width; at += 1) {
+    distinct.push([...new Set(values.map((row) => row[at]).filter((one) => one !== undefined))]);
+  }
+  const slots = [];
+  for (let at = 0;at < width; at += 1) {
+    const seen = distinct[at] ?? [];
+    const partner = theSlotItMovesWith(values, distinct, at);
+    const paired = partner === undefined ? {} : { movesWith: partner };
+    if (seen.length === count && count > 1) {
+      slots.push({ distinct: seen.length, allDifferent: true, ...paired });
+      continue;
+    }
+    const some = seen.slice(0, NAMED_VALUES);
+    slots.push({
+      distinct: seen.length,
+      some,
+      ...seen.length > some.length ? { more: seen.length - some.length } : {},
+      ...paired
+    });
+  }
+  return slots;
+}
+function theSlotItMovesWith(values, distinct, at) {
+  const mine = distinct[at] ?? [];
+  if (mine.length < 2) {
+    return;
+  }
+  for (let other = 0;other < at; other += 1) {
+    if ((distinct[other] ?? []).length !== mine.length) {
+      continue;
+    }
+    const goesWith = new Map;
+    let oneForOne = true;
+    for (const row of values) {
+      const theirs = row[other];
+      const ours = row[at];
+      if (theirs === undefined || ours === undefined) {
+        oneForOne = false;
+        break;
+      }
+      const already = goesWith.get(theirs);
+      if (already === undefined) {
+        goesWith.set(theirs, ours);
+      } else if (already !== ours) {
+        oneForOne = false;
+        break;
+      }
+    }
+    if (oneForOne) {
+      return other;
+    }
+  }
+  return;
+}
+function linesBefore(entries, at, collapsed, wanted) {
+  const found = [];
+  for (let back = at - 1;back >= 0 && at - back <= WALK_BACK_LIMIT && found.length < wanted; back -= 1) {
+    const entry = entries[back];
+    if (entry !== undefined && !collapsed.has(back)) {
+      found.push(entry.text);
+    }
+  }
+  return found.reverse();
+}
+var MOST_CONSOLE_BYTES, NAMED_VALUES = 6, WALK_BACK_LIMIT = 500, SLOTS;
+var init_editor_log = __esm(() => {
+  init_game_log();
+  MOST_CONSOLE_BYTES = 8 * 1024 * 1024;
+  SLOTS = [/"[^"]*"/g, /'[^']*'/g, /\b(?:res|user):\/\/\S+/g, /(?<=\.gd|\.tscn|\.cs):\d+(?::\d+)?/g];
+});
+
 // node_modules/ws/lib/constants.js
 var require_constants = __commonJS(function(exports, module) {
   var BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"];
@@ -35863,6 +36232,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,
@@ -36006,6 +36376,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);
@@ -36182,7 +36553,7 @@ var init_godot_bridge = __esm(() => {
 
 // src/godot-path.ts
 import { execFile as execFile5 } from "node:child_process";
-import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 import { normalize as normalize2 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 
@@ -36237,7 +36608,7 @@ class GodotLocator2 {
       return known;
     }
     let reason;
-    if (path !== "godot" && !existsSync12(path)) {
+    if (path !== "godot" && !existsSync13(path)) {
       reason = "does not exist";
     } else {
       try {
@@ -36259,7 +36630,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({
@@ -36277,7 +36648,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 [
@@ -36613,8 +36984,8 @@ var init_junit = __esm(() => {
 import { realpathSync as realpathSync2 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname12, resolve as resolve4 } from "node:path";
-import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
+import { dirname as dirname13, resolve as resolve4 } from "node:path";
+import { fileURLToPath as fileURLToPath4, pathToFileURL } from "node:url";
 function diagnosticsKey(uri) {
   let decoded;
   try {
@@ -36626,7 +36997,7 @@ function diagnosticsKey(uri) {
     return decoded;
   }
   try {
-    return realpathSync2.native(fileURLToPath3(decoded)).toLowerCase();
+    return realpathSync2.native(fileURLToPath4(decoded)).toLowerCase();
   } catch {
     return decoded.toLowerCase();
   }
@@ -36741,7 +37112,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname12(resolve4(filePath));
+    const rootPath = this.rootPath ?? dirname13(resolve4(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params) {
@@ -37186,13 +37557,13 @@ var init_process_time = __esm(() => {
 });
 
 // src/project-scan.ts
-import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync16 } from "node:fs";
-import { join as join18 } from "node:path";
+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);
 }
 function steppedOver(directory) {
-  return existsSync13(join18(directory, ".gdignore"));
+  return existsSync14(join19(directory, ".gdignore"));
 }
 function projectStructure(projectPath) {
   const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
@@ -37200,12 +37571,12 @@ 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;
       }
       if (entry.isDirectory()) {
-        visit(join18(directory, entry.name));
+        visit(join19(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (extension === "tscn") {
@@ -37229,20 +37600,20 @@ 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;
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join18(directory, entry.name), spelled);
+        visit(join19(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync13(join18(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync14(join19(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -37270,14 +37641,14 @@ 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;
       }
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join18(directory, entry.name);
+      const entryPath = join19(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -37288,7 +37659,7 @@ function searchProject(projectPath, options) {
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync16(entryPath, "utf8").split(`
+      for (const [index, line] of readFileSync17(entryPath, "utf8").split(`
 `).entries()) {
         if (full()) {
           break;
@@ -37317,16 +37688,16 @@ var init_project_scan = __esm(() => {
 });
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync17, rmSync as rmSync8, writeFileSync as writeFileSync12 } from "node:fs";
-import { dirname as dirname13, join as join19 } from "node:path";
+import { mkdirSync as mkdirSync11, readFileSync as readFileSync18, rmSync as rmSync9, writeFileSync as writeFileSync13 } from "node:fs";
+import { dirname as dirname14, join as join20 } from "node:path";
 function restartNotePath(projectPath) {
-  return join19(projectPath, ".godot", "gdharness-restart.json");
+  return join20(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync10(dirname13(path), { recursive: true });
-    writeFileSync12(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync11(dirname14(path), { recursive: true });
+    writeFileSync13(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
@@ -37334,7 +37705,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync17(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync18(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -37349,7 +37720,7 @@ function restartOwed(projectPath) {
 }
 function restartSettled(projectPath) {
   try {
-    rmSync8(restartNotePath(projectPath), { force: true });
+    rmSync9(restartNotePath(projectPath), { force: true });
   } catch (error) {
     console.error(`[SERVER] Could not clear the restart note: ${errorMessage(error)}`);
   }
@@ -37360,36 +37731,36 @@ var init_restart_note = __esm(() => {
 
 // src/run-record.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { mkdirSync as mkdirSync11, openSync, readdirSync as readdirSync6, readFileSync as readFileSync18, rmSync as rmSync9, statSync as statSync4, writeFileSync as writeFileSync13 } from "node:fs";
-import { basename as basename3, join as join20 } from "node:path";
+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 join20(runtimeDirectory(), "runs");
+  return join21(runtimeDirectory(), "runs");
 }
 function recordPath() {
-  return join20(runsDirectory(), "run.json");
+  return join21(runsDirectory(), "run.json");
 }
 function recordPaths() {
-  return runtimeDirectories().map((directory) => join20(directory, "runs", "run.json"));
+  return runtimeDirectories().map((directory) => join21(directory, "runs", "run.json"));
 }
 function openTranscript(startedAt) {
-  mkdirSync11(runsDirectory(), { recursive: true });
-  const path = join20(runsDirectory(), `run-${startedAt}.log`);
-  return { path, fd: openSync(path, "a") };
+  mkdirSync12(runsDirectory(), { recursive: true });
+  const path = join21(runsDirectory(), `run-${startedAt}.log`);
+  return { path, fd: openSync2(path, "a") };
 }
 function writeRunRecord(record) {
-  mkdirSync11(runsDirectory(), { recursive: true });
-  writeFileSync13(recordPath(), JSON.stringify(record, null, 2), "utf8");
+  mkdirSync12(runsDirectory(), { recursive: true });
+  writeFileSync14(recordPath(), JSON.stringify(record, null, 2), "utf8");
 }
 function editorNotePath() {
-  return join20(runsDirectory(), "editor-run.json");
+  return join21(runsDirectory(), "editor-run.json");
 }
 function writeEditorRunNote(note) {
-  mkdirSync11(runsDirectory(), { recursive: true });
-  writeFileSync13(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
+  mkdirSync12(runsDirectory(), { recursive: true });
+  writeFileSync14(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
 }
 function readEditorRunNote() {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(join20(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(join21(directory, "runs", "editor-run.json"));
     if (note !== null) {
       return note;
     }
@@ -37399,7 +37770,7 @@ function readEditorRunNote() {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync18(path, "utf8"));
+    parsed = JSON.parse(readFileSync19(path, "utf8"));
   } catch {
     return null;
   }
@@ -37422,7 +37793,7 @@ function recordRunEnded(pid, exitCode) {
     return;
   }
   try {
-    writeFileSync13(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
+    writeFileSync14(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
   } catch {}
 }
 function readRunRecord() {
@@ -37437,7 +37808,7 @@ function readRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync18(path, "utf8"));
+    parsed = JSON.parse(readFileSync19(path, "utf8"));
   } catch {
     return null;
   }
@@ -37482,7 +37853,7 @@ function runningAs(pid) {
     const began = startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync18(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync19(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = execFileSync2("ps", ["-p", String(pid), "-o", "args="], {
@@ -37609,13 +37980,13 @@ function clearRunRecord(ours = () => true) {
       continue;
     }
     try {
-      rmSync9(path);
+      rmSync10(path);
     } catch {}
   }
 }
 function ageMs(path, now) {
   try {
-    return now - statSync4(path).mtimeMs;
+    return now - statSync7(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -37625,7 +37996,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;
   }
@@ -37633,12 +38004,12 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join20(directory, entry);
+    const path = join21(directory, entry);
     if (path === keep || ageMs(path, now) < keepMs) {
       continue;
     }
     try {
-      rmSync9(path);
+      rmSync10(path);
     } catch {}
   }
 }
@@ -37654,22 +38025,22 @@ import { execFile as execFile7, spawn } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   appendFileSync,
-  closeSync,
-  existsSync as existsSync14,
+  closeSync as closeSync2,
+  existsSync as existsSync15,
   fstatSync,
-  mkdirSync as mkdirSync12,
+  mkdirSync as mkdirSync13,
   mkdtempSync as mkdtempSync3,
-  openSync as openSync2,
-  readdirSync as readdirSync7,
-  readFileSync as readFileSync19,
-  readSync,
+  openSync as openSync3,
+  readdirSync as readdirSync9,
+  readFileSync as readFileSync20,
+  readSync as readSync2,
   rmdirSync,
-  statSync as statSync5
+  statSync as statSync8
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename4, dirname as dirname14, isAbsolute as isAbsolute3, join as join21, normalize as normalize3, relative as relative3 } from "node:path";
+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);
@@ -37909,13 +38280,13 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync14(join21(projectPath, wanted))) {
+  if (wanted === "" || existsSync15(join22(projectPath, wanted))) {
     return "";
   }
   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 "";
   }
@@ -37923,7 +38294,7 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync19(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync20(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function runtimeAddonAnnouncesEditors(projectPath) {
@@ -37931,13 +38302,13 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync19(join21(projectPath, RUNTIME_AUTOLOAD2.path), "utf8").includes('"editor_pid"');
+    return readFileSync20(join22(projectPath, RUNTIME_AUTOLOAD2.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync19(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync20(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -37956,7 +38327,7 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   mcp;
   locator = new GodotLocator2;
-  operationsScript = join21(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join22(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -38621,8 +38992,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join21(path, "project.godot");
-    if (!existsSync14(file)) {
+    const file = join22(path, "project.godot");
+    if (!existsSync15(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -38890,7 +39261,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync19(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync20(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -38951,18 +39322,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname14(output.absolutePath);
+    const folder = dirname15(output.absolutePath);
     try {
-      mkdirSync12(folder, { recursive: true });
+      mkdirSync13(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname14(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname15(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
-    const exportLogs = mkdtempSync3(join21(tmpdir5(), "gdharness-export-"));
+    const exportLogs = mkdtempSync3(join22(tmpdir5(), "gdharness-export-"));
     const exportArgs = [
       "--headless",
       "--log-file",
-      join21(exportLogs, "engine.log"),
+      join22(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -38990,7 +39361,7 @@ class GodotServer {
     log.finish();
     const problems = log.select({ severity: "warning", sinceLastCall: false, limit: 200 });
     const verdict = {
-      exported: exitCode === 0 && log.count("error") === 0 && existsSync14(output.absolutePath),
+      exported: exitCode === 0 && log.count("error") === 0 && existsSync15(output.absolutePath),
       preset,
       outputPath: output.relativePath,
       debug,
@@ -39020,7 +39391,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync14(join21(project.value.path, runner))) {
+    if (!existsSync15(join22(project.value.path, runner))) {
       return this.createErrorResponse(`gdUnit4 is not installed in this project: no ${runner}.`, [
         "Install gdUnit4 under addons/gdUnit4, from https://github.com/godot-gdunit-labs/gdUnit4"
       ]);
@@ -39055,7 +39426,7 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync3(join21(tmpdir5(), "gdharness-tests-"));
+    const userData = mkdtempSync3(join22(tmpdir5(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const hung = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -39071,21 +39442,21 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join21(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join22(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync14(reportsDir) ? readdirSync7(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const 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(readFileSync19(join21(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync20(join22(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
     } finally {
       discard(reportsDir, userData);
       try {
-        rmdirSync(dirname14(reportsDir));
+        rmdirSync(dirname15(reportsDir));
       } catch {}
     }
     const engineEntries = run.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries.map(aboveTheRunner);
@@ -39204,7 +39575,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");
@@ -39217,11 +39588,11 @@ class GodotServer {
     const cached = cachedClasses(projectPath);
     const contradicted = cached === null ? [] : contradictedDiagnostics(messages, cached, (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
-      if (!contained.ok || !existsSync14(contained.absolutePath)) {
+      if (!contained.ok || !existsSync15(contained.absolutePath)) {
         return null;
       }
       try {
-        return readFileSync19(contained.absolutePath, "utf8");
+        return readFileSync20(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -39271,11 +39642,11 @@ class GodotServer {
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
-    if (!contained.ok || !existsSync14(contained.absolutePath)) {
+    if (!contained.ok || !existsSync15(contained.absolutePath)) {
       return null;
     }
     try {
-      return readFileSync19(contained.absolutePath, "utf8");
+      return readFileSync20(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -39391,7 +39762,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,
@@ -39408,7 +39779,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,
@@ -39504,7 +39875,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync19(join21(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync20(join22(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -39540,8 +39911,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
     });
@@ -39634,7 +40005,8 @@ class GodotServer {
     });
   }
   async openAnEditor(engine, projectPath, ports) {
-    const editor = spawn(engine, editorArguments(projectPath, ports), {
+    clearEditorLog(projectPath);
+    const editor = spawn(engine, editorArguments(projectPath, ports, editorLogPath(projectPath)), {
       stdio: "ignore",
       detached: true,
       env: {
@@ -39645,6 +40017,9 @@ class GodotServer {
         [OPENED_BY_A_SERVER]: "1"
       }
     });
+    if (editor.pid !== undefined) {
+      writeEditorLogNote(projectPath, editor.pid);
+    }
     const started = await new Promise((resolve) => {
       editor.once("spawn", () => {
         resolve(null);
@@ -39751,7 +40126,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync14(join21(projectPath, RUNTIME_AUTOLOAD2.path))) {
+    if (!existsSync15(join22(projectPath, RUNTIME_AUTOLOAD2.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
     }
     let asking = null;
@@ -39814,7 +40189,7 @@ class GodotServer {
     }
     let announcedAt;
     try {
-      announcedAt = statSync5(endpoint.file).mtimeMs;
+      announcedAt = statSync8(endpoint.file).mtimeMs;
     } catch {
       return;
     }
@@ -39850,7 +40225,7 @@ class GodotServer {
     }
     const startedAt = Date.now();
     const transcript = openTranscript(startedAt);
-    closeSync(transcript.fd);
+    closeSync2(transcript.fd);
     const playAnswer = asParams(JSON.parse(answer.content[0]?.text ?? "{}"));
     const played = {
       process: null,
@@ -39917,7 +40292,7 @@ class GodotServer {
     }
     let handle;
     try {
-      handle = openSync2(game.errorReport, "r");
+      handle = openSync3(game.errorReport, "r");
     } catch {
       return;
     }
@@ -39928,7 +40303,7 @@ class GodotServer {
         return;
       }
       const buffer = Buffer.alloc(size - from);
-      const read = readSync(handle, buffer, 0, buffer.length, from);
+      const read = readSync2(handle, buffer, 0, buffer.length, from);
       game.errorReportOffset = from + read;
       const reported = buffer.subarray(0, read);
       if (game.transcript !== null) {
@@ -39937,7 +40312,7 @@ class GodotServer {
         game.log.append("stderr", reported);
       }
     } finally {
-      closeSync(handle);
+      closeSync2(handle);
     }
   }
   recordWhatItBrokeOn(game) {
@@ -40031,7 +40406,7 @@ class GodotServer {
         ...env ? { env } : {}
       });
     } finally {
-      closeSync(transcript.fd);
+      closeSync2(transcript.fd);
     }
     child.unref();
     const log = new GameLog;
@@ -40078,7 +40453,7 @@ class GodotServer {
     }
     let handle;
     try {
-      handle = openSync2(game.transcript, "r");
+      handle = openSync3(game.transcript, "r");
     } catch {
       return;
     }
@@ -40088,11 +40463,11 @@ class GodotServer {
         return;
       }
       const buffer = Buffer.alloc(size - game.readOffset);
-      const read = readSync(handle, buffer, 0, buffer.length, game.readOffset);
+      const read = readSync2(handle, buffer, 0, buffer.length, game.readOffset);
       game.readOffset += read;
       game.log.append("transcript", buffer.subarray(0, read));
     } finally {
-      closeSync(handle);
+      closeSync2(handle);
     }
   }
   async pickUpWhatTheEditorIsPlaying() {
@@ -40290,7 +40665,7 @@ class GodotServer {
     }
     const unreadable = this.aRuntimeOfOursIsTooFarOff();
     if (unreadable !== null) {
-      const behind = unreadable.protocol > RUNTIME_PROTOCOL ? "this server is the older half: reconnect it so it spawns the installed version" : "the addon is the older half: reinstall it and restart the game";
+      const behind = whichHalfIsBehind([unreadable]);
       return `A game is running for ${unreadable.project.path}, pid ${unreadable.pid}, announced in protocol` + ` ${unreadable.protocol}, which this server does not speak: it speaks ${RUNTIME_PROTOCOL}, so ${behind}.` + " Until then neither editor_run nor the runtime_* tools can reach it." + " A run started here is a separate process rather than a replacement, so starting one leaves" + " this game running as well.";
     }
     const record = readRunRecord();
@@ -40415,7 +40790,66 @@ class GodotServer {
     }
     return runIsUp(run, said);
   }
+  handleEditorConsole(args) {
+    const status = this.godotBridge.getStatus();
+    const projectPath = status.projectPath ?? this.ownProject ?? undefined;
+    if (projectPath === undefined) {
+      return this.createErrorResponse("No editor is connected, so there is no console to read.", [
+        "editor_status says whether one is connected and whether it may yet be",
+        "editor_launch opens one, and an editor opened here has its console captured"
+      ]);
+    }
+    const 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",
+        "editor_output with no op answers about the game a run is playing, which is a different log"
+      ]);
+    }
+    const severity = readString(args, "severity");
+    const selected = console2.log.select({
+      severity: severity === "error" || severity === "warning" ? severity : "info",
+      sinceLastCall: false,
+      contains: readNonEmptyString(args, "contains"),
+      limit: readPositiveNumber(args, "limit") ?? 200
+    });
+    const everything = console2.log.everything();
+    const grouped = bursts(everything, readPositiveNumber(args, "before") ?? 3);
+    const shown = grouped.slice(0, MOST_GROUPS);
+    return this.jsonTextResponse({
+      editorPid: editorPid ?? undefined,
+      projectPath,
+      ...status.connected ? {} : this.launchedEditorIsUp() ? { stillConnecting: true } : { exitedBeforeConnecting: true },
+      capturedIn: console2.path,
+      ...console2.of === undefined ? {} : {
+        readFromTheStart: console2.readBytes,
+        consoleBytes: console2.of,
+        truncatedNote: `This editor's console is ${console2.of} bytes and the first ${console2.readBytes} of them were read, which is the start of the session rather than the end of it. Restart the editor to begin a fresh console.`
+      },
+      lines: everything.length,
+      counts: {
+        error: console2.log.count("error"),
+        warning: console2.log.count("warning"),
+        info: console2.log.count("info")
+      },
+      repeated: shown,
+      moreShapes: grouped.length > shown.length ? grouped.length - shown.length : undefined,
+      entries: forAnswer(selected.entries),
+      omitted: selected.omitted === 0 ? undefined : selected.omitted
+    });
+  }
   async handleGetDebugOutput(args, waitedMs) {
+    if (readString(args, "op") === "editor") {
+      return this.handleEditorConsole(args);
+    }
     await this.pickUpWhatTheEditorIsPlaying();
     const run = this.currentRun();
     if (!run) {
@@ -40692,6 +41126,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) {
@@ -40702,21 +41137,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(" ")
       }
     };
   }
@@ -40792,7 +41236,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)}`);
     }
@@ -40866,8 +41310,8 @@ class GodotServer {
       ]);
     }
     const expectsScreenshot = command === "capture_screenshot" || command === "capture_viewport";
-    const screenshotDir = expectsScreenshot ? mkdtempSync3(join21(tmpdir5(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join21(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? mkdtempSync3(join22(tmpdir5(), "gdharness-runtime-screenshot-")) : null;
+    const screenshotPath = screenshotDir ? join22(screenshotDir, "capture.png") : null;
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs);
       if (!reply.ok) {
@@ -40891,7 +41335,7 @@ class GodotServer {
             type: "text",
             text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}`
           },
-          { type: "image", data: readFileSync19(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync20(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
@@ -40958,7 +41402,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run7, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CACHE_WRITE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, 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, run7, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CACHE_WRITE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, 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();
@@ -40970,6 +41414,7 @@ var init_server3 = __esm(() => {
   init_class_note();
   init_config_pin();
   init_dap_client();
+  init_editor_log();
   init_errors();
   init_game_log();
   init_godot_bridge();
@@ -40994,7 +41439,7 @@ var init_server3 = __esm(() => {
   init_tool_definitions();
   init_update_check();
   run7 = promisify7(execFile7);
-  __dirname2 = dirname14(fileURLToPath4(import.meta.url));
+  __dirname2 = dirname15(fileURLToPath5(import.meta.url));
   CONSOLE_WRAPPER = /_console(\.exe)?$/i;
   LONGEST_BOOT_NOTED_MS = 5 * 60000;
   VALUE_NAMES = {
@@ -41034,8 +41479,8 @@ var init_server3 = __esm(() => {
 });
 
 // src/cli.ts
-import { existsSync as existsSync15 } from "fs";
-import { join as join22, resolve as resolve5 } from "path";
+import { existsSync as existsSync16 } from "fs";
+import { join as join23, resolve as resolve5 } from "path";
 
 // src/errors.ts
 class Refusal extends Error {
@@ -42213,7 +42658,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"];
@@ -42223,6 +42678,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");
 }
@@ -42245,6 +42734,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) {
@@ -42389,7 +42880,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
@@ -42511,7 +43002,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.
@@ -42532,6 +43024,14 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
   runtime addon announces nothing, so there is no process id and \`running\` is the editor's answer,
   which can lag by seconds after the game has gone. \`editor_status\` names the game under
   \`runtimes\`, which does not depend on the editor answering.
+- When the tools all say the project is fine and something is still wrong, read the editor's own
+  console with \`editor_output op: "editor"\`. It is a different log from the one above and the only
+  way anything here sees what the editor printed: its console reaches no plugin, so an editor
+  gdharness opened is asked for a log file as it starts, and one somebody opened by hand is refused
+  rather than answered empty. It carries the whole session from the editor's first line, which is
+  where a wall of startup errors will be, with repeated messages grouped under \`repeated\` and the
+  ordinary lines above each group beside them: a plugin announcing itself on the line before a
+  burst of parse errors is usually the whole diagnosis.
 - One server, one editor. A second project is a second harness session with its own server, and
   that works: each editor is opened on its own language server and debug adapter ports, and says
   where it serves. Two editors on one project is the thing to refuse.
@@ -42690,7 +43190,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 });
@@ -42714,9 +43214,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")
@@ -42741,7 +43241,7 @@ class UsageError extends Refusal {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve5(named ?? ".");
-  if (!existsSync15(join22(projectPath, "project.godot"))) {
+  if (!existsSync16(join23(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -42780,7 +43280,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync15(join22(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync16(join23(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
     console.log(`  that file is not in this project, so it boots with a missing script: restore it, or point the entry at res://${RUNTIME_AUTOLOAD.path}`);
   }
 }
@@ -42912,7 +43412,7 @@ async function setup() {
       console.log("no harness configured; name one yourself, and gdharness harnesses lists them all");
     }
     if (!args.includes("--no-skill")) {
-      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync15);
+      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync16);
       for (const written of writeSkill(directories, getLocalVersion())) {
         console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
       }
@@ -42978,6 +43478,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}`);
   }
@@ -43005,12 +43506,14 @@ async function upgrade() {
       moved.push(took.from);
     }
   }
-  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync15), version)) {
+  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync16), version)) {
     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(" ")));
 }