gdharness 0.13.34 → 0.13.36

package/build/cli.js

@@ -15994,7 +15994,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. 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.",
+      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: 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",
@@ -16022,7 +16022,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_status",
-      description: 'Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means "not reached yet" as often as it means "no editor". True is worth waiting out; false is an editor that is not there. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer.',
+      description: 'Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means "not reached yet" as often as it means "no editor". True is worth waiting out; false is an editor that is not there. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it.',
       parameters: {},
       requires: []
     },
@@ -36662,23 +36662,32 @@ function recordAt(path) {
 }
 function runningAs(pid) {
   if (process.platform === "win32") {
-    const line = windowsCommandLine(pid);
-    if (line !== null) {
-      return { kind: "commandLine", text: line };
+    const answer = windowsCommandLine(pid);
+    if (answer !== null) {
+      const [, ...rest] = answer.split(`
+`);
+      const line = rest.join(`
+`).trim();
+      const began = startedAt(pid, answer);
+      if (line !== "") {
+        return { kind: "commandLine", text: line, ...began === null ? {} : { startedAt: began } };
+      }
     }
     const image = windowsImage(pid);
     return image === null ? null : { kind: "image", text: image };
   }
   try {
+    const began = startedAt(pid, null);
+    const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
       const raw = readFileSync14(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
-      return raw === "" ? null : { kind: "commandLine", text: raw };
+      return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = execFileSync("ps", ["-p", String(pid), "-o", "args="], {
       encoding: "utf8",
       timeout: 15000
     }).trim();
-    return args === "" ? null : { kind: "commandLine", text: args };
+    return args === "" ? null : { kind: "commandLine", text: args, ...when };
   } catch {
     return null;
   }
@@ -36717,13 +36726,30 @@ function windowsCommandLine(pid) {
       "-NoProfile",
       "-NonInteractive",
       "-Command",
-      `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").CommandLine`
+      `$p = Get-CimInstance Win32_Process -Filter "ProcessId=${pid}"; if ($p) { $p.CreationDate.ToUniversalTime().ToString("o"); $p.CommandLine }`
     ], { encoding: "utf8", timeout: 15000, windowsHide: true }).trim();
     return answer === "" ? null : answer;
   } catch {
     return null;
   }
 }
+function startedAt(pid, windowsAnswer) {
+  if (process.platform === "win32") {
+    const when = Date.parse(windowsAnswer?.split(`
+`)[0]?.trim() ?? "");
+    return Number.isNaN(when) ? null : when;
+  }
+  try {
+    const said = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+      encoding: "utf8",
+      timeout: 15000
+    }).trim();
+    const when = Date.parse(said);
+    return said === "" || Number.isNaN(when) ? null : when;
+  } catch {
+    return null;
+  }
+}
 function windowsImage(pid) {
   try {
     const csv = execFileSync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
@@ -36746,12 +36772,18 @@ function judgeRun(record, running, needed) {
   if (running === null) {
     return false;
   }
+  if (running.startedAt !== undefined && running.startedAt - record.startedAt > SAME_RUN_WINDOW_MS) {
+    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 === "commandLine" && AN_EDITOR.test(said)) {
+    return false;
+  }
   if (record.projectPath === "") {
     return wanted !== null;
   }
@@ -36801,8 +36833,10 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     } catch {}
   }
 }
+var AN_EDITOR, SAME_RUN_WINDOW_MS = 1e4;
 var init_run_record = __esm(() => {
   init_runtime_client();
+  AN_EDITOR = /(?:^|\s)(?:-e|--editor)(?:\s|$)/;
 });
 
 // src/server.ts
@@ -36835,12 +36869,18 @@ function stillRunning(run) {
   if (!run.throughEditor && run.process === null && run.pid !== null) {
     return alive(run.pid);
   }
+  if (run.announcedPid !== undefined && !alive(run.announcedPid)) {
+    return false;
+  }
   return true;
 }
 function runIsUp(run, editorSays) {
   if (run?.throughEditor !== true) {
     return stillRunning(run);
   }
+  if (run.announcedPid !== undefined && !alive(run.announcedPid)) {
+    return false;
+  }
   return editorSays ?? stillRunning(run);
 }
 function runtimeVerdict(endpoint, after) {
@@ -38229,7 +38269,10 @@ class GodotServer {
     return `The debug adapter on port ${port} belongs to process ${holder}, and the editor on this server's bridge is process ${ours}. Godot gives every editor the same debug adapter port by default, so the one this editor names in its settings is not necessarily the one it holds. Playing the game now would put another editor's console and another project's debugger under this project's name.`;
   }
   anEditorIsStillComing(listeningSince) {
-    return anEditorIsStillComing(listeningSince, this.launchedEditor !== null && alive(this.launchedEditor));
+    return anEditorIsStillComing(listeningSince, this.launchedEditorIsUp());
+  }
+  launchedEditorIsUp() {
+    return this.launchedEditor?.exitCode === null && this.launchedEditor.signalCode === null;
   }
   dap() {
     const port = this.editorServes("dapPort", "GDHARNESS_DAP_PORT", DEFAULT_DAP_PORT);
@@ -38275,7 +38318,7 @@ class GodotServer {
       addonIsStale: status.connected ? stale : undefined,
       bridgeAvailable: this.bridgeStartupError === null,
       mayYetConnect: status.connected ? undefined : this.anEditorIsStillComing(status.listeningSince),
-      awaitingLaunchedEditor: status.connected || this.launchedEditor === null || !alive(this.launchedEditor) ? undefined : this.launchedEditor,
+      awaitingLaunchedEditor: status.connected || !this.launchedEditorIsUp() ? undefined : this.launchedEditor?.pid ?? undefined,
       ...status.connected ? this.whatTheLaunchedEditorDropped() : {},
       startupError: this.bridgeStartupError,
       staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION) : undefined,
@@ -38311,7 +38354,8 @@ class GodotServer {
   }
   async handleEditorStatus() {
     const godotPath = await this.locator.find();
-    const games = await Promise.all(discoverRuntimes().map(async (endpoint) => {
+    const announced = runtimesAnnounced();
+    const games = await Promise.all(announced.running.map(async (endpoint) => {
       const reply = await runtimeRequest(endpoint, "ping", {}, this.runtimeTimeoutMs());
       return {
         pid: endpoint.pid,
@@ -38333,10 +38377,17 @@ class GodotServer {
         version: godotPath === null ? null : await this.godotVersion(godotPath)
       },
       game: {
-        processActive: stillRunning(this.currentRun()),
+        processActive: runIsUp(this.currentRun(), playing === null ? null : playing.playing),
         playingInEditor: playing,
         runtimeConnected: games.some((game) => game.reachable),
-        runtimes: games
+        runtimes: games,
+        unreadable: announced.unspoken.map((game) => ({
+          pid: game.pid,
+          project: game.project,
+          protocol: game.protocol,
+          serverSpeaks: RUNTIME_PROTOCOL,
+          behind: game.protocol > RUNTIME_PROTOCOL ? "server" : "addon"
+        }))
       }
     });
   }
@@ -38486,7 +38537,7 @@ class GodotServer {
       return { pid: null, error: started };
     }
     editor.unref();
-    this.launchedEditor = editor.pid ?? null;
+    this.launchedEditor = editor.pid === undefined ? null : editor;
     return { pid: editor.pid ?? null, error: null };
   }
   async portsForAnEditor() {
@@ -38533,6 +38584,7 @@ class GodotServer {
       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 wereHereFirst = this.everyRuntimeOfOurs();
     const headless = resolveHeadless(args["headless"], {
       platform: process.platform,
       variables: process.env
@@ -38553,16 +38605,20 @@ class GodotServer {
     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.`;
+    const stranded = wereHereFirst.filter((one) => one.pid !== ended && alive(one.pid));
+    const named = stranded.map((one) => one.protocol === null ? `pid ${one.pid}` : `pid ${one.pid} on protocol ${one.protocol}`).join(", ");
+    const alsoRunning = stranded.length === 0 ? "" : ` A game of this project was already running and still is: ${named}. Starting this one did not end it and nothing here can, because this server did not start it. End it yourself, or bring the halves to one version where a protocol is named.`;
     return this.jsonTextResponse({
       started: true,
       through: "gdharness",
+      alsoRunning: stranded.length === 0 ? undefined : stranded.map((one) => one.pid),
       pid: started.process.pid ?? null,
       arguments: cmdArgs,
       transcript: started.transcript,
       refreshedClasses: refreshed.value,
       endedPreviousRun: ended ?? undefined,
       runtime: await this.runtimeUp(project.value.path, alreadyPlaying, runtimeWaitMs, given.value.length > 0),
-      message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}${endedForThis}`
+      message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}${endedForThis}${alsoRunning}`
     });
   }
   async gameIsUp() {
@@ -38578,6 +38634,10 @@ class GodotServer {
       budgetMs,
       giveUp: () => this.dapClient?.isStopped() === true || !stillRunning(this.currentRun())
     });
+    const going = this.currentRun();
+    if (endpoint !== null && going?.throughEditor === true && going.announcedPid === undefined) {
+      going.announcedPid = endpoint.pid;
+    }
     return runtimeVerdict(endpoint, {
       addon: true,
       budgetMs,
@@ -38687,9 +38747,15 @@ class GodotServer {
       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;
     }
+    const signalled = runningAs(running.pid);
+    const described = signalled === null ? "nothing it would name" : `${signalled.kind}: ${signalled.text}`;
+    let landed = true;
     try {
       process.kill(running.pid);
-    } catch {}
+    } catch {
+      landed = false;
+    }
+    running.log.record("info", landed ? `gdharness ended pid ${running.pid}, which the operating system described as ${described}.` : `gdharness signalled pid ${running.pid} and it was already gone; the operating system had described it as ${described}.`);
   }
   spawnGame(godotPath, cmdArgs, env) {
     const child = spawn(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
@@ -38878,7 +38944,12 @@ class GodotServer {
     const noEditor = !status.connected ? " No editor is connected, so a game the editor is playing cannot be seen from here at all:" + " editor_status says whether one is on its way, and a run of yours that is still up is" + " reachable again once it is." : "";
     const live = this.aRuntimeOfOursIsAnswering();
     if (live !== null) {
-      return `A game is running for ${live.project.path} and has announced its runtime on port ${live.port}, pid ${live.pid},` + " but this server did not start it and cannot reach it through the editor, so editor_run and" + " editor_output have nothing to answer about. The runtime_* tools reach it now." + " Do not start another: editor_run start replaces the game that is playing rather than" + " adding one, so it would end this one." + (this.godotBridge.getStatus().connected ? "" : " editor_status says whether an editor is on its way, and editor_run can end it once one is.");
+      return `A game is running for ${live.project.path} and has announced its runtime on port ${live.port}, pid ${live.pid},` + " but this server did not start it and cannot reach it through the editor, so editor_run and" + " editor_output have nothing to answer about. The runtime_* tools reach it now." + " A run started here is a separate process rather than a replacement, so starting one leaves" + " this game running as well." + (this.godotBridge.getStatus().connected ? "" : " editor_status says whether an editor is on its way, and editor_run can end it once one is.");
+    }
+    const unreadable = this.aRuntimeOfOursIsTooFarOff();
+    if (unreadable !== null) {
+      const behind = unreadable.protocol > RUNTIME_PROTOCOL ? "this server is the older half: reconnect it so it spawns the installed version" : "the addon is the older half: reinstall it and restart the game";
+      return `A game is running for ${unreadable.project.path}, pid ${unreadable.pid}, announced in protocol` + ` ${unreadable.protocol}, which this server does not speak: it speaks ${RUNTIME_PROTOCOL}, so ${behind}.` + " Until then neither editor_run nor the runtime_* tools can reach it." + " A run started here is a separate process rather than a replacement, so starting one leaves" + " this game running as well.";
     }
     const record = readRunRecord();
     if (record === null) {
@@ -38890,12 +38961,34 @@ class GodotServer {
     return `No game of this server's is running.${noEditor} 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.`;
   }
   aRuntimeOfOursIsAnswering() {
+    return this.announcedForOurProject(discoverRuntimes());
+  }
+  aRuntimeOfOursIsTooFarOff() {
+    return this.announcedForOurProject(runtimesAnnounced().unspoken);
+  }
+  announcedForOurProject(announced) {
+    return this.allAnnouncedForOurProject(announced)[0] ?? null;
+  }
+  allAnnouncedForOurProject(announced) {
     const status = this.godotBridge.getStatus();
     const mine = this.ownProject ?? (status.connected ? status.projectPath ?? null : null);
     if (mine === null) {
-      return null;
+      return [];
     }
-    return discoverRuntimes().find((one) => one.project.path !== "" && isSameDirectory(mine, one.project.path)) ?? null;
+    return announced.filter((one) => one.project.path !== "" && isSameDirectory(mine, one.project.path));
+  }
+  everyRuntimeOfOurs() {
+    const announced = runtimesAnnounced();
+    return [
+      ...this.allAnnouncedForOurProject(announced.running).map((one) => ({
+        pid: one.pid,
+        protocol: null
+      })),
+      ...this.allAnnouncedForOurProject(announced.unspoken).map((one) => ({
+        pid: one.pid,
+        protocol: one.protocol
+      }))
+    ];
   }
   couldBeOurs(project) {
     const status = this.godotBridge.getStatus();
@@ -39000,7 +39093,7 @@ class GodotServer {
       notes.push(run.exitCode === 0 ? "This run quit on its own, cleanly: exit code 0." : "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. 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.`);
+      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: a transcript that stops growing is a run between prints. running above is asked of the operating system while there is a process to ask about, and for an editor-played run that announced no runtime it is the editor's answer instead, which can lag after the game has gone.`);
     }
     return this.jsonTextResponse({
       running: stillRunning(run),
@@ -40796,8 +40889,13 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
   with their backtraces, and a \`clean\` verdict, so a run that printed an error is one call away
   from being known. For a long run it also names a transcript file: read that for output and this
   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.
+  list, or a timeout; a bench between prints looks exactly like a bench that died to everything else.
+  \`endedBy\` says whether gdharness ended it, and \`running\` is asked of the operating system
+  whenever there is a process to ask about: every run started through \`editor_run\`, and every
+  editor-played run whose game announced its runtime. An editor-played run in a project with no
+  runtime addon announces nothing, so there is no process id and \`running\` is the editor's answer,
+  which can lag by seconds after the game has gone. \`editor_status\` names the game under
+  \`runtimes\`, which does not depend on the editor answering.
 - 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

@@ -28256,23 +28256,32 @@ function recordAt(path) {
 }
 function runningAs(pid) {
   if (process.platform === "win32") {
-    const line = windowsCommandLine(pid);
-    if (line !== null) {
-      return { kind: "commandLine", text: line };
+    const answer = windowsCommandLine(pid);
+    if (answer !== null) {
+      const [, ...rest] = answer.split(`
+`);
+      const line = rest.join(`
+`).trim();
+      const began = startedAt(pid, answer);
+      if (line !== "") {
+        return { kind: "commandLine", text: line, ...began === null ? {} : { startedAt: began } };
+      }
     }
     const image = windowsImage(pid);
     return image === null ? null : { kind: "image", text: image };
   }
   try {
+    const began = startedAt(pid, null);
+    const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
       const raw = readFileSync9(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
-      return raw === "" ? null : { kind: "commandLine", text: raw };
+      return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = execFileSync("ps", ["-p", String(pid), "-o", "args="], {
       encoding: "utf8",
       timeout: 15000
     }).trim();
-    return args === "" ? null : { kind: "commandLine", text: args };
+    return args === "" ? null : { kind: "commandLine", text: args, ...when };
   } catch {
     return null;
   }
@@ -28311,13 +28320,30 @@ function windowsCommandLine(pid) {
       "-NoProfile",
       "-NonInteractive",
       "-Command",
-      `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").CommandLine`
+      `$p = Get-CimInstance Win32_Process -Filter "ProcessId=${pid}"; if ($p) { $p.CreationDate.ToUniversalTime().ToString("o"); $p.CommandLine }`
     ], { encoding: "utf8", timeout: 15000, windowsHide: true }).trim();
     return answer === "" ? null : answer;
   } catch {
     return null;
   }
 }
+function startedAt(pid, windowsAnswer) {
+  if (process.platform === "win32") {
+    const when = Date.parse(windowsAnswer?.split(`
+`)[0]?.trim() ?? "");
+    return Number.isNaN(when) ? null : when;
+  }
+  try {
+    const said = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+      encoding: "utf8",
+      timeout: 15000
+    }).trim();
+    const when = Date.parse(said);
+    return said === "" || Number.isNaN(when) ? null : when;
+  } catch {
+    return null;
+  }
+}
 function windowsImage(pid) {
   try {
     const csv = execFileSync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
@@ -28336,16 +28362,24 @@ function stillTheRecordedRun(record) {
 function couldStillBeTheRecordedRun(record) {
   return judgeRun(record, runningAs(record.pid), "possible");
 }
+var AN_EDITOR = /(?:^|\s)(?:-e|--editor)(?:\s|$)/;
+var SAME_RUN_WINDOW_MS = 1e4;
 function judgeRun(record, running, needed) {
   if (running === null) {
     return false;
   }
+  if (running.startedAt !== undefined && running.startedAt - record.startedAt > SAME_RUN_WINDOW_MS) {
+    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 === "commandLine" && AN_EDITOR.test(said)) {
+    return false;
+  }
   if (record.projectPath === "") {
     return wanted !== null;
   }
@@ -29076,7 +29110,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. 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.",
+    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: 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",
@@ -29104,7 +29138,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_status",
-    description: 'Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means "not reached yet" as often as it means "no editor". True is worth waiting out; false is an editor that is not there. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer.',
+    description: 'Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means "not reached yet" as often as it means "no editor". True is worth waiting out; false is an editor that is not there. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it.',
     parameters: {},
     requires: []
   },
@@ -29534,12 +29568,18 @@ function stillRunning(run) {
   if (!run.throughEditor && run.process === null && run.pid !== null) {
     return alive(run.pid);
   }
+  if (run.announcedPid !== undefined && !alive(run.announcedPid)) {
+    return false;
+  }
   return true;
 }
 function runIsUp(run, editorSays) {
   if (run?.throughEditor !== true) {
     return stillRunning(run);
   }
+  if (run.announcedPid !== undefined && !alive(run.announcedPid)) {
+    return false;
+  }
   return editorSays ?? stillRunning(run);
 }
 function runtimeVerdict(endpoint, after) {
@@ -30970,7 +31010,10 @@ class GodotServer {
     return `The debug adapter on port ${port} belongs to process ${holder}, and the editor on this server's bridge is process ${ours}. Godot gives every editor the same debug adapter port by default, so the one this editor names in its settings is not necessarily the one it holds. Playing the game now would put another editor's console and another project's debugger under this project's name.`;
   }
   anEditorIsStillComing(listeningSince) {
-    return anEditorIsStillComing(listeningSince, this.launchedEditor !== null && alive(this.launchedEditor));
+    return anEditorIsStillComing(listeningSince, this.launchedEditorIsUp());
+  }
+  launchedEditorIsUp() {
+    return this.launchedEditor?.exitCode === null && this.launchedEditor.signalCode === null;
   }
   dap() {
     const port = this.editorServes("dapPort", "GDHARNESS_DAP_PORT", DEFAULT_DAP_PORT);
@@ -31016,7 +31059,7 @@ class GodotServer {
       addonIsStale: status.connected ? stale : undefined,
       bridgeAvailable: this.bridgeStartupError === null,
       mayYetConnect: status.connected ? undefined : this.anEditorIsStillComing(status.listeningSince),
-      awaitingLaunchedEditor: status.connected || this.launchedEditor === null || !alive(this.launchedEditor) ? undefined : this.launchedEditor,
+      awaitingLaunchedEditor: status.connected || !this.launchedEditorIsUp() ? undefined : this.launchedEditor?.pid ?? undefined,
       ...status.connected ? this.whatTheLaunchedEditorDropped() : {},
       startupError: this.bridgeStartupError,
       staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION) : undefined,
@@ -31052,7 +31095,8 @@ class GodotServer {
   }
   async handleEditorStatus() {
     const godotPath = await this.locator.find();
-    const games = await Promise.all(discoverRuntimes().map(async (endpoint) => {
+    const announced = runtimesAnnounced();
+    const games = await Promise.all(announced.running.map(async (endpoint) => {
       const reply = await runtimeRequest(endpoint, "ping", {}, this.runtimeTimeoutMs());
       return {
         pid: endpoint.pid,
@@ -31074,10 +31118,17 @@ class GodotServer {
         version: godotPath === null ? null : await this.godotVersion(godotPath)
       },
       game: {
-        processActive: stillRunning(this.currentRun()),
+        processActive: runIsUp(this.currentRun(), playing === null ? null : playing.playing),
         playingInEditor: playing,
         runtimeConnected: games.some((game) => game.reachable),
-        runtimes: games
+        runtimes: games,
+        unreadable: announced.unspoken.map((game) => ({
+          pid: game.pid,
+          project: game.project,
+          protocol: game.protocol,
+          serverSpeaks: RUNTIME_PROTOCOL,
+          behind: game.protocol > RUNTIME_PROTOCOL ? "server" : "addon"
+        }))
       }
     });
   }
@@ -31227,7 +31278,7 @@ class GodotServer {
       return { pid: null, error: started };
     }
     editor.unref();
-    this.launchedEditor = editor.pid ?? null;
+    this.launchedEditor = editor.pid === undefined ? null : editor;
     return { pid: editor.pid ?? null, error: null };
   }
   async portsForAnEditor() {
@@ -31274,6 +31325,7 @@ class GodotServer {
       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 wereHereFirst = this.everyRuntimeOfOurs();
     const headless = resolveHeadless(args["headless"], {
       platform: process.platform,
       variables: process.env
@@ -31294,16 +31346,20 @@ class GodotServer {
     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.`;
+    const stranded = wereHereFirst.filter((one) => one.pid !== ended && alive(one.pid));
+    const named = stranded.map((one) => one.protocol === null ? `pid ${one.pid}` : `pid ${one.pid} on protocol ${one.protocol}`).join(", ");
+    const alsoRunning = stranded.length === 0 ? "" : ` A game of this project was already running and still is: ${named}. Starting this one did not end it and nothing here can, because this server did not start it. End it yourself, or bring the halves to one version where a protocol is named.`;
     return this.jsonTextResponse({
       started: true,
       through: "gdharness",
+      alsoRunning: stranded.length === 0 ? undefined : stranded.map((one) => one.pid),
       pid: started.process.pid ?? null,
       arguments: cmdArgs,
       transcript: started.transcript,
       refreshedClasses: refreshed.value,
       endedPreviousRun: ended ?? undefined,
       runtime: await this.runtimeUp(project.value.path, alreadyPlaying, runtimeWaitMs, given.value.length > 0),
-      message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}${endedForThis}`
+      message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}${endedForThis}${alsoRunning}`
     });
   }
   async gameIsUp() {
@@ -31319,6 +31375,10 @@ class GodotServer {
       budgetMs,
       giveUp: () => this.dapClient?.isStopped() === true || !stillRunning(this.currentRun())
     });
+    const going = this.currentRun();
+    if (endpoint !== null && going?.throughEditor === true && going.announcedPid === undefined) {
+      going.announcedPid = endpoint.pid;
+    }
     return runtimeVerdict(endpoint, {
       addon: true,
       budgetMs,
@@ -31428,9 +31488,15 @@ class GodotServer {
       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;
     }
+    const signalled = runningAs(running.pid);
+    const described = signalled === null ? "nothing it would name" : `${signalled.kind}: ${signalled.text}`;
+    let landed = true;
     try {
       process.kill(running.pid);
-    } catch {}
+    } catch {
+      landed = false;
+    }
+    running.log.record("info", landed ? `gdharness ended pid ${running.pid}, which the operating system described as ${described}.` : `gdharness signalled pid ${running.pid} and it was already gone; the operating system had described it as ${described}.`);
   }
   spawnGame(godotPath, cmdArgs, env) {
     const child = spawn(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
@@ -31619,7 +31685,12 @@ class GodotServer {
     const noEditor = !status.connected ? " No editor is connected, so a game the editor is playing cannot be seen from here at all:" + " editor_status says whether one is on its way, and a run of yours that is still up is" + " reachable again once it is." : "";
     const live = this.aRuntimeOfOursIsAnswering();
     if (live !== null) {
-      return `A game is running for ${live.project.path} and has announced its runtime on port ${live.port}, pid ${live.pid},` + " but this server did not start it and cannot reach it through the editor, so editor_run and" + " editor_output have nothing to answer about. The runtime_* tools reach it now." + " Do not start another: editor_run start replaces the game that is playing rather than" + " adding one, so it would end this one." + (this.godotBridge.getStatus().connected ? "" : " editor_status says whether an editor is on its way, and editor_run can end it once one is.");
+      return `A game is running for ${live.project.path} and has announced its runtime on port ${live.port}, pid ${live.pid},` + " but this server did not start it and cannot reach it through the editor, so editor_run and" + " editor_output have nothing to answer about. The runtime_* tools reach it now." + " A run started here is a separate process rather than a replacement, so starting one leaves" + " this game running as well." + (this.godotBridge.getStatus().connected ? "" : " editor_status says whether an editor is on its way, and editor_run can end it once one is.");
+    }
+    const unreadable = this.aRuntimeOfOursIsTooFarOff();
+    if (unreadable !== null) {
+      const behind = unreadable.protocol > RUNTIME_PROTOCOL ? "this server is the older half: reconnect it so it spawns the installed version" : "the addon is the older half: reinstall it and restart the game";
+      return `A game is running for ${unreadable.project.path}, pid ${unreadable.pid}, announced in protocol` + ` ${unreadable.protocol}, which this server does not speak: it speaks ${RUNTIME_PROTOCOL}, so ${behind}.` + " Until then neither editor_run nor the runtime_* tools can reach it." + " A run started here is a separate process rather than a replacement, so starting one leaves" + " this game running as well.";
     }
     const record = readRunRecord();
     if (record === null) {
@@ -31631,12 +31702,34 @@ class GodotServer {
     return `No game of this server's is running.${noEditor} 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.`;
   }
   aRuntimeOfOursIsAnswering() {
+    return this.announcedForOurProject(discoverRuntimes());
+  }
+  aRuntimeOfOursIsTooFarOff() {
+    return this.announcedForOurProject(runtimesAnnounced().unspoken);
+  }
+  announcedForOurProject(announced) {
+    return this.allAnnouncedForOurProject(announced)[0] ?? null;
+  }
+  allAnnouncedForOurProject(announced) {
     const status = this.godotBridge.getStatus();
     const mine = this.ownProject ?? (status.connected ? status.projectPath ?? null : null);
     if (mine === null) {
-      return null;
+      return [];
     }
-    return discoverRuntimes().find((one) => one.project.path !== "" && isSameDirectory(mine, one.project.path)) ?? null;
+    return announced.filter((one) => one.project.path !== "" && isSameDirectory(mine, one.project.path));
+  }
+  everyRuntimeOfOurs() {
+    const announced = runtimesAnnounced();
+    return [
+      ...this.allAnnouncedForOurProject(announced.running).map((one) => ({
+        pid: one.pid,
+        protocol: null
+      })),
+      ...this.allAnnouncedForOurProject(announced.unspoken).map((one) => ({
+        pid: one.pid,
+        protocol: one.protocol
+      }))
+    ];
   }
   couldBeOurs(project) {
     const status = this.godotBridge.getStatus();
@@ -31741,7 +31834,7 @@ class GodotServer {
       notes.push(run.exitCode === 0 ? "This run quit on its own, cleanly: exit code 0." : "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. 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.`);
+      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: a transcript that stops growing is a run between prints. running above is asked of the operating system while there is a process to ask about, and for an editor-played run that announced no runtime it is the editor's answer instead, which can lag after the game has gone.`);
     }
     return this.jsonTextResponse({
       running: stillRunning(run),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "0.13.34",
+  "version": "0.13.36",
   "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",