gdharness 0.13.42 → 0.13.44

package/build/cli.js

@@ -7283,7 +7283,7 @@ class GameLog {
 }
 var HEADLINE, COLOUR_CODE, STREAMS, ADMITTED;
 var init_game_log = __esm(() => {
-  HEADLINE = /^(USER )?(SCRIPT ERROR|ERROR|WARNING):\s?(.*)$/;
+  HEADLINE = /^(USER )?(SCRIPT ERROR|SHADER ERROR|ERROR|WARNING):\s?(.*)$/;
   COLOUR_CODE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
   STREAMS = ["stdout", "stderr", "transcript"];
   ADMITTED = {
@@ -16015,7 +16015,7 @@ var init_tool_definitions = __esm(() => {
         andChildren: {
           type: "boolean",
           ops: ["stop"],
-          description: "stop: also end what the game started for itself, with OS.create_process or otherwise, such as a bench's workers. Only the children of the run's process that are announced as games of this project are ended, named under endedChildren; any other child is left and named under childrenLeft. Default false, and the run's process is ended either way."
+          description: "stop: also end what the game started for itself, with OS.create_process or otherwise, such as a bench's workers and whatever those started in turn. Only the processes under the run's, to any depth, that are games of this project are ended: announced as one, or this project's engine run with --path on this project by its command line, which is how a bench whose workers deliberately carry no runtime is reached. They are named under endedChildren, with what identified each under identifiedBy; any other process under the run is left and named under childrenLeft, and childrenUnknown is true when nothing could be listed, with the note saying whether the platform would not or the run has no process to list under. Default false, and the run's process is ended either way."
         }
       },
       requires: [],
@@ -16038,7 +16038,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. 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.",
       parameters: {
         severity: {
           type: "string",
@@ -16155,7 +16155,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["find"],
-          description: "find: part of what the node has written on it, case-insensitively, which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern."
+          description: "find: part of what the node has written on it, case-insensitively, which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern. A label with a line break is matched with the break in the words, and a backslash followed by n counts as one."
         },
         limit: {
           type: "number",
@@ -16373,7 +16373,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["until"],
-          description: "until: wait for these words to appear anywhere under nodePath instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Case-insensitive, part of a line, hidden nodes included. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property."
+          description: "until: wait for these words to appear anywhere under nodePath instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Case-insensitive, part of a line, hidden nodes included; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property."
         },
         timeoutMs: {
           type: "number",
@@ -36420,29 +36420,133 @@ var init_lsp_client = __esm(() => {
 
 // src/process-children.ts
 import { execFile as execFile5 } from "node:child_process";
+import { basename as basename2 } from "node:path";
 import { promisify as promisify5 } from "node:util";
-async function childrenOf(pid) {
+async function processTree() {
   try {
-    const printed = process.platform === "win32" ? await askWindows(pid) : await askPosix(pid);
-    return printed.split(/\r?\n/).map((line) => Number(line.trim())).filter((child) => Number.isInteger(child) && child > 0);
-  } catch (error) {
-    if (process.platform !== "win32" && error.code === 1) {
-      return [];
-    }
+    const printed = process.platform === "win32" ? await askWindows() : await askPosix();
+    return parseProcessTable(printed);
+  } catch {
     return;
   }
 }
-async function askWindows(pid) {
+function parseProcessTable(printed) {
+  const tree = new Map;
+  for (const line of printed.split(/\r?\n/)) {
+    const fields = /^\s*(\d+)\s+(\d+)(?:\s+(.*))?$/.exec(line);
+    if (fields === null) {
+      continue;
+    }
+    const pid = Number(fields[1]);
+    const parent = Number(fields[2]);
+    if (pid > 0) {
+      tree.set(pid, { parent, command: (fields[3] ?? "").trim() });
+    }
+  }
+  return tree;
+}
+function childrenIn(tree, pid) {
+  const children = [];
+  for (const [child, listed] of tree) {
+    if (listed.parent === pid) {
+      children.push(child);
+    }
+  }
+  return children;
+}
+function descendantsIn(tree, pid) {
+  const found = [];
+  const queue = [pid];
+  const seen = new Set([pid]);
+  while (queue.length > 0) {
+    const next = queue.shift();
+    if (next === undefined) {
+      break;
+    }
+    for (const child of childrenIn(tree, next)) {
+      if (!seen.has(child)) {
+        seen.add(child);
+        found.push(child);
+        queue.push(child);
+      }
+    }
+  }
+  return found;
+}
+function ancestorsIn(tree, pid, root) {
+  const chain = [];
+  const seen = new Set([pid]);
+  let parent = tree.get(pid)?.parent;
+  while (parent !== undefined && !seen.has(parent)) {
+    chain.push(parent);
+    if (parent === root) {
+      break;
+    }
+    seen.add(parent);
+    parent = tree.get(parent)?.parent;
+  }
+  return chain;
+}
+function readCommandLine(command) {
+  const words = commandWords(command);
+  const executable = words[0] === undefined ? "" : basename2(words[0].replaceAll("\\", "/"));
+  const at = words.indexOf("--path");
+  let projectPath = null;
+  if (at !== -1 && at + 1 < words.length) {
+    const taken = [];
+    for (const word of words.slice(at + 1)) {
+      if (taken.length > 0 && (word.startsWith("-") || /^[a-z]+:\/\//.test(word))) {
+        break;
+      }
+      taken.push(word);
+    }
+    projectPath = taken.join(" ");
+  }
+  return {
+    executable,
+    projectPath,
+    editor: words.some((word) => word === "-e" || word === "--editor")
+  };
+}
+function commandWords(command) {
+  const words = [];
+  let word = "";
+  let quoted = false;
+  let started = false;
+  for (const char of command) {
+    if (char === '"') {
+      quoted = !quoted;
+      started = true;
+    } else if (!quoted && /\s/.test(char)) {
+      if (started) {
+        words.push(word);
+        word = "";
+        started = false;
+      }
+    } else {
+      word += char;
+      started = true;
+    }
+  }
+  if (started) {
+    words.push(word);
+  }
+  return words;
+}
+async function askWindows() {
   const { stdout } = await run5("powershell.exe", [
     "-NoProfile",
     "-NonInteractive",
     "-Command",
-    `(Get-CimInstance Win32_Process -Filter "ParentProcessId=${pid}").ProcessId`
-  ], { timeout: ASK_TIMEOUT_MS, windowsHide: true });
+    'Get-CimInstance Win32_Process | ForEach-Object { "$($_.ProcessId) $($_.ParentProcessId) $($_.CommandLine)" }'
+  ], { timeout: ASK_TIMEOUT_MS, windowsHide: true, maxBuffer: 16 * 1024 * 1024 });
   return stdout;
 }
-async function askPosix(pid) {
-  const { stdout } = await run5("pgrep", ["-P", String(pid)], { timeout: ASK_TIMEOUT_MS });
+async function askPosix() {
+  const { stdout } = await run5("ps", ["-e", "-o", "pid=,ppid=,args="], {
+    timeout: ASK_TIMEOUT_MS,
+    maxBuffer: 16 * 1024 * 1024
+  });
   return stdout;
 }
 var run5, ASK_TIMEOUT_MS = 15000;
@@ -36663,7 +36767,7 @@ var init_restart_note = __esm(() => {
 });
 
 // src/runtime-client.ts
-import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync15, unlinkSync } from "node:fs";
+import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync15, statSync as statSync3, unlinkSync } from "node:fs";
 import { createConnection as createConnection3 } from "node:net";
 import { tmpdir as tmpdir4 } from "node:os";
 import { join as join17, resolve as resolve4 } from "node:path";
@@ -36684,6 +36788,15 @@ function runtimeDirectories(variables = process.env) {
   }
   return [...new Set(candidates.map((path) => resolve4(path)))];
 }
+function errorReportOf(pid, directories = runtimeDirectories()) {
+  for (const directory of directories) {
+    const path = join17(directory, `runtime-${pid}.log`);
+    if (existsSync13(path)) {
+      return path;
+    }
+  }
+  return null;
+}
 function processAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -36772,6 +36885,11 @@ function announcedIn(directory) {
   }
   const found = [];
   for (const entry of readdirSync5(directory)) {
+    const report = ERROR_REPORT_PATTERN.exec(entry);
+    if (report) {
+      sweepErrorReport(join17(directory, entry), Number.parseInt(report[1] ?? "", 10));
+      continue;
+    }
     const match = ANNOUNCEMENT_PATTERN.exec(entry);
     if (!match) {
       continue;
@@ -36793,6 +36911,16 @@ function announcedIn(directory) {
   }
   return found;
 }
+function sweepErrorReport(path, pid, now = Date.now()) {
+  if (processAlive(pid)) {
+    return;
+  }
+  try {
+    if (now - statSync3(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
+      unlinkSync(path);
+    }
+  } catch {}
+}
 async function announcedSince(projectPath, before, waiting = {}) {
   const wanted = resolve4(projectPath);
   const directories = waiting.directories ?? runtimeDirectories();
@@ -36963,16 +37091,18 @@ function runtimeRequest(endpoint, command, params, timeoutMs) {
     });
   });
 }
-var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, GONE_WINDOW_MS = 120000, GONE_KEPT = 32, gone, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1;
+var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, ERROR_REPORT_PATTERN, ERROR_REPORT_KEEP_MS, GONE_WINDOW_MS = 120000, GONE_KEPT = 32, gone, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1;
 var init_runtime_client = __esm(() => {
   ANNOUNCEMENT_PATTERN = /^runtime-(\d+)\.json$/;
+  ERROR_REPORT_PATTERN = /^runtime-(\d+)\.log$/;
+  ERROR_REPORT_KEEP_MS = 60 * 60 * 1000;
   gone = [];
 });
 
 // src/run-record.ts
 import { execFileSync } from "node:child_process";
-import { mkdirSync as mkdirSync9, openSync, readdirSync as readdirSync6, readFileSync as readFileSync16, rmSync as rmSync9, statSync as statSync3, writeFileSync as writeFileSync11 } from "node:fs";
-import { basename as basename2, join as join18 } from "node:path";
+import { mkdirSync as mkdirSync9, openSync, readdirSync as readdirSync6, readFileSync as readFileSync16, rmSync as rmSync9, statSync as statSync4, writeFileSync as writeFileSync11 } from "node:fs";
+import { basename as basename3, join as join18 } from "node:path";
 function runsDirectory() {
   return join18(runtimeDirectory(), "runs");
 }
@@ -37188,7 +37318,7 @@ function judgeRun(record, running, needed) {
   if (running.startedAt !== undefined && running.startedAt - record.startedAt > SAME_RUN_WINDOW_MS) {
     return false;
   }
-  const engine = record.command === undefined ? null : basename2(record.command);
+  const engine = record.command === undefined ? null : basename3(record.command);
   const said = process.platform === "win32" ? running.text.toLowerCase() : running.text;
   const wanted = engine === null || process.platform !== "win32" ? engine : engine.toLowerCase();
   if (wanted !== null && !said.includes(wanted)) {
@@ -37219,7 +37349,7 @@ function clearRunRecord(ours = () => true) {
 }
 function ageMs(path, now) {
   try {
-    return now - statSync3(path).mtimeMs;
+    return now - statSync4(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -37268,7 +37398,7 @@ import {
   readSync
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename3, dirname as dirname11, join as join19, normalize as normalize3, relative as relative3 } from "node:path";
+import { basename as basename4, dirname as dirname11, join as join19, 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";
@@ -37322,16 +37452,43 @@ function endedPreviousRun(ended) {
   }
   return ended.pid ?? true;
 }
+function engineNamesOf(executable) {
+  return CONSOLE_WRAPPER.test(executable) ? [executable, executable.replace(CONSOLE_WRAPPER, "$1")] : [executable];
+}
+function gameBetween(tree, pid, root, games) {
+  return ancestorsIn(tree, pid, root).some((one) => one !== root && games.has(one));
+}
+function endChildrenAmong(started) {
+  if (started.unknown !== false) {
+    return { ended: [], left: [], unknown: started.unknown };
+  }
+  for (const game of started.games) {
+    try {
+      process.kill(game.pid);
+    } catch {}
+  }
+  return { ended: started.games, left: [...started.others], unknown: false };
+}
 function aboutTheChildren(ended, throughEditor) {
+  const reaches = "andChildren ends what it started that is a game of this project: announced as one, or this project's engine run with --path on it.";
   if (ended === null) {
-    return throughEditor ? "Anything that game started for itself, with OS.create_process or otherwise, is not the editor's to stop and is still running; andChildren ends what it started that is announced as a game of this project." : "Anything that game started for itself, with OS.create_process or otherwise, is a separate process and is still running; andChildren ends what it started that is announced as a game of this project.";
+    return throughEditor ? `Anything that game started for itself, with OS.create_process or otherwise, is not the editor's to stop and was not signalled; ${reaches}` : `Anything that game started for itself, with OS.create_process or otherwise, is a separate process this stop did not signal; ${reaches}`;
   }
-  if (ended.unknown) {
+  if (ended.unknown === "platform") {
     return "andChildren was asked for and this platform would not list what the game had started, so nothing else was ended.";
   }
+  if (ended.unknown === "no process") {
+    return "andChildren was asked for and this run has no process id to list under: the editor plays it and its game announced none, so nothing else was ended.";
+  }
   const counted = (n) => `${n} ${n === 1 ? "process" : "processes"}`;
-  const endedToo = ended.ended.length === 0 ? "The game had started nothing announced as a game of this project, so nothing else was ended." : `${counted(ended.ended.length)} the game had started for itself, announced as games of this project, ${ended.ended.length === 1 ? "was" : "were"} ended with it, named under endedChildren.`;
-  const leftToo = ended.left.length === 0 ? "" : ` ${counted(ended.left.length)} it had started ${ended.left.length === 1 ? "was" : "were"} left, named under childrenLeft: not announced as a game of this project, so what ${ended.left.length === 1 ? "it is" : "they are"} cannot be told from here.`;
+  const announced = ended.ended.filter((one) => one.how === "announced").length;
+  const byCommandLine = ended.ended.length - announced;
+  const how = [
+    announced === 0 ? "" : `${announced} announced as ${announced === 1 ? "a game" : "games"} of this project`,
+    byCommandLine === 0 ? "" : `${byCommandLine} this project's engine run with --path on it, by ${byCommandLine === 1 ? "its" : "their"} command line`
+  ].filter((part) => part !== "").join(" and ");
+  const endedToo = ended.ended.length === 0 ? "The game had started nothing that is a game of this project, announced as one or this project's engine run with --path on it, so nothing else was ended." : `${counted(ended.ended.length)} the game had started for itself ${ended.ended.length === 1 ? "was" : "were"} ended with it, named under endedChildren with what identified ${ended.ended.length === 1 ? "it" : "each"} under identifiedBy: ${how}.`;
+  const leftToo = ended.left.length === 0 ? "" : ` ${counted(ended.left.length)} it had started ${ended.left.length === 1 ? "was" : "were"} left, named under childrenLeft: neither announced as a game of this project nor this project's engine run with --path on it, so what ${ended.left.length === 1 ? "it is" : "they are"} cannot be told from here.`;
   return `${endedToo}${leftToo}`;
 }
 function endedToStartThis(ended) {
@@ -38397,7 +38554,7 @@ class GodotServer {
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
-      name: typeof name === "string" && name !== "" ? name : basename3(project.value.path),
+      name: typeof name === "string" && name !== "" ? name : basename4(project.value.path),
       path: project.value.path,
       mainScene: typeof mainScene === "string" && mainScene !== "" ? mainScene : null,
       godotVersion: await this.godotVersion(engine.value),
@@ -39209,6 +39366,7 @@ class GodotServer {
     });
     this.logDebug(`Running Godot project: ${engine.value} ${cmdArgs.join(" ")}`);
     const started = this.spawnKeptGame(engine.value, cmdArgs, project.value.path);
+    started.announcedBefore = alreadyPlaying;
     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." : "";
     const endedForThis = endedToStartThis(ended);
@@ -39258,7 +39416,7 @@ class GodotServer {
       }
     });
     const going = this.currentRun();
-    if (endpoint !== null && going?.throughEditor === true && going.announcedPid === undefined) {
+    if (endpoint !== null && going !== null && going.announcedPid === undefined) {
       going.announcedPid = endpoint.pid;
     }
     return runtimeVerdict(endpoint, {
@@ -39329,7 +39487,11 @@ class GodotServer {
     });
   }
   drainEditorOutput(game) {
-    if (!game.throughEditor || !this.dapClient) {
+    if (!game.throughEditor) {
+      return;
+    }
+    this.drainErrorReport(game);
+    if (!this.dapClient) {
       return;
     }
     if (game.transcript === null) {
@@ -39344,9 +39506,44 @@ class GodotServer {
     }
     this.recordWhatItBrokeOn(game);
   }
+  drainErrorReport(game) {
+    if (game.errorReport === undefined) {
+      const its = this.announcedPidOf(game);
+      const found = its === undefined ? null : errorReportOf(its);
+      if (found === null) {
+        return;
+      }
+      game.errorReport = found;
+      game.errorReportOffset = 0;
+    }
+    let handle;
+    try {
+      handle = openSync2(game.errorReport, "r");
+    } catch {
+      return;
+    }
+    try {
+      const from = game.errorReportOffset ?? 0;
+      const size = fstatSync(handle).size;
+      if (size <= from) {
+        return;
+      }
+      const buffer = Buffer.alloc(size - from);
+      const read = readSync(handle, buffer, 0, buffer.length, from);
+      game.errorReportOffset = from + read;
+      const reported = buffer.subarray(0, read);
+      if (game.transcript !== null) {
+        appendFileSync(game.transcript, reported);
+      } else {
+        game.log.append("stderr", reported);
+      }
+    } finally {
+      closeSync(handle);
+    }
+  }
   recordWhatItBrokeOn(game) {
     const halt = this.dapClient?.whereItStopped() ?? null;
-    if (halt?.reason !== "exception" || halt.text === "" || game.brokeOn === halt.text) {
+    if (halt?.reason !== "exception" || halt.text === "" || game.brokeOn === halt.text || game.errorReport !== undefined) {
       return;
     }
     game.brokeOn = halt.text;
@@ -39544,12 +39741,16 @@ class GodotServer {
     this.activeProcess = picked;
   }
   announcedPidOf(run, announced) {
-    if (!run.throughEditor || run.announcedPid !== undefined) {
+    if (run.announcedPid !== undefined) {
+      return run.announcedPid;
+    }
+    const ours = this.announcedOfTheRunsProject(run, announced ?? runtimesAnnounced().running);
+    if (run.pid !== null && ours.some((one) => one.pid === run.pid)) {
+      run.announcedPid = run.pid;
       return run.announcedPid;
     }
     const before = run.announcedBefore ?? new Set;
-    const fresh = this.allAnnouncedForOurProject(announced ?? runtimesAnnounced().running).filter((one) => !before.has(one.pid));
-    const candidates = fresh.filter((one) => this.playedByOurEditor(one, run.projectPath));
+    const candidates = ours.filter((one) => !before.has(one.pid) && this.isTheGameOf(run, one, run.projectPath));
     const theOne = candidates.length === 1 ? candidates[0] : undefined;
     if (theOne !== undefined) {
       run.announcedPid = theOne.pid;
@@ -39564,8 +39765,68 @@ class GodotServer {
     if (projectPath !== undefined && run.projectPath !== null && !isSameDirectory(run.projectPath, projectPath)) {
       return;
     }
-    const its = run.throughEditor ? this.announcedPidOf(run, running) : run.pid;
-    return its !== null && its !== undefined && running.some((one) => one.pid === its) ? its : undefined;
+    const its = this.announcedPidOf(run, running);
+    return its !== undefined && running.some((one) => one.pid === its) ? its : undefined;
+  }
+  async ownGameThroughTheTree(running, projectPath) {
+    const run = this.currentRun();
+    if (run === null || !stillRunning(run) || run.announcedPid !== undefined) {
+      return;
+    }
+    if (projectPath !== undefined && run.projectPath !== null && !isSameDirectory(run.projectPath, projectPath)) {
+      return;
+    }
+    const its = await this.tiedThroughTheTree(run, running);
+    return its !== undefined && running.some((one) => one.pid === its) ? its : undefined;
+  }
+  async tiedThroughTheTree(run, announced) {
+    if (run.announcedPid !== undefined) {
+      return run.announcedPid;
+    }
+    const ours = this.announcedOfTheRunsProject(run, announced);
+    if (ours.length === 0) {
+      return;
+    }
+    const tree = await processTree();
+    if (tree === undefined) {
+      return;
+    }
+    return this.tieThroughTheTree(run, tree, new Set(ours.map((one) => one.pid)));
+  }
+  async gameProcessOf(run) {
+    if (run.gamePid !== undefined) {
+      return run.gamePid;
+    }
+    const announced = runtimesAnnounced().running;
+    const tied = await this.tiedThroughTheTree(run, announced);
+    if (tied !== undefined) {
+      return tied;
+    }
+    const tree = await processTree();
+    if (tree === undefined) {
+      return;
+    }
+    const found = this.gameByCommandLineIn(run, tree);
+    if (found !== undefined) {
+      run.gamePid = found;
+    }
+    return found;
+  }
+  tieThroughTheTree(run, tree, games) {
+    const root = run.pid ?? (run.throughEditor ? this.godotBridge.getStatus().editorPid : undefined);
+    if (root === undefined) {
+      return;
+    }
+    if (games.has(root)) {
+      run.announcedPid = root;
+      return root;
+    }
+    const nearest = descendantsIn(tree, root).filter((one) => games.has(one) && !gameBetween(tree, one, root, games));
+    const theOne = nearest.length === 1 ? nearest[0] : undefined;
+    if (theOne !== undefined) {
+      run.announcedPid = theOne;
+    }
+    return theOne;
   }
   playedByOurEditor(endpoint, projectPath) {
     const editor = this.godotBridge.getStatus().editorPid;
@@ -39643,6 +39904,13 @@ class GodotServer {
   announcedForOurProject(announced) {
     return this.allAnnouncedForOurProject(announced)[0] ?? null;
   }
+  announcedOfTheRunsProject(run, announced) {
+    const project = run.projectPath;
+    if (project === null) {
+      return this.allAnnouncedForOurProject(announced);
+    }
+    return announced.filter((one) => one.project.path !== "" && isSameDirectory(project, one.project.path));
+  }
   allAnnouncedForOurProject(announced) {
     const status = this.godotBridge.getStatus();
     const mine = this.ownProject ?? (status.connected ? status.projectPath ?? null : null);
@@ -39757,7 +40025,8 @@ class GodotServer {
     });
     const hold = await this.holdOf(run, going);
     const wanted = readBoolean(args, "cpu") ?? false;
-    const processToAsk = run.pid ?? this.announcedPidOf(run) ?? null;
+    const announced = this.announcedPidOf(run);
+    const processToAsk = wanted ? announced ?? (stillRunning(run) ? await this.gameProcessOf(run) : undefined) ?? run.pid ?? null : null;
     const cpuSeconds = wanted && processToAsk !== null && stillRunning(run) ? await cpuSecondsOf(processToAsk) : undefined;
     const notes = [];
     if (wanted && cpuSeconds === undefined && stillRunning(run)) {
@@ -39788,7 +40057,7 @@ class GodotServer {
       running: going,
       exitCode: run.exitCode,
       through: run.throughEditor ? "editor" : "gdharness",
-      pid: run.pid ?? this.announcedPidOf(run) ?? null,
+      pid: run.pid ?? announced ?? run.announcedPid ?? null,
       errors: run.log.count("error"),
       warnings: run.log.count("warning"),
       clean: run.consoleLost === true ? undefined : run.log.count("error") === 0,
@@ -39816,18 +40085,19 @@ class GodotServer {
     this.drainTranscript(stopped);
     const wasRunning = await this.runStillGoing(stopped);
     const endedPid = stopped.pid ?? this.announcedPidOf(stopped) ?? null;
-    const children = readBoolean(args, "andChildren") === true && wasRunning && endedPid !== null ? await childrenOf(endedPid) : null;
+    const children = readBoolean(args, "andChildren") === true && wasRunning ? await this.whatTheRunStarted(stopped) : null;
     this.logDebug("Stopping the running game");
     await this.endActiveGame("editor_run stop");
-    const ended = children === null ? null : this.endChildrenAmong(children, stopped.projectPath);
+    const ended = children === null ? null : endChildrenAmong(children);
     return this.jsonTextResponse({
       stopped: true,
       through: stopped.throughEditor ? "editor" : "gdharness",
       endedPid,
       ...ended === null ? {} : {
-        endedChildren: ended.ended,
+        endedChildren: ended.ended.map((one) => one.pid),
+        identifiedBy: ended.ended.length === 0 ? undefined : Object.fromEntries(ended.ended.map((one) => [String(one.pid), one.identifiedBy])),
         childrenLeft: ended.left.length === 0 ? undefined : ended.left,
-        childrenUnknown: ended.unknown ? true : undefined
+        childrenUnknown: ended.unknown === false ? undefined : true
       },
       exitedBeforeStop: stopped.exitCode !== null || !wasRunning,
       exitCode: stopped.exitCode,
@@ -39838,24 +40108,73 @@ class GodotServer {
       entries: forAnswer(stopped.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries)
     });
   }
-  endChildrenAmong(children, projectPath) {
-    if (children === undefined) {
-      return { ended: [], left: [], unknown: true };
-    }
-    const games = new Set(runtimesAnnounced().running.filter((one) => projectPath === null || isSameDirectory(one.project.path, projectPath)).map((one) => one.pid));
-    const ended = [];
-    const left = [];
-    for (const child of children) {
-      if (!games.has(child)) {
-        left.push(child);
+  async whatTheRunStarted(run) {
+    const tree = await processTree();
+    if (tree === undefined) {
+      return { unknown: "platform" };
+    }
+    const announced = this.announcedOfTheRunsProject(run, runtimesAnnounced().running);
+    const games = new Set(announced.map((one) => one.pid));
+    const own = this.announcedPidOf(run, announced) ?? this.tieThroughTheTree(run, tree, games) ?? run.gamePid ?? this.gameByCommandLineIn(run, tree);
+    if (own !== undefined && run.announcedPid === undefined) {
+      run.gamePid = own;
+    }
+    const roots = [run.pid, own].filter((one) => one !== null && one !== undefined);
+    if (roots.length === 0) {
+      return { unknown: "no process" };
+    }
+    const under = new Set(roots.flatMap((root) => descendantsIn(tree, root)));
+    for (const root of roots) {
+      under.delete(root);
+    }
+    const started = [...under].sort((a, b) => a - b);
+    const found = [];
+    const others = [];
+    for (const pid of started) {
+      if (games.has(pid)) {
+        found.push({ pid, how: "announced", identifiedBy: "announced as a game of this project" });
         continue;
       }
-      try {
-        process.kill(child);
-        ended.push(child);
-      } catch {}
+      const engines = [...roots, ...roots.flatMap((root) => ancestorsIn(tree, pid, root))];
+      const read = this.theProjectsEngine(run, tree, pid, engines);
+      if (read !== null) {
+        found.push({
+          pid,
+          how: "command line",
+          identifiedBy: `${read.executable} run with --path ${read.projectPath ?? ""}, this project's engine on this project`
+        });
+        continue;
+      }
+      others.push(pid);
+    }
+    return { unknown: false, games: found, others };
+  }
+  theProjectsEngine(run, tree, pid, engines) {
+    const project = run.projectPath;
+    if (project === null) {
+      return null;
+    }
+    const read = readCommandLine(tree.get(pid)?.command ?? "");
+    if (read.executable === "" || read.editor || read.projectPath === null || !isSameDirectory(read.projectPath, project)) {
+      return null;
+    }
+    const names = engines.flatMap((one) => engineNamesOf(readCommandLine(tree.get(one)?.command ?? "").executable));
+    const sameName = (one, other) => one !== "" && (process.platform === "win32" ? one.toLowerCase() === other.toLowerCase() : one === other);
+    return names.some((name) => sameName(name, read.executable)) ? read : null;
+  }
+  gameByCommandLineIn(run, tree) {
+    const root = run.pid ?? (run.throughEditor ? this.godotBridge.getStatus().editorPid : undefined);
+    if (root === undefined || run.projectPath === null) {
+      return;
+    }
+    const rootRead = readCommandLine(tree.get(root)?.command ?? "");
+    const rootIsTheGame = !rootRead.editor && !CONSOLE_WRAPPER.test(rootRead.executable) && rootRead.projectPath !== null && isSameDirectory(rootRead.projectPath, run.projectPath);
+    if (rootIsTheGame) {
+      return;
     }
-    return { ended, left, unknown: false };
+    const isEngine = (pid) => this.theProjectsEngine(run, tree, pid, [root]) !== null;
+    const nearest = descendantsIn(tree, root).filter((pid) => isEngine(pid) && !ancestorsIn(tree, pid, root).some((one) => one !== root && isEngine(one)));
+    return nearest.length === 1 ? nearest[0] : undefined;
   }
   async handleRescanFilesystem(args) {
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 30000;
@@ -40052,7 +40371,7 @@ class GodotServer {
     const { op: _op, projectPath, pid, ...params } = asParams(args);
     const announced = runtimesAnnounced();
     const wanted = typeof projectPath === "string" ? projectPath : this.ownProject ?? undefined;
-    const own = typeof pid === "number" ? undefined : this.ownGameAmong(announced.running, wanted);
+    const own = typeof pid === "number" ? undefined : this.ownGameAmong(announced.running, wanted) ?? await this.ownGameThroughTheTree(announced.running, wanted);
     const choice = chooseRuntime(announced.running, wanted, announced.unspoken, typeof pid === "number" ? pid : own);
     if ("problem" in choice) {
       return this.createErrorResponse(choice.problem);
@@ -40160,7 +40479,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, 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, CONSOLE_WRAPPER, 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();
@@ -40195,6 +40514,7 @@ var init_server3 = __esm(() => {
   init_update_check();
   run7 = promisify7(execFile7);
   __dirname2 = dirname11(fileURLToPath4(import.meta.url));
+  CONSOLE_WRAPPER = /_console(\.exe)?$/i;
   VALUE_NAMES = {
     string: "a string",
     number: "a number",
@@ -41719,7 +42039,9 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
   false is a runtime that is not coming and true is a game still on its way up.
 - Read \`editor_output\` after every run. It returns the engine's errors and warnings as entries
   with their backtraces, and a \`clean\` verdict, so a run that printed an error is one call away
-  from being known. For a long run it also names a transcript file: read that for output and this
+  from being known. For a run the editor plays, the errors come from the game through the runtime
+  addon, so a played game without the addon is judged on its prints alone and \`clean\` there says
+  less. For a long run it also names a transcript file: read that for output and this
   answer for state. Never decide a run has ended by watching the file stop growing, or a process
   list, or a timeout; a bench between prints looks exactly like a bench that died to everything else.
   \`endedBy\` says whether gdharness ended it, and \`running\` is asked of the operating system
@@ -41752,7 +42074,7 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | Where a 3D node is on screen | \`runtime_inspect\` \`rect\`, rather than unprojecting by hand |
 | Wait for something in a running game | \`runtime_wait\`, never a sleep; \`until\` with \`says\` for a panel that rebuilds its own labels |
 | Wait for a run to finish | \`editor_run wait\`, never a sleep or a shell loop on the pid: it answers as \`editor_output\` does, once the run is over |
-| End a bench and the workers it opened | \`editor_run stop\` with \`andChildren\`, never a process listing by scene name: it ends the children of the run's process that are announced as games of the project, names them under \`endedChildren\`, and leaves and names any other child |
+| End a bench and the workers it opened | \`editor_run stop\` with \`andChildren\`, never a process listing by scene name: it ends every process under the run's, to any depth, that is a game of the project, announced as one or the project's engine run with \`--path\` on it, names them under \`endedChildren\` with what identified each, and leaves and names any other |
 | A picture, for a person who asked to see one | \`runtime_capture\` |
 
 These need the runtime autoload, which \`gdharness setup\` registers. \`runtime_capture\` needs a