gdharness 0.12.3 → 0.12.5

package/build/cli.js

@@ -15688,19 +15688,34 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_run",
-      description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. args hands the game its own flags, the ones it reads with OS.get_cmdline_user_args(), and a run carrying any is started by this server rather than by the editor. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice.",
+      description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. args hands the game its own flags, the ones it reads with OS.get_cmdline_user_args(), and a run carrying any is started by this server rather than by the editor. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice. When it is not listening, mayYetAnnounce says whether that is final: false is a runtime that is not coming, true is a game still on its way up, which editor_status will see and runtimeWaitMs waits longer for.",
       parameters: {
         projectPath: PROJECT_PATH,
-        scene: { type: "string", description: "A scene to run instead of the main scene." },
+        scene: {
+          type: "string",
+          ops: ["start", "check"],
+          description: "A scene to run instead of the main scene."
+        },
         args: {
           type: "array",
           items: { type: "string" },
+          ops: ["start", "check"],
           description: `The game's own arguments, what OS.get_cmdline_user_args() answers, such as ["--level=2"]. The separator is added here. A run with any is started by this server rather than by the editor, which fixes the game's command line when it opens the project, so the debug_* tools do not answer for it.`
         },
-        headless: { type: "boolean", description: "start: force a window or no window." },
-        frames: { type: "number", description: "check: frames to run before quitting. Default 3." },
+        headless: { type: "boolean", ops: ["start"], description: "start: force a window or no window." },
+        runtimeWaitMs: {
+          type: "number",
+          ops: ["start"],
+          description: "start: how long to wait for the game to announce its runtime before answering. Default 5000. Worth raising for a project that takes longer than that to reach its first frame, which is what leaves runtime listening false on a game whose runtime arrives a moment later."
+        },
+        frames: {
+          type: "number",
+          ops: ["check"],
+          description: "check: frames to run before quitting. Default 3."
+        },
         timeoutMs: {
           type: "number",
+          ops: ["check"],
           description: "check: how long to give the boot before it is called hung. Default 60000."
         }
       },
@@ -15714,7 +15729,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. 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.",
+      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. 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: running is asked of the operating system, 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.",
       parameters: {
         severity: {
           type: "string",
@@ -36095,8 +36110,9 @@ var init_runtime_client = __esm(() => {
 });
 
 // src/run-record.ts
+import { execFileSync } from "node:child_process";
 import { mkdirSync as mkdirSync6, openSync, readdirSync as readdirSync6, readFileSync as readFileSync12, rmSync as rmSync7, statSync as statSync2, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join14 } from "node:path";
+import { basename as basename2, join as join14 } from "node:path";
 function runsDirectory() {
   return join14(runtimeDirectory(), "runs");
 }
@@ -36147,9 +36163,75 @@ function recordAt(path) {
     transcript,
     startedAt,
     projectPath: typeof fields["projectPath"] === "string" ? fields["projectPath"] : "",
-    arguments: Array.isArray(args) ? args.filter((value) => typeof value === "string") : []
+    arguments: Array.isArray(args) ? args.filter((value) => typeof value === "string") : [],
+    ...typeof fields["command"] === "string" ? { command: fields["command"] } : {}
   };
 }
+function runningAs(pid) {
+  if (process.platform === "win32") {
+    const line = windowsCommandLine(pid);
+    if (line !== null) {
+      return { kind: "commandLine", text: line };
+    }
+    const image = windowsImage(pid);
+    return image === null ? null : { kind: "image", text: image };
+  }
+  try {
+    if (process.platform === "linux") {
+      const raw = readFileSync12(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      return raw === "" ? null : { kind: "commandLine", text: raw };
+    }
+    const args = execFileSync("ps", ["-p", String(pid), "-o", "args="], {
+      encoding: "utf8",
+      timeout: 15000
+    }).trim();
+    return args === "" ? null : { kind: "commandLine", text: args };
+  } catch {
+    return null;
+  }
+}
+function windowsCommandLine(pid) {
+  try {
+    const answer = execFileSync("powershell", [
+      "-NoProfile",
+      "-NonInteractive",
+      "-Command",
+      `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").CommandLine`
+    ], { encoding: "utf8", timeout: 15000, windowsHide: true }).trim();
+    return answer === "" ? null : answer;
+  } catch {
+    return null;
+  }
+}
+function windowsImage(pid) {
+  try {
+    const csv = execFileSync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
+      encoding: "utf8",
+      timeout: 15000,
+      windowsHide: true
+    });
+    return /^"([^"]+)"/.exec(csv.trim())?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+function stillTheRecordedRun(record) {
+  const running = runningAs(record.pid);
+  if (running === null) {
+    return false;
+  }
+  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)) {
+    return false;
+  }
+  if (running.kind === "image" || record.projectPath === "") {
+    return wanted !== null;
+  }
+  const project = process.platform === "win32" ? record.projectPath.toLowerCase() : record.projectPath;
+  return said.includes(project);
+}
 function clearRunRecord(ours = () => true) {
   for (const path of recordPaths()) {
     const record = recordAt(path);
@@ -36234,7 +36316,7 @@ import {
   rmSync as rmSync9
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename2, dirname as dirname9, join as join16, normalize as normalize3 } from "node:path";
+import { basename as basename3, dirname as dirname9, join as join16, normalize as normalize3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { promisify as promisify5 } from "node:util";
@@ -36250,6 +36332,38 @@ function stillRunning(run) {
   }
   return true;
 }
+function runIsUp(run, editorSays) {
+  if (run?.throughEditor !== true) {
+    return stillRunning(run);
+  }
+  return editorSays ?? stillRunning(run);
+}
+function runtimeVerdict(endpoint, after) {
+  if (endpoint !== null) {
+    return { listening: true, pid: endpoint.pid, port: endpoint.port };
+  }
+  if (!after.addon) {
+    return {
+      listening: false,
+      mayYetAnnounce: false,
+      note: "this project has no gdharness_runtime addon, so the runtime_* tools have nothing to talk to"
+    };
+  }
+  if (after.heldAt !== null) {
+    return {
+      listening: false,
+      mayYetAnnounce: true,
+      note: "the game stopped before its runtime came up, so the runtime_* tools have nothing to talk to yet: debug_control continue lets it carry on",
+      heldAt: after.heldAt
+    };
+  }
+  return {
+    listening: false,
+    mayYetAnnounce: after.running,
+    note: after.running ? `nothing announced itself within ${after.budgetMs}ms and the game is still running, so it may announce a moment from now: editor_status says whether it has, and editor_run start takes runtimeWaitMs to wait longer than this` : `nothing announced itself within ${after.budgetMs}ms and the game is no longer running, so nothing is going to: editor_output has what it printed on the way down`,
+    heldAt: null
+  };
+}
 function alive(pid) {
   if (pid === undefined || pid === null) {
     return false;
@@ -37128,7 +37242,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),
@@ -37676,18 +37790,21 @@ class GodotServer {
     if (op === "check") {
       return await this.checkBoot(engine.value, project.value.path, sceneArgument, args, given.value);
     }
+    let ended = null;
     if (stillRunning(this.currentRun())) {
       this.logDebug("Ending the running game before starting another");
-      await this.endActiveGame();
+      ended = this.currentRun()?.pid ?? null;
+      await this.endActiveGame("editor_run start, which ends the run that was going before it starts another");
     }
     const alreadyPlaying = new Set(discoverRuntimes().map((endpoint) => endpoint.pid));
     const headless = resolveHeadless(args["headless"], {
       platform: process.platform,
       variables: process.env
     });
+    const runtimeWaitMs = readPositiveNumber(args, "runtimeWaitMs") ?? ANNOUNCE_BUDGET_MS;
     const editorWouldPlay = !headless || editorPlaysHeadless(project.value.file);
     if (this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0) {
-      return await this.playThroughEditor(sceneArgument, refreshed.value, project.value.path, alreadyPlaying);
+      return await this.playThroughEditor(sceneArgument, refreshed.value, project.value.path, alreadyPlaying, runtimeWaitMs, ended);
     }
     const cmdArgs = runArguments({
       projectPath: project.value.path,
@@ -37699,37 +37816,39 @@ class GodotServer {
     const started = this.spawnKeptGame(engine.value, cmdArgs, project.value.path);
     this.activeProcess = started;
     const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && given.value.length > 0 ? " The editor cannot be handed arguments for a game it plays, so this one was started " + "here: the debug_* tools answer only for a game the editor is playing." : "";
+    const endedForThis = ended === null ? "" : ` The run that was going, pid ${ended}, was ended to start this one; its output is no longer what editor_output answers about.`;
     return this.jsonTextResponse({
       started: true,
       through: "gdharness",
       pid: started.process.pid ?? null,
       arguments: cmdArgs,
       refreshedClasses: refreshed.value,
-      runtime: await this.runtimeUp(project.value.path, alreadyPlaying),
-      message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}`
+      endedPreviousRun: ended ?? undefined,
+      runtime: await this.runtimeUp(project.value.path, alreadyPlaying, runtimeWaitMs),
+      message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}${endedForThis}`
     });
   }
-  async runtimeUp(projectPath, before) {
+  async gameIsUp() {
+    const run = this.currentRun();
+    const editorSays = run?.throughEditor === true ? (await this.editorPlayingState())?.playing ?? null : null;
+    return runIsUp(run, editorSays);
+  }
+  async runtimeUp(projectPath, before, budgetMs) {
     if (!existsSync12(join16(projectPath, RUNTIME_AUTOLOAD2.path))) {
-      return {
-        listening: false,
-        note: "this project has no gdharness_runtime addon, so the runtime_* tools have nothing to talk to"
-      };
+      return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false });
     }
     const endpoint = await announcedSince(projectPath, before, {
-      giveUp: () => this.dapClient?.isStopped() === true
+      budgetMs,
+      giveUp: () => this.dapClient?.isStopped() === true || !stillRunning(this.currentRun())
+    });
+    return runtimeVerdict(endpoint, {
+      addon: true,
+      budgetMs,
+      heldAt: this.dapClient?.whereItStopped() ?? null,
+      running: await this.gameIsUp()
     });
-    if (endpoint === null) {
-      const held = this.dapClient?.whereItStopped() ?? null;
-      return {
-        listening: false,
-        note: held === null ? `nothing announced itself within ${ANNOUNCE_BUDGET_MS}ms: the game may be slow to boot, or its runtime is not coming up` : "the game stopped before its runtime came up, so the runtime_* tools have nothing to talk to yet: debug_control continue lets it carry on",
-        heldAt: held
-      };
-    }
-    return { listening: true, pid: endpoint.pid, port: endpoint.port };
   }
-  async playThroughEditor(scene, refreshedClasses, projectPath, alreadyPlaying) {
+  async playThroughEditor(scene, refreshedClasses, projectPath, alreadyPlaying, runtimeWaitMs, ended) {
     const log = new GameLog;
     try {
       await this.dap().connect();
@@ -37762,8 +37881,9 @@ class GodotServer {
       scene: scene === null ? "the main scene" : `res://${scene}`,
       refreshedClasses,
       debugPort: readNumber(asParams(JSON.parse(answer.content[0]?.text ?? "{}")), "debugPort"),
-      runtime: await this.runtimeUp(projectPath, alreadyPlaying),
-      message: "The editor is playing it, so its debugger holds it: the debug_* tools can reach it, " + "editor_output reads its console through the debug adapter, and editor_run stop ends it."
+      endedPreviousRun: ended ?? undefined,
+      runtime: await this.runtimeUp(projectPath, alreadyPlaying, runtimeWaitMs),
+      message: "The editor is playing it, so its debugger holds it: the debug_* tools can reach it, " + "editor_output reads its console through the debug adapter, and editor_run stop ends it." + (ended === null ? "" : ` The run that was going, pid ${ended}, was ended to start this one; its output is no longer what editor_output answers about.`)
     });
   }
   drainEditorOutput(game) {
@@ -37785,13 +37905,15 @@ class GodotServer {
     game.brokeOn = halt.text;
     game.log.record("error", halt.text);
   }
-  async endActiveGame() {
+  async endActiveGame(reason) {
     const running = this.activeProcess;
     this.activeProcess = null;
+    const recorded = running?.process === null ? readRunRecord() : null;
     clearRunRecord((record) => this.couldBeOurs(record.projectPath));
     if (!running) {
       return;
     }
+    running.endedHere = reason;
     if (running.throughEditor) {
       await this.handleViaBridge("stop_playing", {});
       return;
@@ -37800,11 +37922,17 @@ class GodotServer {
       running.process.kill();
       return;
     }
-    if (running.pid !== null) {
-      try {
-        process.kill(running.pid);
-      } catch {}
+    if (running.pid === null) {
+      return;
+    }
+    if (recorded === null || recorded.pid !== running.pid || !stillTheRecordedRun(recorded)) {
+      running.endedHere = null;
+      running.log.record("warning", `This run was not ended here: pid ${running.pid} no longer answers as the run that was recorded, so nothing was signalled. If that process is still the game, end it yourself; if it is not, it belongs to something else.`);
+      return;
     }
+    try {
+      process.kill(running.pid);
+    } catch {}
   }
   spawnGame(godotPath, cmdArgs, env) {
     const child = spawn(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
@@ -37885,7 +38013,8 @@ class GodotServer {
         transcript: transcript.path,
         startedAt,
         projectPath,
-        arguments: cmdArgs
+        arguments: cmdArgs,
+        command: godotPath
       });
     }
     sweepTranscripts();
@@ -37932,7 +38061,7 @@ class GodotServer {
       brokeOn: null
     };
     this.drainTranscript(adopted);
-    if (!alive(record.pid)) {
+    if (!alive(record.pid) || !stillTheRecordedRun(record)) {
       adopted.log.finish();
       adopted.exitCode = null;
       adopted.endedUnwatched = true;
@@ -37940,13 +38069,24 @@ class GodotServer {
     this.activeProcess = adopted;
     return adopted;
   }
-  couldBeOurs(project) {
-    if (project === "") {
-      return true;
+  nothingOfOursIsRunning() {
+    const record = readRunRecord();
+    if (record === null) {
+      return "No game is running. Start one with editor_run.";
     }
     const status = this.godotBridge.getStatus();
     const mine = this.ownProject ?? (status.connected ? status.projectPath ?? null : null);
-    return mine === null || samePath(mine, project);
+    const whose = record.projectPath === "" ? "a project it does not name" : record.projectPath;
+    const ours = mine === null ? "this server was started without GDHARNESS_PROJECT and has no editor connected, so it cannot say whose that run is" : `this server serves ${mine}`;
+    return `No game of this server's is running. A run started from ${whose} is recorded on this machine, and ${ours}, so it is not this server's to answer for or to end. Start one with editor_run.`;
+  }
+  couldBeOurs(project) {
+    const status = this.godotBridge.getStatus();
+    const mine = this.ownProject ?? (status.connected ? status.projectPath ?? null : null);
+    if (mine === null) {
+      return false;
+    }
+    return project !== "" && samePath(mine, project);
   }
   currentRun() {
     return this.activeProcess ?? this.adoptRecordedRun();
@@ -37986,7 +38126,7 @@ class GodotServer {
   handleGetDebugOutput(args) {
     const run = this.currentRun();
     if (!run) {
-      return this.createErrorResponse("No game is running. Start one with editor_run.");
+      return this.createErrorResponse(this.nothingOfOursIsRunning());
     }
     this.drainEditorOutput(run);
     this.drainTranscript(run);
@@ -38006,8 +38146,13 @@ class GodotServer {
     if (run.endedUnwatched === true) {
       notes.push("This run outlived the server that started it and is over now, so its exit code was never collected. Everything it printed is below, read back from its transcript.");
     }
+    if (typeof run.endedHere === "string") {
+      notes.push(`This run was ended here, by ${run.endedHere}.`);
+    } else if (!stillRunning(run) && !run.throughEditor && run.exitCode !== null) {
+      notes.push("Nothing here ended this run: it stopped on its own or something outside this server stopped it.");
+    }
     if (run.transcript !== null && selected.omitted > 0) {
-      notes.push(`Everything this run has printed is in ${run.transcript}, uncapped and still being written.`);
+      notes.push(`Everything this run has printed is in ${run.transcript}, uncapped and still being written. Read it for output, not for whether the run is alive: running above is asked of the operating system, and a transcript that stops growing is a run between prints.`);
     }
     return this.jsonTextResponse({
       running: stillRunning(run),
@@ -38019,6 +38164,7 @@ class GodotServer {
       clean: run.log.count("error") === 0,
       heldAt: halt,
       endedUnwatched: run.endedUnwatched === true ? true : undefined,
+      endedBy: stillRunning(run) ? undefined : run.endedHere ?? null,
       project: !run.throughEditor && run.process === null ? run.projectPath ?? undefined : undefined,
       transcript: run.transcript ?? undefined,
       note: notes.length > 0 ? notes.join(" ") : undefined,
@@ -38029,12 +38175,12 @@ class GodotServer {
   async handleStopProject() {
     const stopped = this.currentRun();
     if (!stopped) {
-      return this.createErrorResponse("No game is running. Start one with editor_run.");
+      return this.createErrorResponse(this.nothingOfOursIsRunning());
     }
     this.drainEditorOutput(stopped);
     this.drainTranscript(stopped);
     this.logDebug("Stopping the running game");
-    await this.endActiveGame();
+    await this.endActiveGame("editor_run stop");
     return this.jsonTextResponse({
       stopped: true,
       through: stopped.throughEditor ? "editor" : "gdharness",
@@ -39678,10 +39824,15 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
   \`addonIsStale\` means they differ, and \`staleNote\` says which half is behind: an editor that
   needs restarting, or a server that needs reconnecting in your harness.
 - Start the game with \`editor_run start\`, never by spawning an engine. The editor plays it, so
-  its debugger holds it, which is what gives the \`debug_*\` tools something to talk to.
+  its debugger holds it, which is what gives the \`debug_*\` tools something to talk to. Its answer
+  says under \`runtime\` whether the game can be talked to yet; when it cannot, \`mayYetAnnounce\`
+  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.
+  from being known. 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. \`running\` is asked of the operating system and \`endedBy\` says whether
+  gdharness ended it; a bench between prints looks exactly like a bench that died to everything else.
 - One server, one editor. A second project is a second harness session with its own server, and
   that works: each editor is opened on its own language server and debug adapter ports, and says
   where it serves. Two editors on one project is the thing to refuse.

package/build/index.js

@@ -10140,7 +10140,7 @@ import {
   rmSync as rmSync5
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename, dirname as dirname4, join as join10, normalize as normalize2 } from "node:path";
+import { basename as basename2, dirname as dirname4, join as join10, normalize as normalize2 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { promisify as promisify3 } from "node:util";
@@ -27493,8 +27493,9 @@ function setupResourceHandlers(mcp, getProjectPath) {
 }
 
 // src/run-record.ts
+import { execFileSync } from "node:child_process";
 import { mkdirSync as mkdirSync3, openSync, readdirSync as readdirSync5, readFileSync as readFileSync8, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join8 } from "node:path";
+import { basename, join as join8 } from "node:path";
 
 // src/runtime-client.ts
 import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync7, unlinkSync } from "node:fs";
@@ -27842,9 +27843,75 @@ function recordAt(path) {
     transcript,
     startedAt,
     projectPath: typeof fields["projectPath"] === "string" ? fields["projectPath"] : "",
-    arguments: Array.isArray(args) ? args.filter((value) => typeof value === "string") : []
+    arguments: Array.isArray(args) ? args.filter((value) => typeof value === "string") : [],
+    ...typeof fields["command"] === "string" ? { command: fields["command"] } : {}
   };
 }
+function runningAs(pid) {
+  if (process.platform === "win32") {
+    const line = windowsCommandLine(pid);
+    if (line !== null) {
+      return { kind: "commandLine", text: line };
+    }
+    const image = windowsImage(pid);
+    return image === null ? null : { kind: "image", text: image };
+  }
+  try {
+    if (process.platform === "linux") {
+      const raw = readFileSync8(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      return raw === "" ? null : { kind: "commandLine", text: raw };
+    }
+    const args = execFileSync("ps", ["-p", String(pid), "-o", "args="], {
+      encoding: "utf8",
+      timeout: 15000
+    }).trim();
+    return args === "" ? null : { kind: "commandLine", text: args };
+  } catch {
+    return null;
+  }
+}
+function windowsCommandLine(pid) {
+  try {
+    const answer = execFileSync("powershell", [
+      "-NoProfile",
+      "-NonInteractive",
+      "-Command",
+      `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").CommandLine`
+    ], { encoding: "utf8", timeout: 15000, windowsHide: true }).trim();
+    return answer === "" ? null : answer;
+  } catch {
+    return null;
+  }
+}
+function windowsImage(pid) {
+  try {
+    const csv = execFileSync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
+      encoding: "utf8",
+      timeout: 15000,
+      windowsHide: true
+    });
+    return /^"([^"]+)"/.exec(csv.trim())?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+function stillTheRecordedRun(record) {
+  const running = runningAs(record.pid);
+  if (running === null) {
+    return false;
+  }
+  const engine = record.command === undefined ? null : basename(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)) {
+    return false;
+  }
+  if (running.kind === "image" || record.projectPath === "") {
+    return wanted !== null;
+  }
+  const project = process.platform === "win32" ? record.projectPath.toLowerCase() : record.projectPath;
+  return said.includes(project);
+}
 function clearRunRecord(ours = () => true) {
   for (const path of recordPaths()) {
     const record = recordAt(path);
@@ -28492,19 +28559,34 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_run",
-    description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. args hands the game its own flags, the ones it reads with OS.get_cmdline_user_args(), and a run carrying any is started by this server rather than by the editor. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice.",
+    description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. args hands the game its own flags, the ones it reads with OS.get_cmdline_user_args(), and a run carrying any is started by this server rather than by the editor. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice. When it is not listening, mayYetAnnounce says whether that is final: false is a runtime that is not coming, true is a game still on its way up, which editor_status will see and runtimeWaitMs waits longer for.",
     parameters: {
       projectPath: PROJECT_PATH,
-      scene: { type: "string", description: "A scene to run instead of the main scene." },
+      scene: {
+        type: "string",
+        ops: ["start", "check"],
+        description: "A scene to run instead of the main scene."
+      },
       args: {
         type: "array",
         items: { type: "string" },
+        ops: ["start", "check"],
         description: `The game's own arguments, what OS.get_cmdline_user_args() answers, such as ["--level=2"]. The separator is added here. A run with any is started by this server rather than by the editor, which fixes the game's command line when it opens the project, so the debug_* tools do not answer for it.`
       },
-      headless: { type: "boolean", description: "start: force a window or no window." },
-      frames: { type: "number", description: "check: frames to run before quitting. Default 3." },
+      headless: { type: "boolean", ops: ["start"], description: "start: force a window or no window." },
+      runtimeWaitMs: {
+        type: "number",
+        ops: ["start"],
+        description: "start: how long to wait for the game to announce its runtime before answering. Default 5000. Worth raising for a project that takes longer than that to reach its first frame, which is what leaves runtime listening false on a game whose runtime arrives a moment later."
+      },
+      frames: {
+        type: "number",
+        ops: ["check"],
+        description: "check: frames to run before quitting. Default 3."
+      },
       timeoutMs: {
         type: "number",
+        ops: ["check"],
         description: "check: how long to give the boot before it is called hung. Default 60000."
       }
     },
@@ -28518,7 +28600,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. 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.",
+    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. 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: running is asked of the operating system, 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.",
     parameters: {
       severity: {
         type: "string",
@@ -28970,6 +29052,38 @@ function stillRunning(run) {
   }
   return true;
 }
+function runIsUp(run, editorSays) {
+  if (run?.throughEditor !== true) {
+    return stillRunning(run);
+  }
+  return editorSays ?? stillRunning(run);
+}
+function runtimeVerdict(endpoint, after) {
+  if (endpoint !== null) {
+    return { listening: true, pid: endpoint.pid, port: endpoint.port };
+  }
+  if (!after.addon) {
+    return {
+      listening: false,
+      mayYetAnnounce: false,
+      note: "this project has no gdharness_runtime addon, so the runtime_* tools have nothing to talk to"
+    };
+  }
+  if (after.heldAt !== null) {
+    return {
+      listening: false,
+      mayYetAnnounce: true,
+      note: "the game stopped before its runtime came up, so the runtime_* tools have nothing to talk to yet: debug_control continue lets it carry on",
+      heldAt: after.heldAt
+    };
+  }
+  return {
+    listening: false,
+    mayYetAnnounce: after.running,
+    note: after.running ? `nothing announced itself within ${after.budgetMs}ms and the game is still running, so it may announce a moment from now: editor_status says whether it has, and editor_run start takes runtimeWaitMs to wait longer than this` : `nothing announced itself within ${after.budgetMs}ms and the game is no longer running, so nothing is going to: editor_output has what it printed on the way down`,
+    heldAt: null
+  };
+}
 function alive(pid) {
   if (pid === undefined || pid === null) {
     return false;
@@ -29910,7 +30024,7 @@ class GodotServer {
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
-      name: typeof name === "string" && name !== "" ? name : basename(project.value.path),
+      name: typeof name === "string" && name !== "" ? name : basename2(project.value.path),
       path: project.value.path,
       mainScene: typeof mainScene === "string" && mainScene !== "" ? mainScene : null,
       godotVersion: await this.godotVersion(engine.value),
@@ -30458,18 +30572,21 @@ class GodotServer {
     if (op === "check") {
       return await this.checkBoot(engine.value, project.value.path, sceneArgument, args, given.value);
     }
+    let ended = null;
     if (stillRunning(this.currentRun())) {
       this.logDebug("Ending the running game before starting another");
-      await this.endActiveGame();
+      ended = this.currentRun()?.pid ?? null;
+      await this.endActiveGame("editor_run start, which ends the run that was going before it starts another");
     }
     const alreadyPlaying = new Set(discoverRuntimes().map((endpoint) => endpoint.pid));
     const headless = resolveHeadless(args["headless"], {
       platform: process.platform,
       variables: process.env
     });
+    const runtimeWaitMs = readPositiveNumber(args, "runtimeWaitMs") ?? ANNOUNCE_BUDGET_MS;
     const editorWouldPlay = !headless || editorPlaysHeadless(project.value.file);
     if (this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0) {
-      return await this.playThroughEditor(sceneArgument, refreshed.value, project.value.path, alreadyPlaying);
+      return await this.playThroughEditor(sceneArgument, refreshed.value, project.value.path, alreadyPlaying, runtimeWaitMs, ended);
     }
     const cmdArgs = runArguments({
       projectPath: project.value.path,
@@ -30481,37 +30598,39 @@ class GodotServer {
     const started = this.spawnKeptGame(engine.value, cmdArgs, project.value.path);
     this.activeProcess = started;
     const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && given.value.length > 0 ? " The editor cannot be handed arguments for a game it plays, so this one was started " + "here: the debug_* tools answer only for a game the editor is playing." : "";
+    const endedForThis = ended === null ? "" : ` The run that was going, pid ${ended}, was ended to start this one; its output is no longer what editor_output answers about.`;
     return this.jsonTextResponse({
       started: true,
       through: "gdharness",
       pid: started.process.pid ?? null,
       arguments: cmdArgs,
       refreshedClasses: refreshed.value,
-      runtime: await this.runtimeUp(project.value.path, alreadyPlaying),
-      message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}`
+      endedPreviousRun: ended ?? undefined,
+      runtime: await this.runtimeUp(project.value.path, alreadyPlaying, runtimeWaitMs),
+      message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}${endedForThis}`
     });
   }
-  async runtimeUp(projectPath, before) {
+  async gameIsUp() {
+    const run = this.currentRun();
+    const editorSays = run?.throughEditor === true ? (await this.editorPlayingState())?.playing ?? null : null;
+    return runIsUp(run, editorSays);
+  }
+  async runtimeUp(projectPath, before, budgetMs) {
     if (!existsSync7(join10(projectPath, RUNTIME_AUTOLOAD.path))) {
-      return {
-        listening: false,
-        note: "this project has no gdharness_runtime addon, so the runtime_* tools have nothing to talk to"
-      };
+      return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false });
     }
     const endpoint = await announcedSince(projectPath, before, {
-      giveUp: () => this.dapClient?.isStopped() === true
+      budgetMs,
+      giveUp: () => this.dapClient?.isStopped() === true || !stillRunning(this.currentRun())
+    });
+    return runtimeVerdict(endpoint, {
+      addon: true,
+      budgetMs,
+      heldAt: this.dapClient?.whereItStopped() ?? null,
+      running: await this.gameIsUp()
     });
-    if (endpoint === null) {
-      const held = this.dapClient?.whereItStopped() ?? null;
-      return {
-        listening: false,
-        note: held === null ? `nothing announced itself within ${ANNOUNCE_BUDGET_MS}ms: the game may be slow to boot, or its runtime is not coming up` : "the game stopped before its runtime came up, so the runtime_* tools have nothing to talk to yet: debug_control continue lets it carry on",
-        heldAt: held
-      };
-    }
-    return { listening: true, pid: endpoint.pid, port: endpoint.port };
   }
-  async playThroughEditor(scene, refreshedClasses, projectPath, alreadyPlaying) {
+  async playThroughEditor(scene, refreshedClasses, projectPath, alreadyPlaying, runtimeWaitMs, ended) {
     const log = new GameLog;
     try {
       await this.dap().connect();
@@ -30544,8 +30663,9 @@ class GodotServer {
       scene: scene === null ? "the main scene" : `res://${scene}`,
       refreshedClasses,
       debugPort: readNumber(asParams(JSON.parse(answer.content[0]?.text ?? "{}")), "debugPort"),
-      runtime: await this.runtimeUp(projectPath, alreadyPlaying),
-      message: "The editor is playing it, so its debugger holds it: the debug_* tools can reach it, " + "editor_output reads its console through the debug adapter, and editor_run stop ends it."
+      endedPreviousRun: ended ?? undefined,
+      runtime: await this.runtimeUp(projectPath, alreadyPlaying, runtimeWaitMs),
+      message: "The editor is playing it, so its debugger holds it: the debug_* tools can reach it, " + "editor_output reads its console through the debug adapter, and editor_run stop ends it." + (ended === null ? "" : ` The run that was going, pid ${ended}, was ended to start this one; its output is no longer what editor_output answers about.`)
     });
   }
   drainEditorOutput(game) {
@@ -30567,13 +30687,15 @@ class GodotServer {
     game.brokeOn = halt.text;
     game.log.record("error", halt.text);
   }
-  async endActiveGame() {
+  async endActiveGame(reason) {
     const running = this.activeProcess;
     this.activeProcess = null;
+    const recorded = running?.process === null ? readRunRecord() : null;
     clearRunRecord((record) => this.couldBeOurs(record.projectPath));
     if (!running) {
       return;
     }
+    running.endedHere = reason;
     if (running.throughEditor) {
       await this.handleViaBridge("stop_playing", {});
       return;
@@ -30582,11 +30704,17 @@ class GodotServer {
       running.process.kill();
       return;
     }
-    if (running.pid !== null) {
-      try {
-        process.kill(running.pid);
-      } catch {}
+    if (running.pid === null) {
+      return;
+    }
+    if (recorded === null || recorded.pid !== running.pid || !stillTheRecordedRun(recorded)) {
+      running.endedHere = null;
+      running.log.record("warning", `This run was not ended here: pid ${running.pid} no longer answers as the run that was recorded, so nothing was signalled. If that process is still the game, end it yourself; if it is not, it belongs to something else.`);
+      return;
     }
+    try {
+      process.kill(running.pid);
+    } catch {}
   }
   spawnGame(godotPath, cmdArgs, env) {
     const child = spawn(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
@@ -30667,7 +30795,8 @@ class GodotServer {
         transcript: transcript.path,
         startedAt,
         projectPath,
-        arguments: cmdArgs
+        arguments: cmdArgs,
+        command: godotPath
       });
     }
     sweepTranscripts();
@@ -30714,7 +30843,7 @@ class GodotServer {
       brokeOn: null
     };
     this.drainTranscript(adopted);
-    if (!alive(record.pid)) {
+    if (!alive(record.pid) || !stillTheRecordedRun(record)) {
       adopted.log.finish();
       adopted.exitCode = null;
       adopted.endedUnwatched = true;
@@ -30722,13 +30851,24 @@ class GodotServer {
     this.activeProcess = adopted;
     return adopted;
   }
-  couldBeOurs(project) {
-    if (project === "") {
-      return true;
+  nothingOfOursIsRunning() {
+    const record = readRunRecord();
+    if (record === null) {
+      return "No game is running. Start one with editor_run.";
     }
     const status = this.godotBridge.getStatus();
     const mine = this.ownProject ?? (status.connected ? status.projectPath ?? null : null);
-    return mine === null || samePath(mine, project);
+    const whose = record.projectPath === "" ? "a project it does not name" : record.projectPath;
+    const ours = mine === null ? "this server was started without GDHARNESS_PROJECT and has no editor connected, so it cannot say whose that run is" : `this server serves ${mine}`;
+    return `No game of this server's is running. A run started from ${whose} is recorded on this machine, and ${ours}, so it is not this server's to answer for or to end. Start one with editor_run.`;
+  }
+  couldBeOurs(project) {
+    const status = this.godotBridge.getStatus();
+    const mine = this.ownProject ?? (status.connected ? status.projectPath ?? null : null);
+    if (mine === null) {
+      return false;
+    }
+    return project !== "" && samePath(mine, project);
   }
   currentRun() {
     return this.activeProcess ?? this.adoptRecordedRun();
@@ -30768,7 +30908,7 @@ class GodotServer {
   handleGetDebugOutput(args) {
     const run = this.currentRun();
     if (!run) {
-      return this.createErrorResponse("No game is running. Start one with editor_run.");
+      return this.createErrorResponse(this.nothingOfOursIsRunning());
     }
     this.drainEditorOutput(run);
     this.drainTranscript(run);
@@ -30788,8 +30928,13 @@ class GodotServer {
     if (run.endedUnwatched === true) {
       notes.push("This run outlived the server that started it and is over now, so its exit code was never collected. Everything it printed is below, read back from its transcript.");
     }
+    if (typeof run.endedHere === "string") {
+      notes.push(`This run was ended here, by ${run.endedHere}.`);
+    } else if (!stillRunning(run) && !run.throughEditor && run.exitCode !== null) {
+      notes.push("Nothing here ended this run: it stopped on its own or something outside this server stopped it.");
+    }
     if (run.transcript !== null && selected.omitted > 0) {
-      notes.push(`Everything this run has printed is in ${run.transcript}, uncapped and still being written.`);
+      notes.push(`Everything this run has printed is in ${run.transcript}, uncapped and still being written. Read it for output, not for whether the run is alive: running above is asked of the operating system, and a transcript that stops growing is a run between prints.`);
     }
     return this.jsonTextResponse({
       running: stillRunning(run),
@@ -30801,6 +30946,7 @@ class GodotServer {
       clean: run.log.count("error") === 0,
       heldAt: halt,
       endedUnwatched: run.endedUnwatched === true ? true : undefined,
+      endedBy: stillRunning(run) ? undefined : run.endedHere ?? null,
       project: !run.throughEditor && run.process === null ? run.projectPath ?? undefined : undefined,
       transcript: run.transcript ?? undefined,
       note: notes.length > 0 ? notes.join(" ") : undefined,
@@ -30811,12 +30957,12 @@ class GodotServer {
   async handleStopProject() {
     const stopped = this.currentRun();
     if (!stopped) {
-      return this.createErrorResponse("No game is running. Start one with editor_run.");
+      return this.createErrorResponse(this.nothingOfOursIsRunning());
     }
     this.drainEditorOutput(stopped);
     this.drainTranscript(stopped);
     this.logDebug("Stopping the running game");
-    await this.endActiveGame();
+    await this.endActiveGame("editor_run stop");
     return this.jsonTextResponse({
       stopped: true,
       through: stopped.throughEditor ? "editor" : "gdharness",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "0.12.3",
+  "version": "0.12.5",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",