gdharness 0.13.42 → 0.13.44

package/build/index.js

@@ -10183,7 +10183,7 @@ import {
   readSync
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename2, dirname as dirname6, join as join13, normalize as normalize2, relative as relative3 } from "node:path";
+import { basename as basename3, dirname as dirname6, join as join13, normalize as normalize2, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { promisify as promisify5 } from "node:util";
@@ -25831,7 +25831,7 @@ function dictionary(entries) {
 
 // src/game-log.ts
 import { StringDecoder } from "node:string_decoder";
-var HEADLINE = /^(USER )?(SCRIPT ERROR|ERROR|WARNING):\s?(.*)$/;
+var HEADLINE = /^(USER )?(SCRIPT ERROR|SHADER ERROR|ERROR|WARNING):\s?(.*)$/;
 var COLOUR_CODE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
 function announced(line) {
   const match = HEADLINE.exec(line);
@@ -27711,31 +27711,135 @@ async function handleLSPTool(client, toolName, args) {
 
 // src/process-children.ts
 import { execFile as execFile3 } from "node:child_process";
+import { basename } from "node:path";
 import { promisify as promisify3 } from "node:util";
 var run3 = promisify3(execFile3);
 var ASK_TIMEOUT_MS = 15000;
-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 ? "" : basename(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 run3("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 run3("pgrep", ["-P", String(pid)], { timeout: ASK_TIMEOUT_MS });
+async function askPosix() {
+  const { stdout } = await run3("ps", ["-e", "-o", "pid=,ppid=,args="], {
+    timeout: ASK_TIMEOUT_MS,
+    maxBuffer: 16 * 1024 * 1024
+  });
   return stdout;
 }
 
@@ -28186,11 +28290,11 @@ function restartSettled(projectPath) {
 
 // src/run-record.ts
 import { execFileSync } from "node:child_process";
-import { mkdirSync as mkdirSync5, openSync, readdirSync as readdirSync5, readFileSync as readFileSync11, rmSync as rmSync5, statSync as statSync3, writeFileSync as writeFileSync6 } from "node:fs";
-import { basename, join as join11 } from "node:path";
+import { mkdirSync as mkdirSync5, openSync, readdirSync as readdirSync5, readFileSync as readFileSync11, rmSync as rmSync5, statSync as statSync4, writeFileSync as writeFileSync6 } from "node:fs";
+import { basename as basename2, join as join11 } from "node:path";
 
 // src/runtime-client.ts
-import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync10, unlinkSync } from "node:fs";
+import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync3, unlinkSync } from "node:fs";
 import { createConnection as createConnection3 } from "node:net";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join10, resolve as resolve4 } from "node:path";
@@ -28271,6 +28375,17 @@ function runtimeDirectories(variables = process.env) {
   }
   return [...new Set(candidates.map((path) => resolve4(path)))];
 }
+var ERROR_REPORT_PATTERN = /^runtime-(\d+)\.log$/;
+function errorReportOf(pid, directories = runtimeDirectories()) {
+  for (const directory of directories) {
+    const path = join10(directory, `runtime-${pid}.log`);
+    if (existsSync7(path)) {
+      return path;
+    }
+  }
+  return null;
+}
+var ERROR_REPORT_KEEP_MS = 60 * 60 * 1000;
 function processAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -28362,6 +28477,11 @@ function announcedIn(directory) {
   }
   const found = [];
   for (const entry of readdirSync4(directory)) {
+    const report = ERROR_REPORT_PATTERN.exec(entry);
+    if (report) {
+      sweepErrorReport(join10(directory, entry), Number.parseInt(report[1] ?? "", 10));
+      continue;
+    }
     const match = ANNOUNCEMENT_PATTERN.exec(entry);
     if (!match) {
       continue;
@@ -28383,6 +28503,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 {}
+}
 var LOOK_EVERY_MS = 50;
 var ANNOUNCE_BUDGET_MS = 5000;
 async function announcedSince(projectPath, before, waiting = {}) {
@@ -28775,7 +28905,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 : basename(record.command);
+  const engine = record.command === undefined ? null : basename2(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)) {
@@ -28806,7 +28936,7 @@ function clearRunRecord(ours = () => true) {
 }
 function ageMs(path, now) {
   try {
-    return now - statSync3(path).mtimeMs;
+    return now - statSync4(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -29500,7 +29630,7 @@ var TOOL_SPECS = [
       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: [],
@@ -29523,7 +29653,7 @@ var TOOL_SPECS = [
   },
   {
     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",
@@ -29640,7 +29770,7 @@ var TOOL_SPECS = [
       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",
@@ -29858,7 +29988,7 @@ var TOOL_SPECS = [
       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",
@@ -30027,16 +30157,44 @@ function endedPreviousRun(ended) {
   }
   return ended.pid ?? true;
 }
+var CONSOLE_WRAPPER = /_console(\.exe)?$/i;
+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) {
@@ -31144,7 +31302,7 @@ class GodotServer {
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
-      name: typeof name === "string" && name !== "" ? name : basename2(project.value.path),
+      name: typeof name === "string" && name !== "" ? name : basename3(project.value.path),
       path: project.value.path,
       mainScene: typeof mainScene === "string" && mainScene !== "" ? mainScene : null,
       godotVersion: await this.godotVersion(engine.value),
@@ -31956,6 +32114,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);
@@ -32005,7 +32164,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, {
@@ -32076,7 +32235,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) {
@@ -32091,9 +32254,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;
@@ -32291,12 +32489,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;
@@ -32311,8 +32513,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;
@@ -32390,6 +32652,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);
@@ -32504,7 +32773,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)) {
@@ -32535,7 +32805,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,
@@ -32563,18 +32833,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,
@@ -32585,24 +32856,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;
@@ -32799,7 +33119,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);