gdharness 1.0.11 → 1.0.12

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];
@@ -15349,7 +15362,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 +16083,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 +16091,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 +16107,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: []
     },
     {
@@ -31693,10 +31724,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 +31771,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 +31812,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 +32870,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 statSync4,
+  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 = statSync4(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"];
@@ -36182,7 +36479,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 +36534,7 @@ class GodotLocator2 {
       return known;
     }
     let reason;
-    if (path !== "godot" && !existsSync12(path)) {
+    if (path !== "godot" && !existsSync13(path)) {
       reason = "does not exist";
     } else {
       try {
@@ -36613,7 +36910,7 @@ 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 { dirname as dirname13, resolve as resolve4 } from "node:path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function diagnosticsKey(uri) {
   let decoded;
@@ -36741,7 +37038,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 +37483,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 readdirSync5, 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 };
@@ -37205,7 +37502,7 @@ function projectStructure(projectPath) {
         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") {
@@ -37235,14 +37532,14 @@ function scriptsWithoutUid(projectPath) {
       }
       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);
       }
     }
@@ -37277,7 +37574,7 @@ function searchProject(projectPath, options) {
       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 +37585,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 +37614,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 +37631,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 +37646,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 +37657,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 readdirSync6, readFileSync as readFileSync19, rmSync as rmSync10, statSync as statSync5, 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 +37696,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 +37719,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 +37734,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 +37779,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 +37906,13 @@ function clearRunRecord(ours = () => true) {
       continue;
     }
     try {
-      rmSync9(path);
+      rmSync10(path);
     } catch {}
   }
 }
 function ageMs(path, now) {
   try {
-    return now - statSync4(path).mtimeMs;
+    return now - statSync5(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -37633,12 +37930,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,20 +37951,20 @@ 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,
+  openSync as openSync3,
   readdirSync as readdirSync7,
-  readFileSync as readFileSync19,
-  readSync,
+  readFileSync as readFileSync20,
+  readSync as readSync2,
   rmdirSync,
-  statSync as statSync5
+  statSync as statSync6
 } 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 { promisify as promisify7 } from "node:util";
@@ -37909,7 +38206,7 @@ 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();
@@ -37923,7 +38220,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 +38228,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 +38253,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 +38918,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 +39187,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 +39248,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 +39287,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 +39317,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 +39352,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 +39368,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) ? readdirSync7(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
       const newest = written.at(-1);
       if (newest !== undefined) {
-        report = parseJUnit(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);
@@ -39217,11 +39514,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 +39568,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;
     }
@@ -39504,7 +39801,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;
     }
@@ -39634,7 +39931,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 +39943,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 +40052,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 +40115,7 @@ class GodotServer {
     }
     let announcedAt;
     try {
-      announcedAt = statSync5(endpoint.file).mtimeMs;
+      announcedAt = statSync6(endpoint.file).mtimeMs;
     } catch {
       return;
     }
@@ -39850,7 +40151,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 +40218,7 @@ class GodotServer {
     }
     let handle;
     try {
-      handle = openSync2(game.errorReport, "r");
+      handle = openSync3(game.errorReport, "r");
     } catch {
       return;
     }
@@ -39928,7 +40229,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 +40238,7 @@ class GodotServer {
         game.log.append("stderr", reported);
       }
     } finally {
-      closeSync(handle);
+      closeSync2(handle);
     }
   }
   recordWhatItBrokeOn(game) {
@@ -40031,7 +40332,7 @@ class GodotServer {
         ...env ? { env } : {}
       });
     } finally {
-      closeSync(transcript.fd);
+      closeSync2(transcript.fd);
     }
     child.unref();
     const log = new GameLog;
@@ -40078,7 +40379,7 @@ class GodotServer {
     }
     let handle;
     try {
-      handle = openSync2(game.transcript, "r");
+      handle = openSync3(game.transcript, "r");
     } catch {
       return;
     }
@@ -40088,11 +40389,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 +40591,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 +40716,57 @@ 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 console2 = editorConsole(projectPath, status.editorPid ?? null, status.openedByAServer === 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: status.editorPid,
+      projectPath,
+      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) {
@@ -40866,8 +41217,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 +41242,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 +41309,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 +41321,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 +41346,7 @@ var init_server3 = __esm(() => {
   init_tool_definitions();
   init_update_check();
   run7 = promisify7(execFile7);
-  __dirname2 = dirname14(fileURLToPath4(import.meta.url));
+  __dirname2 = dirname15(fileURLToPath4(import.meta.url));
   CONSOLE_WRAPPER = /_console(\.exe)?$/i;
   LONGEST_BOOT_NOTED_MS = 5 * 60000;
   VALUE_NAMES = {
@@ -41034,8 +41386,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 {
@@ -42532,6 +42884,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.
@@ -42741,7 +43101,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 +43140,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 +43272,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}`);
       }
@@ -43005,7 +43365,7 @@ 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(`