gdharness 0.13.41 → 0.13.43

package/build/index.js

@@ -10168,7 +10168,7 @@ function defectReport(where, error, context = {}) {
 }
 
 // src/server.ts
-import { execFile as execFile4, spawn } from "node:child_process";
+import { execFile as execFile5, spawn } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   appendFileSync,
@@ -10183,10 +10183,10 @@ 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 promisify4 } from "node:util";
+import { promisify as promisify5 } from "node:util";
 
 // node_modules/zod/v3/helpers/util.js
 var 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);
@@ -27709,25 +27709,159 @@ async function handleLSPTool(client, toolName, args) {
   }
 }
 
-// src/process-time.ts
+// 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 = 6000;
+var ASK_TIMEOUT_MS = 15000;
+async function processTree() {
+  try {
+    const printed = process.platform === "win32" ? await askWindows() : await askPosix();
+    return parseProcessTable(printed);
+  } catch {
+    return;
+  }
+}
+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 | ForEach-Object { "$($_.ProcessId) $($_.ParentProcessId) $($_.CommandLine)" }'
+  ], { timeout: ASK_TIMEOUT_MS, windowsHide: true, maxBuffer: 16 * 1024 * 1024 });
+  return stdout;
+}
+async function askPosix() {
+  const { stdout } = await run3("ps", ["-e", "-o", "pid=,ppid=,args="], {
+    timeout: ASK_TIMEOUT_MS,
+    maxBuffer: 16 * 1024 * 1024
+  });
+  return stdout;
+}
+
+// src/process-time.ts
+import { execFile as execFile4 } from "node:child_process";
+import { promisify as promisify4 } from "node:util";
+var run4 = promisify4(execFile4);
+var ASK_TIMEOUT_MS2 = 6000;
 async function cpuSecondsOf(pid) {
   try {
-    return process.platform === "win32" ? await askWindows(pid) : await askPosix(pid);
+    return process.platform === "win32" ? await askWindows2(pid) : await askPosix2(pid);
   } catch {
     return;
   }
 }
-async function askWindows(pid) {
-  const { stdout } = await run3("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `(Get-Process -Id ${pid}).CPU`], { timeout: ASK_TIMEOUT_MS, windowsHide: true });
+async function askWindows2(pid) {
+  const { stdout } = await run4("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `(Get-Process -Id ${pid}).CPU`], { timeout: ASK_TIMEOUT_MS2, windowsHide: true });
   const seconds = Number(stdout.trim().replace(",", "."));
   return Number.isFinite(seconds) ? seconds : undefined;
 }
-async function askPosix(pid) {
-  const { stdout } = await run3("ps", ["-o", "time=", "-p", String(pid)], { timeout: ASK_TIMEOUT_MS });
+async function askPosix2(pid) {
+  const { stdout } = await run4("ps", ["-o", "time=", "-p", String(pid)], { timeout: ASK_TIMEOUT_MS2 });
   return secondsFromClock(stdout.trim());
 }
 function secondsFromClock(printed) {
@@ -28156,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";
@@ -28241,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);
@@ -28332,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;
@@ -28353,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 = {}) {
@@ -28745,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)) {
@@ -28776,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;
   }
@@ -28848,7 +29008,7 @@ var RUNNING_PROJECT_PATH = {
 };
 var RUNNING_PID = {
   type: "number",
-  description: "Which game, when several are running from one project, such as a bench and its workers: its process id, as editor_status lists under runtimes. Not needed with one game per project."
+  description: "Which game, when several are running from one project, such as a bench and its workers: its process id, as editor_status lists under runtimes. Without it the game this server started or plays is the one asked when it is among them, and the answer says so under answeredBy; with one game per project it is not needed at all."
 };
 var SCENE_PATH = {
   type: "string",
@@ -29466,6 +29626,11 @@ var TOOL_SPECS = [
         type: "number",
         ops: ["check", "wait"],
         description: "check: how long to give the boot before it is called hung. Default 60000. wait: how long to wait for the run to end before answering anyway. Default 600000."
+      },
+      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 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: [],
@@ -29475,7 +29640,7 @@ var TOOL_SPECS = [
         requires: ["projectPath"]
       },
       stop: {
-        summary: "end the run and answer with what it printed last, naming the process ended under endedPid: a game that started processes of its own keeps them",
+        summary: "end the run and answer with what it printed last, naming the process ended under endedPid: a game that started processes of its own keeps them unless andChildren says to end those too",
         requires: []
       },
       check: {
@@ -29488,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",
@@ -29937,7 +30102,7 @@ function buildToolDefinitions() {
 // src/server.ts
 var UPDATE_NOTICE_EVERY = 500;
 var FEEDBACK_NOTICE_EVERY = 250;
-var run4 = promisify4(execFile4);
+var run5 = promisify5(execFile5);
 var __dirname2 = dirname6(fileURLToPath2(import.meta.url));
 var EDITOR_RESTART_TIMEOUT_MS = 90000;
 var HOLD_PING_MS = 2000;
@@ -29992,6 +30157,46 @@ 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 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 === "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 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) {
   if (ended === null) {
     return "";
@@ -30733,7 +30938,7 @@ class GodotServer {
         return op === "restart" ? await this.handleRestartEditor() : await this.handleLaunchEditor(args);
       case "editor_run":
         if (op === "stop") {
-          return await this.handleStopProject();
+          return await this.handleStopProject(args);
         }
         if (op === "wait") {
           return await this.handleWaitForRun(args);
@@ -31097,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),
@@ -31176,7 +31381,7 @@ class GodotServer {
     const log = new GameLog;
     let exitCode = 0;
     try {
-      const { stdout, stderr } = await run4(engine.value, exportArgs, { timeout: 300000 });
+      const { stdout, stderr } = await run5(engine.value, exportArgs, { timeout: 300000 });
       log.append("stdout", stdout);
       log.append("stderr", stderr);
     } catch (error) {
@@ -31373,7 +31578,7 @@ class GodotServer {
   }
   async godotVersion(godotPath) {
     try {
-      const { stdout } = await run4(godotPath, ["--version"], { timeout: 1e4 });
+      const { stdout } = await run5(godotPath, ["--version"], { timeout: 1e4 });
       this.lastGodotVersion = stdout.trim();
       return this.lastGodotVersion;
     } catch (error) {
@@ -31909,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);
@@ -31958,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, {
@@ -32029,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) {
@@ -32044,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;
@@ -32244,18 +32489,93 @@ 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;
     }
     return run.announcedPid;
   }
+  ownGameAmong(running, projectPath) {
+    const run = this.currentRun();
+    if (run === null || !stillRunning(run)) {
+      return;
+    }
+    if (projectPath !== undefined && run.projectPath !== null && !isSameDirectory(run.projectPath, projectPath)) {
+      return;
+    }
+    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;
     if (editor === undefined) {
@@ -32332,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);
@@ -32446,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)) {
@@ -32477,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,
@@ -32495,7 +32823,7 @@ class GodotServer {
       entries: forAnswer(selected.entries)
     });
   }
-  async handleStopProject() {
+  async handleStopProject(args) {
     await this.pickUpWhatTheEditorIsPlaying();
     const stopped = this.currentRun();
     if (!stopped) {
@@ -32504,21 +32832,98 @@ class GodotServer {
     this.drainEditorOutput(stopped);
     this.drainTranscript(stopped);
     const wasRunning = await this.runStillGoing(stopped);
+    const endedPid = stopped.pid ?? this.announcedPidOf(stopped) ?? 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 : endChildrenAmong(children);
     return this.jsonTextResponse({
       stopped: true,
       through: stopped.throughEditor ? "editor" : "gdharness",
-      endedPid: stopped.pid ?? this.announcedPidOf(stopped) ?? null,
+      endedPid,
+      ...ended === null ? {} : {
+        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 === false ? undefined : true
+      },
       exitedBeforeStop: stopped.exitCode !== null || !wasRunning,
       exitCode: stopped.exitCode,
       errors: stopped.log.count("error"),
       warnings: stopped.log.count("warning"),
       clean: stopped.log.count("error") === 0,
-      note: !wasRunning ? "This run was over before the stop, so nothing was ended here: editor_output has what it printed and how it ended. Anything that game started for itself, with OS.create_process or otherwise, is a separate process and may still be running." : stopped.throughEditor ? "The editor was asked to stop the scene it is playing. Anything that game started for itself, with OS.create_process or otherwise, is not the editor's to stop and is still running." : "The process named under endedPid was ended. Anything that game started for itself, with OS.create_process or otherwise, is a separate process and is still running.",
+      note: !wasRunning ? "This run was over before the stop, so nothing was ended here: editor_output has what it printed and how it ended. Anything that game started for itself, with OS.create_process or otherwise, is a separate process and may still be running." : `${stopped.throughEditor ? "The editor was asked to stop the scene it is playing." : "The process named under endedPid was ended."} ${aboutTheChildren(ended, stopped.throughEditor)}`,
       entries: forAnswer(stopped.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries)
     });
   }
+  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;
+      }
+      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;
+    }
+    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;
     const started = Date.now();
@@ -32713,10 +33118,15 @@ class GodotServer {
   async handleRuntimeCommand(command, args, timeoutMs = this.runtimeTimeoutMs()) {
     const { op: _op, projectPath, pid, ...params } = asParams(args);
     const announced = runtimesAnnounced();
-    const choice = chooseRuntime(announced.running, typeof projectPath === "string" ? projectPath : this.ownProject ?? undefined, announced.unspoken, typeof pid === "number" ? pid : undefined);
+    const wanted = typeof projectPath === "string" ? projectPath : this.ownProject ?? undefined;
+    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);
     }
+    const ofProject = announced.running.filter((one) => wanted === undefined || isSameDirectory(one.project.path, wanted));
+    const chosenAmongSeveral = own !== undefined && ofProject.length > 1;
+    const answeredBy = chosenAmongSeveral ? { answeredBy: own } : {};
     const held = this.knownHoldOn(choice.endpoint, announced.running);
     if (held !== null) {
       return this.createErrorResponse(`The game (pid ${choice.endpoint.pid}) is held by the editor's debugger, ${describeHalt(held)}, and answers no runtime call while it is.`, [
@@ -32735,7 +33145,7 @@ class GodotServer {
       }
       const { id: _id, ...payload } = reply.payload;
       if (!expectsScreenshot) {
-        return this.jsonTextResponse(payload);
+        return this.jsonTextResponse({ ...payload, ...answeredBy });
       }
       const returnedPath = readString(payload, "path");
       if (readString(payload, "type") !== "screenshot_file" || !returnedPath || !screenshotPath) {
@@ -32747,7 +33157,10 @@ class GodotServer {
       const dimensions = `${readNumber(payload, "width") ?? 0}x${readNumber(payload, "height") ?? 0} ${readString(payload, "format") ?? "unknown"}`;
       return {
         content: [
-          { type: "text", text: `Screenshot captured: ${dimensions}` },
+          {
+            type: "text",
+            text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}`
+          },
           { type: "image", data: readFileSync13(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };