gdharness 0.10.1 → 0.11.0

package/build/cli.js

@@ -155,6 +155,9 @@ function runArguments(options) {
   if (options.scene !== null) {
     args.push(`res://${options.scene}`);
   }
+  if (options.userArgs !== undefined && options.userArgs.length > 0) {
+    args.push("--", ...options.userArgs);
+  }
   return args;
 }
 function editorArguments(projectPath, ports) {
@@ -7187,8 +7190,12 @@ function announced(line) {
 
 class GameLog {
   entries = [];
-  decoders = { stdout: new StringDecoder("utf8"), stderr: new StringDecoder("utf8") };
-  partial = { stdout: "", stderr: "" };
+  decoders = {
+    stdout: new StringDecoder("utf8"),
+    stderr: new StringDecoder("utf8"),
+    transcript: new StringDecoder("utf8")
+  };
+  partial = { stdout: "", stderr: "", transcript: "" };
   lastHeadline = null;
   cursor = 0;
   append(source, chunk) {
@@ -7201,7 +7208,7 @@ class GameLog {
     }
   }
   finish() {
-    for (const source of ["stdout", "stderr"]) {
+    for (const source of STREAMS) {
       const tail = this.partial[source] + this.decoders[source].end();
       this.partial[source] = "";
       if (tail !== "") {
@@ -7264,10 +7271,11 @@ class GameLog {
     return { entries: matching.slice(omitted), omitted };
   }
 }
-var HEADLINE, COLOUR_CODE;
+var HEADLINE, COLOUR_CODE, STREAMS;
 var init_game_log = __esm(() => {
   HEADLINE = /^(USER )?(SCRIPT ERROR|ERROR|WARNING):\s?(.*)$/;
   COLOUR_CODE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+  STREAMS = ["stdout", "stderr", "transcript"];
 });
 
 // src/update-check.ts
@@ -15405,7 +15413,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "project_test",
-      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. Needs gdUnit4 under addons/gdUnit4.",
+      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. Needs gdUnit4 under addons/gdUnit4.",
       parameters: {
         projectPath: PROJECT_PATH,
         path: {
@@ -15680,10 +15688,15 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_run",
-      description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice.",
+      description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. args hands the game its own flags, the ones it reads with OS.get_cmdline_user_args(), and a run carrying any is started by this server rather than by the editor. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice.",
       parameters: {
         projectPath: PROJECT_PATH,
         scene: { type: "string", description: "A scene to run instead of the main scene." },
+        args: {
+          type: "array",
+          items: { type: "string" },
+          description: `The game's own arguments, what OS.get_cmdline_user_args() answers, such as ["--level=2"]. The separator is added here. A run with any is started by this server rather than by the editor, which fixes the game's command line when it opens the project, so the debug_* tools do not answer for it.`
+        },
         headless: { type: "boolean", description: "start: force a window or no window." },
         frames: { type: "number", description: "check: frames to run before quitting. Default 3." },
         timeoutMs: {
@@ -15812,8 +15825,8 @@ var init_tool_definitions = __esm(() => {
         },
         includeHidden: {
           type: "boolean",
-          ops: ["text"],
-          description: "text: read hidden nodes as well, for checking that something is not showing. Default false."
+          ops: ["text", "find"],
+          description: "text: read hidden nodes as well, for checking that something is not showing. Default false. find: default true, since a find means the node whether or not it is drawn; false answers with what the player can actually see, which is how a panel that keeps a label for every line and hides the ones that do not is read. A node counts as hidden when anything above it is, and how many matches were left out comes back under hidden."
         },
         metrics: {
           type: "array",
@@ -15830,7 +15843,7 @@ var init_tool_definitions = __esm(() => {
           requires: []
         },
         find: {
-          summary: "the paths of every node matching className, script, namePattern, group or says, with property read off each",
+          summary: "the paths of every node matching className, script, namePattern, group or says, with property read off each, hidden ones included unless includeHidden says otherwise",
           requires: []
         },
         rect: {
@@ -35160,7 +35173,37 @@ function whyNoReport(printed, asked) {
   }
   return printed.some((line) => NOTHING_RAN.test(line)) ? `no test cases found at ${asked}` : null;
 }
-var MalformedReportError, ENTITIES, ATTRIBUTE, NOTHING_RAN, NO_SUCH_PATH;
+function orphansPrinted(printed) {
+  const suites = [];
+  let total = null;
+  let running = null;
+  for (const line of printed) {
+    const started = RUNNING_SUITE.exec(line);
+    if (started?.[1] !== undefined) {
+      running = started[1];
+      continue;
+    }
+    const counted = ORPHANS.exec(line);
+    if (counted?.[1] === undefined) {
+      continue;
+    }
+    const orphans = Number(counted[1]);
+    if (line.includes(OVERALL)) {
+      total = orphans;
+      running = null;
+      continue;
+    }
+    if (running !== null && orphans > 0) {
+      suites.push({ path: running, orphans });
+    }
+    running = null;
+  }
+  return {
+    total: total ?? suites.reduce((sum, suite) => sum + suite.orphans, 0),
+    suites
+  };
+}
+var MalformedReportError, ENTITIES, ATTRIBUTE, NOTHING_RAN, NO_SUCH_PATH, RUNNING_SUITE, ORPHANS, OVERALL = "Overall Summary";
 var init_junit = __esm(() => {
   MalformedReportError = class MalformedReportError extends Error {
     constructor(message) {
@@ -35172,6 +35215,8 @@ var init_junit = __esm(() => {
   ATTRIBUTE = /\s*([^\s=/>]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/y;
   NOTHING_RAN = /no test cases found/i;
   NO_SUCH_PATH = /given directory or file does not exists:\s*(\S+)/i;
+  RUNNING_SUITE = /Run Test Suite:\s*(\S+)/;
+  ORPHANS = /(\d+)\s+orphans/;
 });
 
 // src/lsp_client.ts
@@ -35475,6 +35520,14 @@ class GodotLSPClient {
     }
     return uri;
   }
+  closeDocument(uri) {
+    if (!this.documentVersions.delete(uri)) {
+      return;
+    }
+    try {
+      this.sendNotification("textDocument/didClose", { textDocument: { uri } });
+    } catch {}
+  }
   async initialize(rootPath) {
     await this.ensureConnected();
     const resolvedRootPath = resolve3(rootPath);
@@ -35528,8 +35581,9 @@ class GodotLSPClient {
         timer
       });
     });
+    let opened = null;
     try {
-      this.syncDocument(filePath, content);
+      opened = this.syncDocument(filePath, content);
       return await diagnosticsPromise;
     } catch (error) {
       const waiter = this.diagnosticsWaiters.get(key);
@@ -35538,16 +35592,25 @@ class GodotLSPClient {
         this.diagnosticsWaiters.delete(key);
       }
       throw error;
+    } finally {
+      if (opened !== null) {
+        this.closeDocument(opened);
+      }
     }
   }
   async getCompletions(filePath, content, line, character) {
     await this.ensureConnected();
     await this.ensureInitializedForFile(filePath);
     const uri = this.syncDocument(filePath, content);
-    const result = await this.sendRequest("textDocument/completion", {
-      textDocument: { uri },
-      position: { line, character }
-    });
+    let result;
+    try {
+      result = await this.sendRequest("textDocument/completion", {
+        textDocument: { uri },
+        position: { line, character }
+      });
+    } finally {
+      this.closeDocument(uri);
+    }
     if (Array.isArray(result)) {
       return result;
     }
@@ -35563,18 +35626,27 @@ class GodotLSPClient {
     await this.ensureConnected();
     await this.ensureInitializedForFile(filePath);
     const uri = this.syncDocument(filePath, content);
-    return this.sendRequest("textDocument/hover", {
-      textDocument: { uri },
-      position: { line, character }
-    });
+    try {
+      return await this.sendRequest("textDocument/hover", {
+        textDocument: { uri },
+        position: { line, character }
+      });
+    } finally {
+      this.closeDocument(uri);
+    }
   }
   async getDocumentSymbols(filePath, content) {
     await this.ensureConnected();
     await this.ensureInitializedForFile(filePath);
     const uri = this.syncDocument(filePath, content);
-    const result = await this.sendRequest("textDocument/documentSymbol", {
-      textDocument: { uri }
-    });
+    let result;
+    try {
+      result = await this.sendRequest("textDocument/documentSymbol", {
+        textDocument: { uri }
+      });
+    } finally {
+      this.closeDocument(uri);
+    }
     return Array.isArray(result) ? result : [];
   }
   isConnected() {
@@ -36016,15 +36088,97 @@ var init_runtime_client = __esm(() => {
   ANNOUNCEMENT_PATTERN = /^runtime-(\d+)\.json$/;
 });
 
+// src/run-record.ts
+import { mkdirSync as mkdirSync6, openSync, readdirSync as readdirSync6, readFileSync as readFileSync12, rmSync as rmSync7, statSync as statSync2, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join14 } from "node:path";
+function runsDirectory() {
+  return join14(runtimeDirectory(), "runs");
+}
+function recordPath() {
+  return join14(runsDirectory(), "run.json");
+}
+function openTranscript(startedAt) {
+  mkdirSync6(runsDirectory(), { recursive: true });
+  const path = join14(runsDirectory(), `run-${startedAt}.log`);
+  return { path, fd: openSync(path, "a") };
+}
+function writeRunRecord(record) {
+  mkdirSync6(runsDirectory(), { recursive: true });
+  writeFileSync8(recordPath(), JSON.stringify(record, null, 2), "utf8");
+}
+function readRunRecord() {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync12(recordPath(), "utf8"));
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return null;
+  }
+  const fields = parsed;
+  const pid = fields["pid"];
+  const transcript = fields["transcript"];
+  const startedAt = fields["startedAt"];
+  if (typeof pid !== "number" || typeof transcript !== "string" || typeof startedAt !== "number") {
+    return null;
+  }
+  const args = fields["arguments"];
+  return {
+    pid,
+    transcript,
+    startedAt,
+    projectPath: typeof fields["projectPath"] === "string" ? fields["projectPath"] : "",
+    arguments: Array.isArray(args) ? args.filter((value) => typeof value === "string") : []
+  };
+}
+function clearRunRecord() {
+  try {
+    rmSync7(recordPath());
+  } catch {}
+}
+function ageMs(path, now) {
+  try {
+    return now - statSync2(path).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
+  const directory = runsDirectory();
+  const keep = readRunRecord()?.transcript;
+  let entries;
+  try {
+    entries = readdirSync6(directory);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
+      continue;
+    }
+    const path = join14(directory, entry);
+    if (path === keep || ageMs(path, now) < keepMs) {
+      continue;
+    }
+    try {
+      rmSync7(path);
+    } catch {}
+  }
+}
+var init_run_record = __esm(() => {
+  init_runtime_client();
+});
+
 // src/setup.ts
-import { cpSync as cpSync2, existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync12, rmSync as rmSync7, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname8, join as join14 } from "node:path";
+import { cpSync as cpSync2, existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync13, rmSync as rmSync8, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname8, join as join15 } from "node:path";
 function installedAddonVersion(projectPath) {
-  const marker = join14(projectPath, "addons", ADDONS2[0], VERSION_MARKER2);
+  const marker = join15(projectPath, "addons", ADDONS2[0], VERSION_MARKER2);
   if (!existsSync11(marker)) {
     return null;
   }
-  const said = readFileSync12(marker, "utf8").trim();
+  const said = readFileSync13(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 var ADDONS2, RUNTIME_AUTOLOAD2, VERSION_MARKER2 = ".gdharness-version";
@@ -36042,24 +36196,45 @@ var init_setup = __esm(() => {
 
 // src/server.ts
 import { execFile as execFile5, spawn } from "node:child_process";
-import { existsSync as existsSync12, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync3, readdirSync as readdirSync6, readFileSync as readFileSync13, realpathSync as realpathSync2, rmSync as rmSync8 } from "node:fs";
+import {
+  closeSync,
+  existsSync as existsSync12,
+  fstatSync,
+  mkdirSync as mkdirSync8,
+  mkdtempSync as mkdtempSync3,
+  openSync as openSync2,
+  readdirSync as readdirSync7,
+  readFileSync as readFileSync14,
+  readSync,
+  realpathSync as realpathSync2,
+  rmSync as rmSync9
+} from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename2, dirname as dirname9, join as join15, normalize as normalize3 } from "node:path";
+import { basename as basename2, dirname as dirname9, join as join16, normalize as normalize3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { promisify as promisify5 } from "node:util";
 function patienceForFrames(frames, atLeast) {
   return Math.max(atLeast, frames / SLOWEST_FRAME_RATE * 1000 + atLeast);
 }
+function stillRunning(run) {
+  if (run?.exitCode !== null || run.endedUnwatched === true) {
+    return false;
+  }
+  if (!run.throughEditor && run.process === null && run.pid !== null) {
+    return alive(run.pid);
+  }
+  return true;
+}
 function alive(pid) {
-  if (pid === undefined) {
+  if (pid === undefined || pid === null) {
     return false;
   }
   try {
     process.kill(pid, 0);
     return true;
-  } catch {
-    return false;
+  } catch (error) {
+    return error.code === "EPERM";
   }
 }
 function isOfType(value, kind) {
@@ -36139,13 +36314,13 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync12(join15(projectPath, wanted))) {
+  if (wanted === "" || existsSync12(join16(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
   let near = [];
   try {
-    near = readdirSync6(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 = 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()));
   } catch {
     return "";
   }
@@ -36153,11 +36328,11 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync13(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync14(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync13(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync14(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -36173,7 +36348,7 @@ function camelCased(params) {
 class GodotServer {
   mcp;
   locator = new GodotLocator2;
-  operationsScript = join15(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join16(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -36330,10 +36505,7 @@ class GodotServer {
     this.stopWatchingForASuccessor();
     withdrawBridge(this.announcedAt);
     this.announcedAt = null;
-    if (this.activeProcess) {
-      this.activeProcess.process?.kill();
-      this.activeProcess = null;
-    }
+    this.activeProcess = null;
     if (this.lspClient) {
       try {
         await this.lspClient.disconnect();
@@ -36398,14 +36570,7 @@ class GodotServer {
       return;
     }
     this.shutdownInitiated = true;
-    if (this.activeProcess) {
-      try {
-        this.activeProcess.process?.kill();
-      } catch (error) {
-        console.error("[SERVER] Failed to kill the Godot process on exit:", errorMessage(error));
-      }
-      this.activeProcess = null;
-    }
+    this.activeProcess = null;
   }
   setupToolHandlers() {
     this.mcp.server.setRequestHandler(ListToolsRequestSchema, () => ({ tools: this.tools }));
@@ -36765,7 +36930,7 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join15(path, "project.godot");
+    const file = join16(path, "project.godot");
     if (!existsSync12(file)) {
       return {
         ok: false,
@@ -36776,6 +36941,21 @@ class GodotServer {
     }
     return { ok: true, value: { path, file } };
   }
+  gameArguments(args) {
+    if (args["args"] === undefined) {
+      return { ok: true, value: [] };
+    }
+    const given = readStringArray(args, "args");
+    if (given === undefined) {
+      return {
+        ok: false,
+        response: this.createErrorResponse("args must be a list of strings.", [
+          `Pass the game's own flags, such as ["--level=2"]`
+        ])
+      };
+    }
+    return { ok: true, value: given };
+  }
   async debuggedGame() {
     const game = this.activeProcess;
     if (game !== null && game.exitCode !== null) {
@@ -36920,7 +37100,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync13(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync14(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -36983,7 +37163,7 @@ class GodotServer {
     }
     const folder = dirname9(output.absolutePath);
     try {
-      mkdirSync7(folder, { recursive: true });
+      mkdirSync8(folder, { recursive: true });
     } catch (error) {
       return this.createErrorResponse(`Cannot create ${dirname9(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
@@ -37045,7 +37225,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync12(join15(project.value.path, runner))) {
+    if (!existsSync12(join16(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"
       ]);
@@ -37079,7 +37259,7 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync3(join15(tmpdir5(), "gdharness-tests-"));
+    const userData = mkdtempSync3(join16(tmpdir5(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const hung = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -37095,26 +37275,26 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join15(project.value.path, ".godot", "gdharness-reports");
+    const reportsDir = join16(project.value.path, ".godot", "gdharness-reports");
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync12(reportsDir) ? readdirSync6(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync12(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(readFileSync13(join15(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync14(join16(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
     } finally {
-      rmSync8(reportsDir, { recursive: true, force: true });
-      rmSync8(userData, { recursive: true, force: true });
+      rmSync9(reportsDir, { recursive: true, force: true });
+      rmSync9(userData, { recursive: true, force: true });
     }
     const engineEntries = run.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries.map(aboveTheRunner);
     const verdicts = {
       0: "passed",
       100: "failures",
-      101: "warnings",
+      101: "warnings: orphan nodes",
       103: "headless not supported by this gdUnit4",
       104: "Godot version not supported by this gdUnit4",
       105: "script errors"
@@ -37146,7 +37326,17 @@ class GodotServer {
       };
     }
     const failed = report.suites.flatMap((suite) => suite.cases.filter((entry) => entry.status === "failed" || entry.status === "error").map((entry) => ({ ...entry, path: suite.path })));
-    const unclean = report.suites.filter((suite) => suite.failures > 0 || suite.errors > 0 || suite.skipped > 0);
+    const orphans = orphansPrinted(said);
+    const leftBehind = new Map(orphans.suites.map((suite) => [suite.path, suite.orphans]));
+    const orphansIn = (path) => path === null ? 0 : leftBehind.get(path) ?? 0;
+    const warnings = orphans.suites.map((suite) => ({
+      kind: "orphans",
+      path: suite.path,
+      name: report.suites.find((entry) => entry.path === suite.path)?.name ?? suite.path,
+      orphans: suite.orphans,
+      message: `${suite.orphans} node${suite.orphans === 1 ? "" : "s"} were still in the tree when this suite finished. A node built in a test and neither freed nor added to the tree is the usual cause; free it, or add it with auto_free().`
+    }));
+    const unclean = report.suites.filter((suite) => suite.failures > 0 || suite.errors > 0 || suite.skipped > 0 || orphansIn(suite.path) > 0);
     return this.jsonTextResponse({
       passed: !hung && exitCode === 0 && report.failures === 0 && report.errors === 0,
       verdict,
@@ -37157,6 +37347,9 @@ class GodotServer {
       skipped: report.skipped,
       time: report.time,
       failed,
+      warnings: warnings.length > 0 ? warnings : undefined,
+      orphans: orphans.total > 0 ? orphans.total : undefined,
+      note: verdict.startsWith("warnings") && warnings.length === 0 ? "gdUnit4 exits 101 for orphan nodes when nothing failed, and this run printed no count of them: orphan reporting may be off in the project settings." : undefined,
       suites: unclean.map((suite) => ({
         name: suite.name,
         path: suite.path,
@@ -37164,6 +37357,7 @@ class GodotServer {
         failures: suite.failures,
         errors: suite.errors,
         skipped: suite.skipped,
+        orphans: orphansIn(suite.path) > 0 ? orphansIn(suite.path) : undefined,
         time: suite.time
       })),
       suitesPassed: report.suites.length - unclean.length,
@@ -37290,7 +37484,7 @@ class GodotServer {
         version: godotPath === null ? null : await this.godotVersion(godotPath)
       },
       game: {
-        processActive: this.activeProcess?.exitCode === null,
+        processActive: stillRunning(this.currentRun()),
         playingInEditor: playing,
         runtimeConnected: games.some((game) => game.reachable),
         runtimes: games
@@ -37436,6 +37630,10 @@ class GodotServer {
     if (sceneToRun && !sceneToRun.ok) {
       return this.createErrorResponse(sceneToRun.reason, PATH_SOLUTIONS);
     }
+    const given = this.gameArguments(args);
+    if (!given.ok) {
+      return given.response;
+    }
     if (!sceneToRun && !hasMainScene(project.value.file)) {
       return this.createErrorResponse("The project sets no main scene, so there is nothing to run.", [
         "Pass scene to run one scene",
@@ -37452,9 +37650,9 @@ class GodotServer {
     }
     const sceneArgument = sceneToRun?.ok ? sceneToRun.relativePath : null;
     if (op === "check") {
-      return await this.checkBoot(engine.value, project.value.path, sceneArgument, args);
+      return await this.checkBoot(engine.value, project.value.path, sceneArgument, args, given.value);
     }
-    if (this.activeProcess?.exitCode === null) {
+    if (stillRunning(this.currentRun())) {
       this.logDebug("Ending the running game before starting another");
       await this.endActiveGame();
     }
@@ -37463,17 +37661,20 @@ class GodotServer {
       platform: process.platform,
       variables: process.env
     });
-    if (this.godotBridge.isConnected() && (!headless || editorPlaysHeadless(project.value.file))) {
+    const editorWouldPlay = !headless || editorPlaysHeadless(project.value.file);
+    if (this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0) {
       return await this.playThroughEditor(sceneArgument, refreshed.value, project.value.path, alreadyPlaying);
     }
     const cmdArgs = runArguments({
       projectPath: project.value.path,
       headless,
-      scene: sceneArgument
+      scene: sceneArgument,
+      userArgs: given.value
     });
     this.logDebug(`Running Godot project: ${engine.value} ${cmdArgs.join(" ")}`);
-    const started = this.spawnGame(engine.value, cmdArgs);
+    const started = this.spawnKeptGame(engine.value, cmdArgs, project.value.path);
     this.activeProcess = started;
+    const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && given.value.length > 0 ? " The editor cannot be handed arguments for a game it plays, so this one was started " + "here: the debug_* tools answer only for a game the editor is playing." : "";
     return this.jsonTextResponse({
       started: true,
       through: "gdharness",
@@ -37481,11 +37682,11 @@ class GodotServer {
       arguments: cmdArgs,
       refreshedClasses: refreshed.value,
       runtime: await this.runtimeUp(project.value.path, alreadyPlaying),
-      message: "Use editor_output for what it prints and editor_run stop to end it."
+      message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}`
     });
   }
   async runtimeUp(projectPath, before) {
-    if (!existsSync12(join15(projectPath, RUNTIME_AUTOLOAD2.path))) {
+    if (!existsSync12(join16(projectPath, RUNTIME_AUTOLOAD2.path))) {
       return {
         listening: false,
         note: "this project has no gdharness_runtime addon, so the runtime_* tools have nothing to talk to"
@@ -37520,7 +37721,11 @@ class GodotServer {
     }
     const played = {
       process: null,
+      pid: null,
       log,
+      transcript: null,
+      readOffset: 0,
+      projectPath,
       startedAt: Date.now(),
       exitCode: null,
       throughEditor: true,
@@ -37559,6 +37764,7 @@ class GodotServer {
   async endActiveGame() {
     const running = this.activeProcess;
     this.activeProcess = null;
+    clearRunRecord();
     if (!running) {
       return;
     }
@@ -37566,14 +37772,26 @@ class GodotServer {
       await this.handleViaBridge("stop_playing", {});
       return;
     }
-    running.process?.kill();
+    if (running.process !== null) {
+      running.process.kill();
+      return;
+    }
+    if (running.pid !== null) {
+      try {
+        process.kill(running.pid);
+      } catch {}
+    }
   }
   spawnGame(godotPath, cmdArgs, env) {
     const child = spawn(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
     const log = new GameLog;
     const started = {
       process: child,
+      pid: child.pid ?? null,
       log,
+      transcript: null,
+      readOffset: 0,
+      projectPath: null,
       startedAt: Date.now(),
       exitCode: null,
       throughEditor: false,
@@ -37598,10 +37816,121 @@ class GodotServer {
     });
     return started;
   }
-  async checkBoot(godotPath, projectPath, scene, args) {
+  spawnKeptGame(godotPath, cmdArgs, projectPath, env) {
+    const startedAt = Date.now();
+    const transcript = openTranscript(startedAt);
+    let child;
+    try {
+      child = spawn(godotPath, cmdArgs, {
+        stdio: ["ignore", transcript.fd, transcript.fd],
+        detached: true,
+        ...env ? { env } : {}
+      });
+    } finally {
+      closeSync(transcript.fd);
+    }
+    child.unref();
+    const log = new GameLog;
+    const started = {
+      process: child,
+      pid: child.pid ?? null,
+      log,
+      transcript: transcript.path,
+      readOffset: 0,
+      projectPath,
+      startedAt,
+      exitCode: null,
+      throughEditor: false,
+      brokeOn: null
+    };
+    child.on("exit", (code) => {
+      this.logDebug(`Godot process exited with code ${code ?? "none"}`);
+      this.drainTranscript(started);
+      log.finish();
+      started.exitCode = code ?? -1;
+    });
+    child.on("error", (err) => {
+      console.error("Failed to start Godot process:", err);
+      log.append("stderr", `${err.message}
+`);
+      started.exitCode = -1;
+    });
+    if (started.pid !== null) {
+      writeRunRecord({
+        pid: started.pid,
+        transcript: transcript.path,
+        startedAt,
+        projectPath,
+        arguments: cmdArgs
+      });
+    }
+    sweepTranscripts();
+    return started;
+  }
+  drainTranscript(game) {
+    if (game.transcript === null) {
+      return;
+    }
+    let handle;
+    try {
+      handle = openSync2(game.transcript, "r");
+    } catch {
+      return;
+    }
+    try {
+      const size = fstatSync(handle).size;
+      if (size <= game.readOffset) {
+        return;
+      }
+      const buffer = Buffer.alloc(size - game.readOffset);
+      const read = readSync(handle, buffer, 0, buffer.length, game.readOffset);
+      game.readOffset += read;
+      game.log.append("transcript", buffer.subarray(0, read));
+    } finally {
+      closeSync(handle);
+    }
+  }
+  adoptRecordedRun() {
+    const record = readRunRecord();
+    if (record === null || !this.couldBeOurs(record.projectPath)) {
+      return null;
+    }
+    const adopted = {
+      process: null,
+      pid: record.pid,
+      log: new GameLog,
+      transcript: record.transcript,
+      readOffset: 0,
+      projectPath: record.projectPath === "" ? null : record.projectPath,
+      startedAt: record.startedAt,
+      exitCode: null,
+      throughEditor: false,
+      brokeOn: null
+    };
+    this.drainTranscript(adopted);
+    if (!alive(record.pid)) {
+      adopted.log.finish();
+      adopted.exitCode = null;
+      adopted.endedUnwatched = true;
+    }
+    this.activeProcess = adopted;
+    return adopted;
+  }
+  couldBeOurs(project) {
+    if (project === "") {
+      return true;
+    }
+    const status = this.godotBridge.getStatus();
+    const mine = this.ownProject ?? (status.connected ? status.projectPath ?? null : null);
+    return mine === null || samePath(mine, project);
+  }
+  currentRun() {
+    return this.activeProcess ?? this.adoptRecordedRun();
+  }
+  async checkBoot(godotPath, projectPath, scene, args, userArgs) {
     const frames = readPositiveNumber(args, "frames") ?? 3;
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 60000;
-    const cmdArgs = runArguments({ projectPath, headless: true, scene, quitAfter: frames });
+    const cmdArgs = runArguments({ projectPath, headless: true, scene, quitAfter: frames, userArgs });
     const boot = this.spawnGame(godotPath, cmdArgs);
     const hung = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -37631,37 +37960,47 @@ class GodotServer {
     });
   }
   handleGetDebugOutput(args) {
-    if (!this.activeProcess) {
+    const run = this.currentRun();
+    if (!run) {
       return this.createErrorResponse("No game is running. Start one with editor_run.");
     }
-    this.drainEditorOutput(this.activeProcess);
+    this.drainEditorOutput(run);
+    this.drainTranscript(run);
+    if (run.endedUnwatched !== true && !stillRunning(run)) {
+      run.log.finish();
+      run.endedUnwatched = run.exitCode === null;
+    }
     const severity = readString(args, "severity");
-    const selected = this.activeProcess.log.select({
+    const selected = run.log.select({
       severity: severity === "error" || severity === "warning" ? severity : "info",
       sinceLastCall: readBoolean(args, "sinceLastCall") ?? false,
       contains: readNonEmptyString(args, "contains"),
       limit: readPositiveNumber(args, "limit") ?? 200
     });
-    const halt = this.activeProcess.throughEditor ? this.dapClient?.whereItStopped() ?? null : null;
+    const halt = run.throughEditor ? this.dapClient?.whereItStopped() ?? null : null;
     return this.jsonTextResponse({
-      running: this.activeProcess.exitCode === null,
-      exitCode: this.activeProcess.exitCode,
-      through: this.activeProcess.throughEditor ? "editor" : "gdharness",
-      pid: this.activeProcess.process?.pid ?? null,
-      errors: this.activeProcess.log.count("error"),
-      warnings: this.activeProcess.log.count("warning"),
-      clean: this.activeProcess.log.count("error") === 0,
+      running: stillRunning(run),
+      exitCode: run.exitCode,
+      through: run.throughEditor ? "editor" : "gdharness",
+      pid: run.pid,
+      errors: run.log.count("error"),
+      warnings: run.log.count("warning"),
+      clean: run.log.count("error") === 0,
       heldAt: halt,
+      endedUnwatched: run.endedUnwatched === true ? true : undefined,
+      project: !run.throughEditor && run.process === null ? run.projectPath ?? undefined : undefined,
+      note: run.endedUnwatched === true ? "This run outlived the server that started it and is over now, so its exit code was never collected. Everything it printed is below, read back from its transcript." : undefined,
       omitted: selected.omitted,
       entries: selected.entries
     });
   }
   async handleStopProject() {
-    if (!this.activeProcess) {
+    const stopped = this.currentRun();
+    if (!stopped) {
       return this.createErrorResponse("No game is running. Start one with editor_run.");
     }
-    const stopped = this.activeProcess;
     this.drainEditorOutput(stopped);
+    this.drainTranscript(stopped);
     this.logDebug("Stopping the running game");
     await this.endActiveGame();
     return this.jsonTextResponse({
@@ -37767,8 +38106,8 @@ class GodotServer {
       return this.createErrorResponse(choice.problem);
     }
     const expectsScreenshot = command === "capture_screenshot" || command === "capture_viewport";
-    const screenshotDir = expectsScreenshot ? mkdtempSync3(join15(tmpdir5(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join15(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? mkdtempSync3(join16(tmpdir5(), "gdharness-runtime-screenshot-")) : null;
+    const screenshotPath = screenshotDir ? join16(screenshotDir, "capture.png") : null;
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs);
       if (!reply.ok) {
@@ -37789,12 +38128,12 @@ class GodotServer {
       return {
         content: [
           { type: "text", text: `Screenshot captured: ${dimensions}` },
-          { type: "image", data: readFileSync13(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync14(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
       if (screenshotDir) {
-        rmSync8(screenshotDir, { recursive: true, force: true });
+        rmSync9(screenshotDir, { recursive: true, force: true });
       }
     }
   }
@@ -37819,12 +38158,14 @@ class GodotServer {
       return this.createErrorResponse("runtime_inspect find needs at least one of className, script, namePattern, group, says.");
     }
     const property = readNonEmptyString(args, "property");
+    const includeHidden = readBoolean(args, "includeHidden");
     return await this.handleRuntimeCommand("find_nodes", {
       ...filters,
       projectPath: args["projectPath"],
       root: readNonEmptyString(args, "nodePath") ?? "/root",
       limit: readPositiveNumber(args, "limit") ?? 100,
-      ...property === undefined ? {} : { property }
+      ...property === undefined ? {} : { property },
+      ...includeHidden === undefined ? {} : { include_hidden: includeHidden }
     });
   }
   async handleRuntimeWait(op, args) {
@@ -37875,6 +38216,7 @@ var init_server3 = __esm(() => {
   init_ports();
   init_project_scan();
   init_resources();
+  init_run_record();
   init_runtime_client();
   init_server_version();
   init_setup();
@@ -37945,7 +38287,7 @@ var init_server3 = __esm(() => {
 
 // src/cli.ts
 import { existsSync as existsSync13 } from "fs";
-import { join as join16, resolve as resolve5 } from "path";
+import { join as join17, resolve as resolve5 } from "path";
 
 // src/errors.ts
 class Refusal extends Error {
@@ -39336,6 +39678,11 @@ them. \`editor_rescan\` asks it to scan and names any class it still cannot reso
 declaration and the cache can both be right while the editor stays blind to it. Change the
 declaring script, or restart the editor.
 
+A diagnostic about a member rather than a type, \`Static function "x()" not found in base "Y"\`
+about something the engine compiles, is a different thing and is no longer stale here: each ask
+gives the document back when its answer arrives, so the next one is read off disk. If one turns
+up anyway, believe the run over the diagnostic and say so.
+
 ## Refusals are useful
 
 An unknown op, an argument the tool does not name, or a missing required one is refused with the
@@ -39448,7 +39795,7 @@ class UsageError extends Refusal {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve5(named ?? ".");
-  if (!existsSync13(join16(projectPath, "project.godot"))) {
+  if (!existsSync13(join17(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;