gdharness 1.2.24 → 1.2.25

package/build/cli.js

@@ -70,6 +70,7 @@ var init_errors = __esm(() => {
 
 // src/windows-ask.ts
 import { spawn } from "node:child_process";
+import { tmpdir } from "node:os";
 import process2 from "node:process";
 function holding(child, wanted) {
   if (held === wanted) {
@@ -94,7 +95,7 @@ function running() {
     "Bypass",
     "-EncodedCommand",
     Buffer.from(SCRIPT, "utf16le").toString("base64")
-  ], { stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+  ], { stdio: ["pipe", "pipe", "pipe"], windowsHide: true, cwd: tmpdir() });
   buffered = "";
   child.stdout.setEncoding("utf8");
   child.stdout.on("data", (chunk) => {
@@ -8220,13 +8221,13 @@ var init_alive = () => {};
 
 // src/scratch.ts
 import { existsSync as existsSync6, mkdtempSync, readdirSync as readdirSync3, rmSync as rmSync4 } from "node:fs";
-import { tmpdir } from "node:os";
+import { tmpdir as tmpdir2 } from "node:os";
 import { join as join6 } from "node:path";
 import process6 from "node:process";
 function scratchDirectory(kind) {
-  return mkdtempSync(join6(tmpdir(), `gdharness-${kind}-${process6.pid}-`));
+  return mkdtempSync(join6(tmpdir2(), `gdharness-${kind}-${process6.pid}-`));
 }
-function sweepAbandonedScratch(directory = tmpdir()) {
+function sweepAbandonedScratch(directory = tmpdir2()) {
   let entries;
   try {
     entries = readdirSync3(directory);
@@ -8336,14 +8337,20 @@ function snakeCased(params) {
   return result;
 }
 function engineExtras(outcome) {
+  const after = outcome.afterAnswerMessages ?? [];
   return {
     ...outcome.messages.length > 0 ? { engine_messages: outcome.messages } : {},
     ...outcome.messagesOmitted === undefined ? {} : { engine_messages_omitted: outcome.messagesOmitted },
+    ...after.length > 0 ? { engine_messages_after_answer: after, engine_messages_after_answer_note: AFTER_ANSWER_NOTE } : {},
+    ...outcome.afterAnswerOmitted === undefined ? {} : { engine_messages_after_answer_omitted: outcome.afterAnswerOmitted },
     ...outcome.afterAnswer === undefined ? {} : { engine_after_answer: outcome.afterAnswer }
   };
 }
 function problemsIn(log) {
-  return log.everything().flatMap((entry) => {
+  return problemsAmong(log.everything());
+}
+function problemsAmong(entries) {
+  return entries.flatMap((entry) => {
     if (entry.severity !== "info") {
       return [entry];
     }
@@ -8472,12 +8479,20 @@ async function runOperation(engine, operation, params, projectPath) {
   } finally {
     discard(paramsDir);
   }
-  const problems = problemsIn(ran.log);
+  const everything = ran.log.everything();
+  const answered = everything.findIndex((entry) => entry.source === "stderr" && entry.text === ANSWERED);
+  const problems = problemsAmong(answered === -1 ? everything : everything.slice(0, answered));
+  const after = answered === -1 ? [] : problemsAmong(everything.slice(answered + 1));
+  const afterAnswered = {
+    ...after.length === 0 ? {} : { afterAnswerMessages: after.slice(-MESSAGES_KEPT) },
+    ...after.length > MESSAGES_KEPT ? { afterAnswerOmitted: after.length - MESSAGES_KEPT } : {}
+  };
   if (answer.kind === "unreadable") {
     return {
       ok: false,
       message: `${operation} wrote an answer that could not be read (${answer.why})`,
-      ...reported2(problems)
+      ...reported2(problems),
+      ...afterAnswered
     };
   }
   if (answer.kind === "none") {
@@ -8493,14 +8508,16 @@ async function runOperation(engine, operation, params, projectPath) {
     return {
       ok: false,
       message: `${operation} hit an error in the operations script, so its answer is left out: part of it was ` + `never computed. ${fault.text} (${fault.detail[0]?.slice("at: ".length) ?? "no location given"})`,
-      ...reported2(problems)
+      ...reported2(problems),
+      ...afterAnswered
     };
   }
-  const afterAnswer = ran.exitCode === 0 && ran.failure === null ? undefined : `The operation finished and wrote this answer, and then the engine did not exit cleanly (${howItEnded(ran)}). Anything it reported on the way out is under engine_messages.`;
+  const afterAnswer = ran.exitCode === 0 && ran.failure === null ? undefined : `The operation finished and wrote this answer, and then the engine did not exit cleanly (${howItEnded(ran)}). Anything it reported on the way out is under ${answered === -1 ? "engine_messages" : "engine_messages_after_answer"}.`;
   return {
     ok: true,
     payload: answer.payload,
     ...reported2(problems),
+    ...afterAnswered,
     ...afterAnswer === undefined ? {} : { afterAnswer }
   };
 }
@@ -8519,7 +8536,7 @@ function answerIn(file) {
     };
   }
 }
-var OWN_ERROR = "[ERROR] ", MESSAGES_KEPT = 200, ERRORS_NAMED = 3;
+var AFTER_ANSWER_NOTE = "Printed after this operation had written its answer, while the engine ran the project's autoloads and shut down: Godot starts a project's autoloads in every script run and cannot be told not to. An error raised in a project script here is that autoload's own, and none of these changes the answer.", OWN_ERROR = "[ERROR] ", ANSWERED = "[gdharness] answered", MESSAGES_KEPT = 200, ERRORS_NAMED = 3;
 var init_headless = __esm(() => {
   init_engine_run();
   init_reimport();
@@ -8528,7 +8545,7 @@ var init_headless = __esm(() => {
 
 // src/update-check.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
+import { homedir as homedir3, tmpdir as tmpdir3 } from "node:os";
 import { join as join8 } from "node:path";
 function packageUrl(root) {
   return `${root.replace(/\/+$/, "")}/gdharness/latest`;
@@ -8564,7 +8581,7 @@ function cacheFile(environment = process.env) {
     mkdirSync3(directory, { recursive: true, mode: 448 });
     return join8(directory, "update-check.json");
   } catch {
-    return join8(tmpdir2(), "gdharness-update-check.json");
+    return join8(tmpdir3(), "gdharness-update-check.json");
   }
 }
 function readCache(path) {
@@ -11810,7 +11827,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "editor_launch",
       title: "Open, restart or close the editor",
-      description: "Opens the Godot editor on a project, or restarts or closes the one already connected. close saves open scenes, quits the editor and waits for its process to go, which is the only way to end a hidden one short of killing it; settingsDropped in its answer says what that save took out of project.godot. open refuses while an editor of the project is already running and has not reached this server, naming its pid, rather than putting a second on the project. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, visible unless hidden: true is passed again, once the old one has gone: it waits 90 seconds for that, or GDHARNESS_EDITOR_RESTART_TIMEOUT_MS, and an old editor still running after it is not replaced, since the new one would find its ports held. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart. An open is refused when the editor it would start could never reach this server: a project other than the one this server serves, whose editor dials that project's own server; a project without the gdharness editor addon installed and enabled; and a project whose editor a restart is already bringing back.",
+      description: "Opens the Godot editor on a project, or restarts or closes the one already connected. close saves open scenes, quits the editor and waits for its process to go, which is the only way to end a hidden one short of killing it; settingsDropped in its answer says what that save took out of project.godot. An editor this server opened that has not connected yet has nothing of this server's to save, so close stops its process instead and answers beforeConnecting. open answers once the process has started, and the editor dials in after its import; a call needing the editor made before then waits for the one this server opened, for as long as a restart waits, and is refused naming it if it has not arrived. open refuses while an editor of the project is already running and has not reached this server, naming its pid, rather than putting a second on the project. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, visible unless hidden: true is passed again, once the old one has gone: it waits 90 seconds for that, or GDHARNESS_EDITOR_RESTART_TIMEOUT_MS, and an old editor still running after it is not replaced, since the new one would find its ports held. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart. An open is refused when the editor it would start could never reach this server: a project other than the one this server serves, whose editor dials that project's own server; a project without the gdharness editor addon installed and enabled; and a project whose editor a restart is already bringing back.",
       parameters: {
         projectPath: { ...PROJECT_PATH, ops: ["open"] },
         hidden: {
@@ -11965,6 +11982,10 @@ var init_tool_definitions = __esm(() => {
       title: "Game and 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. For a run the editor plays the reports come from the game itself, through the runtime addon, since the editor's debugger relays what a game prints and not what it reports; a played game without the runtime addon answers here with its prints alone, with errorsUnread true and no clean, since what it raised reaches nothing here. Answers with the counts and the verdict as well as the entries: clean is true when no error was reported, and warnings, counted beside it, do not make it false. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts; a run ended by a signal has no exit code, and exitSignal names the signal instead. 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. op: \"editor\" answers about the editor itself instead, which is a different log and the only way anything here can read what an editor printed: its console reaches no plugin, so the addon cannot scrape it, and an editor gdharness opened is asked for a log file as it starts. That covers the whole session from the editor's first line, which is where the output worth reading usually is, since the class cache, the plugins and the language server all say what they have to say before any harness has connected. The answer carries the entries in the order they were printed and, beside them under repeated, each message shape several lines share: how many, what varied in each slot of it and how many different values stood there, the first occurrence, and the ordinary lines above the group, found by walking back past the group rather than by counting lines. An editor somebody opened by hand has no console here and is refused saying so rather than answered empty, because an editor that printed nothing and an editor nobody captured are not the same thing. startedAt is when the run began and elapsedMs how long it has been going; for a run that is over, endedAt is when it ended and elapsedMs how long it ran, and both are left out when nobody saw the end, as for a game closed in the editor or a run picked up from a note written before ends were recorded.",
       parameters: {
+        projectPath: {
+          type: "string",
+          description: "The project whose output you mean to read. It picks nothing, since this reads the one run or editor this server holds, and a call naming another project than that one's is refused rather than answered with output from a different game."
+        },
         severity: {
           type: "string",
           enum: ["error", "warning", "info"],
@@ -12016,7 +12037,7 @@ var init_tool_definitions = __esm(() => {
       title: "Editor status",
       effect: "read",
       description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and which games with the runtime addon are reachable, of this project and of every other on the machine. Read connected with mayYetConnect: the editor dials this server and backs off between tries, so for the first half-minute after a server starts false means not reached yet as often as no editor; mayYetConnect true is worth waiting out, false is final, and restartInterrupted, restartUnderway, closedHere and editorsNotYetConnected say why. An editor that has connected and not yet greeted reports nothing about itself, and every other call made in that window waits up to ten seconds for it to settle. playingInEditor null means unanswered rather than nothing playing: processActive and runtimes do not depend on the editor answering. game.run names the run editor_output and editor_run stop answer for, and stays named after it ends. addonIsStale, on the editor and on each game, says it runs addon code other than what this server ships, and staleNote says which half moves: gdharness upgrade in the project, a restart, or a reconnect of this server. A false editor.lspListening or editor.dapListening comes with serversNote, and editor_launch restart binds the port again. editor.scan says whether the editor is scanning, which editor_run waits out before starting a game. A game announced in a protocol this server does not speak is listed under unreadable, during an upgrade that moves the protocol, until the halves match.",
-      answer: "runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. 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. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it. It stays named after the run ends, beside processActive false, so editor_output can still read what that run printed; null when there is no run at all. startedAt says when it began, and endedAt when it ended, wherever something saw the end: a run adopted from a note another server wrote can have ended hours before this server started. editor.lspListening and editor.dapListening say whether anything accepts connections on the ports the editor names, lspPort and dapPort: Godot binds each once, as the editor starts, and reports a failure only in the log panel of the editor itself, so a false comes with serversNote, and editor_launch restart binds it again. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs gdharness upgrade, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. Every runtime_* answer from such a game carries addonIsStale and staleNote too. 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. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. 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. Any editor of this project running and not yet connected, whoever opened it, makes it true as well and is named under editorsNotYetConnected with its pid and start time, so a restart a reconnect interrupted after its launch is not read as nothing being there. 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. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs. An engine run that loads the editor addon to do one job and quit, such as a gate's godot --headless --import, an export or a script, is not taken as the editor: a process that greets without a server's mark has its command line read first, and while that is read identifying is true and connected false; one started with such an option is turned away, and turnedAway names the last one, its pid and the option. Every other call made while an editor is arriving, before its greeting or while it is looked up, waits up to ten seconds for it to settle rather than acting on connected as it reads in that window.",
+      answer: "server names this server: its pid, its version, and lifecycleLog, the file every gdharness server of the user appends a line to when it starts, when its client first names itself, when it replaces another server of its project, and when it ends, with why it ended (the client closing its end as stdin:end, a signal by name, superseded with the successor's pid, an uncaught exception or rejection with its stack, or the exit code) and the calls it was answering then. The parent's command line follows on its own line a few seconds after the start. A server killed without warning writes no ended line, and on Windows every kill is that, so a started line with no ended line after it is a server something killed. " + "runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. 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. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it. It stays named after the run ends, beside processActive false, so editor_output can still read what that run printed; null when there is no run at all. startedAt says when it began, and endedAt when it ended, wherever something saw the end: a run adopted from a note another server wrote can have ended hours before this server started. editor.lspListening and editor.dapListening say whether anything accepts connections on the ports the editor names, lspPort and dapPort: Godot binds each once, as the editor starts, and reports a failure only in the log panel of the editor itself, so a false comes with serversNote, and editor_launch restart binds it again. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs gdharness upgrade, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. Every runtime_* answer from such a game carries addonIsStale and staleNote too. 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. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. 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. Any editor of this project running and not yet connected, whoever opened it, makes it true as well and is named under editorsNotYetConnected with its pid and start time, so a restart a reconnect interrupted after its launch is not read as nothing being there. 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. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs. An engine run that loads the editor addon to do one job and quit, such as a gate's godot --headless --import, an export or a script, is not taken as the editor: a process that greets without a server's mark has its command line read first, and while that is read identifying is true and connected false; one started with such an option is turned away, and turnedAway names the last one, its pid and the option. Every other call made while an editor is arriving, before its greeting or while it is looked up, waits up to ten seconds for it to settle rather than acting on connected as it reads in that window.",
       parameters: {},
       requires: []
     },
@@ -12219,7 +12240,7 @@ var init_tool_definitions = __esm(() => {
         value: {
           ops: ["set"],
           blank: true,
-          description: `set: the value, fitted to the property's type. "" writes an empty string. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. One declared as Variant or untyped takes anything, as the engine does: a value of the kind it holds is fitted to it, an int staying an int, and any other is stored as sent. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key, as is an object of another script than the one the list holds, whether or not that script has a class_name.`
+          description: `set: the value, fitted to the property's type. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}, which is the form a read answers with. "" writes an empty string. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. One declared as Variant or untyped takes anything, as the engine does: a value of the kind it holds is fitted to it, an int staying an int, and any other is stored as sent. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key, as is an object of another script than the one the list holds, whether or not that script has a class_name.`
         },
         method: {
           type: "string",
@@ -12229,7 +12250,7 @@ var init_tool_definitions = __esm(() => {
         args: {
           type: "array",
           ops: ["call"],
-          description: `call: the arguments, fitted to the method's parameter types. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A path that reaches no object, or an object of another class than the parameter declares, is refused, and so are too few or too many arguments. The engine names a parameter typed as a script class without class_name by the class the script extends, so an object of that class with another script passes that check and the engine refuses the call: the answer says the method did not run, with the engine's reason. A parameter typed as a list or map, such as Array[int] or Array[Gear], is built from a JSON list or object element by element, objects named by their paths. The method itself takes its arguments here only: brackets on it holding arguments are refused.`
+          description: `call: the arguments, fitted to the method's parameter types. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A path that reaches no object, or an object of another class than the parameter declares, is refused, and so are too few or too many arguments. The engine names a parameter typed as a script class without class_name by the class the script extends, so an object of that class with another script passes that check and the engine refuses the call: the answer says the method did not run, with the engine's reason. A parameter typed as a list or map, such as Array[int] or Array[Gear], is built from a JSON list or object element by element, objects named by their paths. The method itself takes its arguments here only: brackets on it holding arguments are refused.`
         },
         properties: {
           type: ["boolean", "array"],
@@ -12323,7 +12344,7 @@ var init_tool_definitions = __esm(() => {
       name: "runtime_input",
       title: "Send input to the game",
       description: "Input to the running game: a whole click on a Control or a 3D node named by path or on a control named by the words on it, an item chosen out of a menu, typing into whatever has the focus, or a raw action, key, mouse button or mouse motion. All of it works headless, where the window is 64 by 64 and the GUI only takes what is inside it. On gdharness's own desktop, where a windowed run goes, Windows refuses to say where the pointer is: every pointer answer there carries pointer_on_hidden_desktop, and the first of the run pointer_note saying why it matters: get_mouse_position() on the root window, and the mouse positions derived from it, read a meaningless position, while what reads the event itself (the control under it, hover, tooltips, input handlers) gets the injected position.",
-      answer: 'click: what was under the pointer, and what became of the control: in_tree, removed or freed. Named by says, found says which match it was, and found.pressedOn says "the words" for words in a RichTextLabel pressed where they are drawn, or "the middle of the label" with a note saying why they could not be placed; on a rich label link_pressed says whether the press reached a link, with link_meta giving the meta the label reports clicked, an empty one included. A control scrolled into view first is scrolled each container out from it a frame after the one inside, and scrolled_into_view says whether a scroll value changed. A button in toggle mode, a CheckBox or CheckButton included, answers pressed with before and after, its button_pressed either side of the click: the same value twice is a click the game undid, and after is null when the click freed it. A refusal for a pointer turned off names where mouse_behavior_recursive was set. On a 3D node landed says the interface did not swallow the press: no control under the pointer stopped it, a control letting the pointer pass included, and every viewport on the way out from the room had the pointer over what shows the room. choose: what was chosen, read before the press, which is heard rather than assumed; what became of the control named (in_tree, removed or freed, since a game can rebuild its screen on the pick); and what the button in front of the menu shows now when it is still there. A menu is opened rather than clicked because its items are drawn rather than built, and the item is looked for as the menu stands once open, since a game can fill a menu as it opens.',
+      answer: 'click: what was under the pointer, and what became of the control: in_tree, removed or freed. Named by says, found says which match it was, and found.pressedOn says "the words" for words in a RichTextLabel pressed where they are drawn, or "the middle of the label" with a note saying why they could not be placed; on a rich label link_pressed says whether the press reached a link, with link_meta giving the meta the label reports clicked, an empty one included. A control scrolled into view first is scrolled each container out from it a frame after the one inside, and scrolled_into_view says whether a scroll value changed. A button in toggle mode, a CheckBox or CheckButton included, answers pressed with before and after, its button_pressed either side of the click: the same value twice is a click the game undid, and after is null when the click freed it. A refusal for a pointer turned off names where mouse_behavior_recursive was set. On a 3D node landed says the interface did not swallow the press: no control under the pointer stopped it, a control letting the pointer pass included, and every viewport on the way out from the room had the pointer over what shows the room. choose: what was chosen, read before the press, which is heard rather than assumed; what became of the control named (in_tree, removed or freed, since a game can rebuild its screen on the pick); and what the button in front of the menu shows now when it is still there. A menu is opened rather than clicked because its items are drawn rather than built, and the item is looked for as the menu stands once open, since a game can fill a menu as it opens. action, key and mouse_click: the event as it was sent, with whole saying whether the press was let go of again, and for a key the keycode, physical_keycode and unicode it carried. mouse_motion: the position and the relative movement sent. None of these is aimed at anything, so none says what the event reached: click on a nodePath or says answers what was under the pointer.',
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         pid: RUNNING_PID,
@@ -34333,7 +34354,7 @@ var init_stdio = __esm(() => {
 // src/runtime-client.ts
 import { existsSync as existsSync13, readdirSync as readdirSync8, readFileSync as readFileSync12, statSync as statSync6, unlinkSync } from "node:fs";
 import { createConnection } from "node:net";
-import { tmpdir as tmpdir3 } from "node:os";
+import { tmpdir as tmpdir4 } from "node:os";
 import { dirname as dirname8, join as join14, resolve as resolve4 } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 function runtimeDirectory(variables = process.env) {
@@ -34342,7 +34363,7 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join14(perUser ?? tmpdir3(), "gdharness");
+  return join14(perUser ?? tmpdir4(), "gdharness");
 }
 function runtimeDirectories(variables = process.env) {
   const candidates = [runtimeDirectory(variables)];
@@ -40126,11 +40147,58 @@ function askTheKeeperToStop(address, withinMs) {
 }
 var init_keeper_channel = () => {};
 
+// src/lifecycle-log.ts
+import { appendFileSync, mkdirSync as mkdirSync11, renameSync, statSync as statSync8 } from "node:fs";
+import { dirname as dirname14, join as join21 } from "node:path";
+import process10 from "node:process";
+function lifecycleLogPath() {
+  return join21(runtimeDirectory(), "servers.log");
+}
+function writeLifecycle(event, fields = {}) {
+  const path = lifecycleLogPath();
+  try {
+    mkdirSync11(dirname14(path), { recursive: true });
+    if ((statSync8(path, { throwIfNoEntry: false })?.size ?? 0) > LIFECYCLE_LOG_LIMIT) {
+      try {
+        renameSync(path, `${path}.1`);
+      } catch {}
+    }
+    const line = {
+      at: new Date().toISOString(),
+      pid: process10.pid,
+      ppid: process10.ppid,
+      version: SERVER_VERSION,
+      event
+    };
+    for (const [name, value] of Object.entries(fields)) {
+      if (!Object.hasOwn(line, name)) {
+        line[name] = value;
+      }
+    }
+    appendFileSync(path, `${JSON.stringify(line)}
+`, "utf8");
+  } catch {
+    console.error(`[SERVER] Could not write the lifecycle log at ${path}.`);
+  }
+}
+function callsInFlight(calls, now = Date.now()) {
+  return [...calls].map((call) => ({
+    tool: call.tool,
+    ...call.op === "" ? {} : { op: call.op },
+    runningMs: now - call.startedAt
+  }));
+}
+var LIFECYCLE_LOG_LIMIT = 1e6;
+var init_lifecycle_log = __esm(() => {
+  init_runtime_client();
+  init_server_version();
+});
+
 // src/lsp_client.ts
 import { existsSync as existsSync17, realpathSync as realpathSync4 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname14, join as join21, resolve as resolve5 } from "node:path";
+import { dirname as dirname15, join as join22, resolve as resolve5 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function initializeTimeoutMs() {
@@ -40292,7 +40360,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname14(resolve5(filePath));
+    const rootPath = this.rootPath ?? dirname15(resolve5(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params, timeoutMs = this.timeouts.requestMs) {
@@ -40793,7 +40861,7 @@ async function resolveLSPPaths(projectPathValue, scriptPathValue) {
   } catch {
     throw new ArgumentRefusal(`Project path does not exist: ${requestedProjectPath}`);
   }
-  if (!existsSync17(join21(projectPath, "project.godot"))) {
+  if (!existsSync17(join22(projectPath, "project.godot"))) {
     throw new ArgumentRefusal(`Not a Godot project: ${projectPath}. Point projectPath at the directory holding project.godot.`);
   }
   const contained = resolveWithinProject(projectPath, scriptPathValue);
@@ -41233,8 +41301,8 @@ var init_prompts = __esm(() => {
 });
 
 // src/rename.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync11, readFileSync as readFileSync19, renameSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname15, posix as posix2 } from "node:path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync12, readFileSync as readFileSync19, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync13 } from "node:fs";
+import { dirname as dirname16, posix as posix2 } from "node:path";
 
 class Script {
   path;
@@ -41946,15 +42014,15 @@ function applyRewrites(rewrites) {
   const done = [];
   try {
     for (const rewrite of rewrites) {
-      mkdirSync11(dirname15(rewrite.writeTo), { recursive: true });
+      mkdirSync12(dirname16(rewrite.writeTo), { recursive: true });
       const staging = `${rewrite.writeTo}.gdharness-rename`;
       writeFileSync13(staging, rewrite.after, "utf8");
-      renameSync(staging, rewrite.writeTo);
+      renameSync2(staging, rewrite.writeTo);
       let movedUid = false;
       if (rewrite.writeTo !== rewrite.absolute) {
         unlinkSync2(rewrite.absolute);
         if (existsSync18(`${rewrite.absolute}.uid`)) {
-          renameSync(`${rewrite.absolute}.uid`, `${rewrite.writeTo}.uid`);
+          renameSync2(`${rewrite.absolute}.uid`, `${rewrite.writeTo}.uid`);
           movedUid = true;
         }
       }
@@ -41967,7 +42035,7 @@ function applyRewrites(rewrites) {
         if (rewrite.writeTo !== rewrite.absolute) {
           unlinkSync2(rewrite.writeTo);
           if (movedUid) {
-            renameSync(`${rewrite.writeTo}.uid`, `${rewrite.absolute}.uid`);
+            renameSync2(`${rewrite.writeTo}.uid`, `${rewrite.absolute}.uid`);
           }
         }
       } catch {}
@@ -41999,8 +42067,8 @@ var init_rename = __esm(() => {
 });
 
 // src/rename-symbol.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync12, readdirSync as readdirSync9, realpathSync as realpathSync5, rmSync as rmSync10, writeFileSync as writeFileSync14 } from "node:fs";
-import { basename as basename5, dirname as dirname16, join as join22, relative as relative4, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync13, readdirSync as readdirSync9, realpathSync as realpathSync5, rmSync as rmSync10, writeFileSync as writeFileSync14 } from "node:fs";
+import { basename as basename5, dirname as dirname17, join as join23, relative as relative4, resolve as resolve6 } from "node:path";
 function resourcePathOf(projectPath, absolute) {
   const inside = relative4(onDiskSpelling(projectPath), onDiskSpelling(absolute));
   if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
@@ -42013,9 +42081,9 @@ function onDiskSpelling(path) {
   let at = resolve6(path);
   for (;; ) {
     try {
-      return join22(realpathSync5.native(at), ...missing.reverse());
+      return join23(realpathSync5.native(at), ...missing.reverse());
     } catch {
-      const parent = dirname16(at);
+      const parent = dirname17(at);
       if (parent === at) {
         return resolve6(path);
       }
@@ -42441,15 +42509,15 @@ ${mention.kind}`;
   };
 }
 function writeLeftAloneDetail(projectPath, symbol, detail) {
-  const directory = join22(projectPath, ".godot", "gdharness-renames");
-  mkdirSync12(directory, { recursive: true });
+  const directory = join23(projectPath, ".godot", "gdharness-renames");
+  mkdirSync13(directory, { recursive: true });
   detailWrites += 1;
-  const path = join22(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
+  const path = join23(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
   writeFileSync14(path, `${JSON.stringify(detail, null, 2)}
 `, "utf8");
   const kept = readdirSync9(directory).filter((name) => name.endsWith(".json")).sort().reverse();
   for (const old of kept.slice(10)) {
-    rmSync10(join22(directory, old), { force: true });
+    rmSync10(join23(directory, old), { force: true });
   }
   return path;
 }
@@ -42489,15 +42557,15 @@ var init_rename_symbol = __esm(() => {
 });
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync13, readFileSync as readFileSync20, rmSync as rmSync11, writeFileSync as writeFileSync15 } from "node:fs";
-import { dirname as dirname17, join as join23 } from "node:path";
+import { mkdirSync as mkdirSync14, readFileSync as readFileSync20, rmSync as rmSync11, writeFileSync as writeFileSync15 } from "node:fs";
+import { dirname as dirname18, join as join24 } from "node:path";
 function restartNotePath(projectPath) {
-  return join23(projectPath, ".godot", "gdharness-restart.json");
+  return join24(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync13(dirname17(path), { recursive: true });
+    mkdirSync14(dirname18(path), { recursive: true });
     writeFileSync15(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
@@ -42531,7 +42599,7 @@ var init_restart_note = __esm(() => {
 });
 
 // src/whole-file.ts
-import { renameSync as renameSync2, rmSync as rmSync12, writeFileSync as writeFileSync16 } from "node:fs";
+import { renameSync as renameSync3, rmSync as rmSync12, writeFileSync as writeFileSync16 } from "node:fs";
 function writeWhole(path, text) {
   const partial = `${path}.${process.pid}.partial`;
   try {
@@ -42542,7 +42610,7 @@ function writeWhole(path, text) {
   const until = Date.now() + HELD_FILE_MS;
   for (;; ) {
     try {
-      renameSync2(partial, path);
+      renameSync3(partial, path);
       return true;
     } catch (error) {
       const code = error.code ?? "";
@@ -42564,20 +42632,20 @@ var init_whole_file = __esm(() => {
 // src/run-record.ts
 import { execFile as execFile4 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
-import { mkdirSync as mkdirSync14, openSync as openSync2, readdirSync as readdirSync10, readFileSync as readFileSync21, realpathSync as realpathSync6, rmSync as rmSync13, statSync as statSync8 } from "node:fs";
-import { basename as basename6, dirname as dirname18, join as join24, resolve as resolve7 } from "node:path";
+import { mkdirSync as mkdirSync15, openSync as openSync2, readdirSync as readdirSync10, readFileSync as readFileSync21, realpathSync as realpathSync6, rmSync as rmSync13, statSync as statSync9 } from "node:fs";
+import { basename as basename6, dirname as dirname19, join as join25, resolve as resolve7 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 function runsDirectory() {
-  return join24(runtimeDirectory(), "runs");
+  return join25(runtimeDirectory(), "runs");
 }
 function realAsFarAsItExists(path) {
   const missing = [];
   let at = path;
   for (;; ) {
     try {
-      return join24(realpathSync6.native(at), ...missing);
+      return join25(realpathSync6.native(at), ...missing);
     } catch {
-      const parent = dirname18(at);
+      const parent = dirname19(at);
       if (parent === at) {
         return path;
       }
@@ -42592,14 +42660,14 @@ function projectKey(projectPath) {
   return createHash4("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join24(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join25(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 function latestRunPath(servedBy, directory = runtimeDirectory()) {
-  return join24(directory, "runs", `latest-${projectKey(servedBy)}.json`);
+  return join25(directory, "runs", `latest-${projectKey(servedBy)}.json`);
 }
 function writeLatestRun(servedBy, latest) {
   try {
-    mkdirSync14(runsDirectory(), { recursive: true });
+    mkdirSync15(runsDirectory(), { recursive: true });
     writeWhole(latestRunPath(servedBy), JSON.stringify(latest, null, 2));
   } catch {}
 }
@@ -42619,21 +42687,21 @@ function readLatestRun(servedBy, directory = runtimeDirectory()) {
   }
 }
 function openTranscript(startedAt) {
-  mkdirSync14(runsDirectory(), { recursive: true });
-  const path = join24(runsDirectory(), `run-${startedAt}.log`);
+  mkdirSync15(runsDirectory(), { recursive: true });
+  const path = join25(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync2(path, "a") };
 }
 function profilePath(startedAt) {
-  return join24(runsDirectory(), `run-${startedAt}.profile.json`);
+  return join25(runsDirectory(), `run-${startedAt}.profile.json`);
 }
 function noteIsAbout(note, playing) {
   return note.play !== undefined && playing !== null && note.play.play === playing.play && note.play.editorPid === playing.editorPid;
 }
 function editorNotePath(projectPath, directory = runtimeDirectory()) {
-  return join24(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join25(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
-  mkdirSync14(runsDirectory(), { recursive: true });
+  mkdirSync15(runsDirectory(), { recursive: true });
   const path = editorNotePath(note.projectPath);
   if (!writeWhole(path, JSON.stringify(note, null, 2))) {
     throw new Error(`the editor run note could not be written at ${path}`);
@@ -42641,7 +42709,7 @@ function writeEditorRunNote(note) {
 }
 function readEditorRunNote(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join24(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join25(directory, "runs", "editor-run.json"));
     if (note !== null && isSameDirectory(note.projectPath, projectPath)) {
       return note;
     }
@@ -42675,7 +42743,7 @@ function readRunRecord(projectPath) {
     if (own !== null) {
       return own;
     }
-    const shared = recordAt(join24(directory, "runs", SHARED_NOTE));
+    const shared = recordAt(join25(directory, "runs", SHARED_NOTE));
     if (shared !== null && shared.projectPath !== "" && isSameDirectory(shared.projectPath, projectPath)) {
       return shared;
     }
@@ -42687,13 +42755,13 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync10(join24(directory, "runs"));
+      entries = readdirSync10(join25(directory, "runs"));
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry === SHARED_NOTE || entry.startsWith("note-") && entry.endsWith(".json")) {
-        const record = recordAt(join24(directory, "runs", entry));
+        const record = recordAt(join25(directory, "runs", entry));
         if (record !== null) {
           found.push(record);
         }
@@ -42903,7 +42971,7 @@ function judgeAnnouncedGame(running, projectPath, announcedAt) {
 }
 function clearRunRecord(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const shared = join24(directory, "runs", SHARED_NOTE);
+    const shared = join25(directory, "runs", SHARED_NOTE);
     const sharedRecord = recordAt(shared);
     const ours = sharedRecord !== null && sharedRecord.projectPath !== "" && isSameDirectory(sharedRecord.projectPath, projectPath);
     for (const path of [runRecordPath(projectPath, directory), ...ours ? [shared] : []]) {
@@ -42915,7 +42983,7 @@ function clearRunRecord(projectPath) {
 }
 function ageMs(path, now) {
   try {
-    return now - statSync8(path).mtimeMs;
+    return now - statSync9(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -42937,7 +43005,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!transcript && !entry.endsWith(".partial")) {
       continue;
     }
-    const path = join24(directory, entry);
+    const path = join25(directory, entry);
     if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
@@ -42958,7 +43026,7 @@ var init_run_record = __esm(() => {
 });
 
 // src/script-origins.ts
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 function unresolvedClassIn(message) {
   return UNRESOLVED.exec(message)?.[1] ?? null;
 }
@@ -43011,7 +43079,7 @@ function checkWithEngine(godotPath, projectPath) {
       const ran = await runEngine(godotPath, [
         "--headless",
         "--log-file",
-        join25(logDir, "engine.log"),
+        join26(logDir, "engine.log"),
         "--path",
         projectPath,
         "--check-only",
@@ -43240,21 +43308,21 @@ var init_server_instructions = __esm(() => {
 import { execFile as execFile5, spawn as spawn4 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
-  appendFileSync,
+  appendFileSync as appendFileSync2,
   closeSync as closeSync2,
   constants,
   copyFileSync,
   existsSync as existsSync20,
   fstatSync,
-  mkdirSync as mkdirSync15,
+  mkdirSync as mkdirSync16,
   openSync as openSync3,
   readdirSync as readdirSync11,
   readFileSync as readFileSync23,
   readSync as readSync2,
   rmdirSync as rmdirSync2,
-  statSync as statSync9
+  statSync as statSync10
 } from "node:fs";
-import { basename as basename7, dirname as dirname19, extname as extname3, isAbsolute as isAbsolute3, join as join26, normalize as normalize2, relative as relative5 } from "node:path";
+import { basename as basename7, dirname as dirname20, extname as extname3, isAbsolute as isAbsolute3, join as join27, normalize as normalize2, relative as relative5 } from "node:path";
 import { setTimeout as delay4 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { promisify as promisify5 } from "node:util";
@@ -43291,11 +43359,11 @@ function writtenFileRefusal(path, rule) {
   if (!rule.extensions.includes(extname3(path).toLowerCase())) {
     return `${named} ${path} does not end in ${rule.extensions.join(" or ")}, which is what ${what} is.`;
   }
-  const directory = realPathOr(dirname19(path));
+  const directory = realPathOr(dirname20(path));
   if (!existsSync20(directory)) {
-    return `${named}'s directory ${dirname19(path)} does not exist; ${what} creates no directories.`;
+    return `${named}'s directory ${dirname20(path)} does not exist; ${what} creates no directories.`;
   }
-  const where = join26(directory, basename7(path));
+  const where = join27(directory, basename7(path));
   const inside = rule.projects.find((project) => project !== "" && isWithinRoot(realPathOr(project), where));
   if (inside !== undefined) {
     return `${named} ${path} is inside the project at ${inside}; ${what} is saved outside it, so it never becomes part of the game.`;
@@ -43816,6 +43884,23 @@ function engineFlagsNote(args) {
   const named = among.join(", ");
   return `${named} ${among.length === 1 ? "is a flag" : "are flags"} the engine reads, and args goes to the game after --, where the engine does not read ${among.length === 1 ? "it" : "them"}. engineArgs hands the engine its own flags; ${among.length === 1 ? "leave it" : "leave them"} in args only for a game that reads ${among.length === 1 ? "that flag" : "those flags"} itself.`;
 }
+function editorAddonMissing(projectPath) {
+  if (!existsSync20(join27(projectPath, "project.godot"))) {
+    return null;
+  }
+  const report = inspectProject(projectPath);
+  const installed = report.addons.some((addon) => addon.name === "gdharness_editor" && addon.installed);
+  if (installed && report.pluginsEnabled.includes("gdharness_editor")) {
+    return null;
+  }
+  return {
+    why: `the gdharness editor addon is not ${installed ? "enabled" : "installed"} in ${projectPath}`,
+    remedies: installed ? [
+      "gdharness setup in the project enables it",
+      "Or enable it under Project Settings, Plugins, in an editor opened by hand"
+    ] : ["gdharness setup in the project installs and enables it"]
+  };
+}
 function opElsewhere(tool, requested) {
   const ops = Object.hasOwn(OPS_ELSEWHERE, tool) ? OPS_ELSEWHERE[tool] : undefined;
   const where = ops !== undefined && typeof requested === "string" && Object.hasOwn(ops, requested) ? ops[requested] : undefined;
@@ -44036,7 +44121,7 @@ function profileFrameFunctions(projectPath) {
   let projectGodot = null;
   if (projectPath !== null) {
     try {
-      projectGodot = readFileSync23(join26(projectPath, "project.godot"), "utf8");
+      projectGodot = readFileSync23(join27(projectPath, "project.godot"), "utf8");
     } catch {}
   }
   return frameFunctionsFor(queuedMessagesOf(projectGodot));
@@ -44210,7 +44295,7 @@ function foldedEntriesAnswer(log, floor = "warning") {
 }
 function gdUnitFailsOnScriptErrors(projectPath) {
   try {
-    return settingKeys(readFileSync23(join26(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
+    return settingKeys(readFileSync23(join27(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
   } catch {
     return true;
   }
@@ -44225,7 +44310,7 @@ function uncaughtNote(uncaught) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync20(join26(projectPath, wanted))) {
+  if (wanted === "" || existsSync20(join27(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -44315,13 +44400,13 @@ function scriptsToDiagnose(projectPath, given) {
 }
 function isDirectory(path) {
   try {
-    return statSync9(path).isDirectory();
+    return statSync10(path).isDirectory();
   } catch {
     return false;
   }
 }
 function scriptsUnder(directory, prefix) {
-  if (existsSync20(join26(directory, ".gdignore"))) {
+  if (existsSync20(join27(directory, ".gdignore"))) {
     return [];
   }
   const found = [];
@@ -44331,7 +44416,7 @@ function scriptsUnder(directory, prefix) {
     }
     const path = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
     if (entry.isDirectory()) {
-      found.push(...scriptsUnder(join26(directory, entry.name), path));
+      found.push(...scriptsUnder(join27(directory, entry.name), path));
     } else if (entry.isFile() && entry.name.endsWith(".gd")) {
       found.push(path);
     }
@@ -44347,7 +44432,7 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync23(join26(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
+    return readFileSync23(join27(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
@@ -44372,7 +44457,7 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   stdio = null;
   locator = new GodotLocator;
-  operationsScript = join26(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join27(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -44396,6 +44481,11 @@ class GodotServer {
   launchedFrom = null;
   launchedDropped = null;
   closedHere = null;
+  inFlight = new Map;
+  callsTaken = 0;
+  clientNoted = null;
+  parentCommand = null;
+  endNoted = false;
   ownProject;
   announcedAt = null;
   handingOverFrom = null;
@@ -44432,6 +44522,7 @@ class GodotServer {
     return { content: [{ type: "text", text: answerJson(payload) }] };
   }
   async run() {
+    this.noteTheStart();
     const located = await this.locator.find();
     if (!located.ok) {
       console.error(`[SERVER] ${GodotLocator.refusal(located).message} Until that is fixed every tool that runs the engine will say so.`);
@@ -44548,6 +44639,7 @@ class GodotServer {
         return;
       }
       console.error(`[SERVER] pid ${successor} now serves ${this.ownProject}; this server is finished and is stopping.`);
+      this.noteTheEnd("superseded", { successor });
       this.handleShutdown(`superseded by ${successor}`, 0);
     }, SUCCESSOR_CHECK_MS);
     watch.unref();
@@ -44619,10 +44711,67 @@ class GodotServer {
     }
     await this.stdio?.close();
   }
+  noteTheStart() {
+    const cwd = process.cwd();
+    const mcpJson = join27(cwd, ".mcp.json");
+    const announced = this.ownProject === null ? null : readAnnouncement(announcementPath(this.ownProject));
+    const predecessor = announced !== null && announced.pid !== process.pid && alive(announced.pid) ? announced.pid : null;
+    writeLifecycle("started", {
+      argv: process.argv.slice(1),
+      cwd,
+      project: this.ownProject,
+      mcpJson: existsSync20(mcpJson) ? mcpJson : null
+    });
+    if (predecessor !== null) {
+      writeLifecycle("replaced", { project: this.ownProject, predecessor });
+    }
+    const ask = setTimeout(() => {
+      processTree().then((tree) => {
+        this.parentCommand = tree?.get(process.ppid)?.command ?? null;
+        writeLifecycle("parent", {
+          command: this.parentCommand,
+          ...tree === undefined ? { why: whyTheProcessTreeFailed() } : {}
+        });
+      });
+    }, PARENT_ASKED_AFTER_MS);
+    ask.unref();
+  }
+  noteTheEnd(cause, more = {}) {
+    if (this.endNoted) {
+      return;
+    }
+    this.endNoted = true;
+    writeLifecycle("ended", {
+      cause,
+      project: this.ownProject,
+      ...this.parentCommand === null ? {} : { parentCommand: this.parentCommand },
+      ...this.clientNoted === null ? {} : { client: this.clientNoted },
+      inFlight: callsInFlight(this.inFlight.values()),
+      ...more
+    });
+  }
+  noteTheClient(client) {
+    if (client === undefined) {
+      return;
+    }
+    const said = `${client.name} ${client.version}`;
+    if (said === this.clientNoted) {
+      return;
+    }
+    this.clientNoted = said;
+    writeLifecycle("client", { client: { name: client.name, version: client.version } });
+  }
   setupShutdownHandlers() {
     const requestShutdown = (source, exitCode) => {
       this.handleShutdown(source, exitCode);
     };
+    process.on("uncaughtException", (error, origin) => {
+      this.noteTheEnd(origin === "unhandledRejection" ? "unhandledRejection" : "uncaughtException", {
+        error: error instanceof Error ? error.stack ?? error.message : String(error)
+      });
+      console.error(error);
+      process.exit(1);
+    });
     process.once("SIGINT", () => {
       requestShutdown("SIGINT", 0);
     });
@@ -44635,7 +44784,8 @@ class GodotServer {
     process.once("beforeExit", (code) => {
       requestShutdown(`beforeExit:${code}`);
     });
-    process.once("exit", () => {
+    process.once("exit", (code) => {
+      this.noteTheEnd(`exit:${code}`);
       this.forceCleanupOnExit();
     });
   }
@@ -44644,6 +44794,7 @@ class GodotServer {
       return;
     }
     this.shutdownInitiated = true;
+    this.noteTheEnd(source);
     this.logDebug(`Shutting down server via ${source}`);
     try {
       await this.cleanup();
@@ -44683,9 +44834,23 @@ class GodotServer {
     return mcp;
   }
   setupToolHandlers(protocol) {
-    protocol.setRequestHandler("tools/list", () => ({ tools: this.tools }));
+    const clientOf = (envelope) => {
+      const named = envelope?.["io.modelcontextprotocol/clientInfo"];
+      if (typeof named === "object" && named !== null) {
+        const { name, version } = named;
+        if (typeof name === "string" && typeof version === "string") {
+          return { name, version };
+        }
+      }
+      return protocol.getClientVersion();
+    };
+    protocol.setRequestHandler("tools/list", (_request, ctx) => {
+      this.noteTheClient(clientOf(ctx.mcpReq.envelope));
+      return { tools: this.tools };
+    });
     protocol.setRequestHandler("tools/call", async (request, ctx) => {
       this.logDebug(`Handling tool request: ${request.params.name}`);
+      this.noteTheClient(clientOf(ctx.mcpReq.envelope));
       const spec = toolSpec(request.params.name);
       if (!spec) {
         throw new ProtocolError(ProtocolErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}. Tools: ${TOOL_SPECS.map((tool) => tool.name).join(", ")}`);
@@ -44696,7 +44861,7 @@ class GodotServer {
         return checked.response;
       }
       const named = args["projectPath"];
-      if (typeof named === "string" && existsSync20(join26(named, "project.godot"))) {
+      if (typeof named === "string" && existsSync20(join27(named, "project.godot"))) {
         this.lastProjectPath = named;
       }
       this.updates.refresh();
@@ -44709,8 +44874,14 @@ class GodotServer {
           this.logDebug(`Progress for ${spec.name} was not sent: ${errorMessage(error)}`);
         });
       };
-      const answer = await withCallSignal(ctx.mcpReq.signal, () => this.answered(spec.name, checked.op ?? "", args), progress);
-      return this.withFeedbackNotice(this.withUpdateNotice(answer));
+      const call = this.callsTaken++;
+      this.inFlight.set(call, { tool: spec.name, op: checked.op ?? "", startedAt: Date.now() });
+      try {
+        const answer = await withCallSignal(ctx.mcpReq.signal, () => this.answered(spec.name, checked.op ?? "", args), progress);
+        return this.withFeedbackNotice(this.withUpdateNotice(answer));
+      } finally {
+        this.inFlight.delete(call);
+      }
     });
   }
   async answered(tool, op, args) {
@@ -44929,10 +45100,12 @@ class GodotServer {
           ]);
         }
         if (!this.godotBridge.isConnected()) {
-          return this.createErrorResponse(`${tool} ${op} was asked of the editor, and no editor has reached this server.`, [
-            "editor_status says whether the bridge is up and whether an editor may yet connect",
-            'Open the project with editor_launch, or pass from: "disk" to read the file instead'
+          const refused = await this.noEditorYet(answerable, [
+            `${tool} ${op} was asked of the editor; from: "disk" reads the file instead`
           ]);
+          if (refused !== null) {
+            return refused;
+          }
         }
         const { op: _dropped, ...asks } = answerable;
         const contained = this.containProjectFiles(asks);
@@ -45017,11 +45190,11 @@ class GodotServer {
       case "script_info":
         switch (op) {
           case "symbols":
-            return await this.handleLSP("lsp_get_symbols", args);
+            return await this.askScriptInfo("lsp_get_symbols", "Symbols", args);
           case "completion":
-            return await this.handleLSP("lsp_get_completions", args);
+            return await this.askScriptInfo("lsp_get_completions", "Completion", args);
           default:
-            return await this.handleLSP("lsp_get_hover", args);
+            return await this.askScriptInfo("lsp_get_hover", "Hover", args);
         }
       case "script_diagnostics":
         return await this.handleScriptDiagnostics(args);
@@ -45198,7 +45371,7 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join26(path, "project.godot");
+    const file = join27(path, "project.godot");
     if (!existsSync20(file)) {
       return {
         ok: false,
@@ -45885,18 +46058,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname19(output.absolutePath);
+    const folder = dirname20(output.absolutePath);
     try {
-      mkdirSync15(folder, { recursive: true });
+      mkdirSync16(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname19(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname20(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
     const exportLogs = scratchDirectory("export");
     const exportArgs = [
       "--headless",
       "--log-file",
-      join26(exportLogs, "engine.log"),
+      join27(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -45904,7 +46077,7 @@ class GodotServer {
       output.absolutePath
     ];
     this.logDebug(`Exporting: ${engine.value} ${exportArgs.join(" ")}`);
-    const writtenAt = () => existsSync20(output.absolutePath) ? statSync9(output.absolutePath).mtimeMs : null;
+    const writtenAt = () => existsSync20(output.absolutePath) ? statSync10(output.absolutePath).mtimeMs : null;
     const before = writtenAt();
     let ending;
     try {
@@ -45968,10 +46141,10 @@ class GodotServer {
     if (movie !== null) {
       return this.createErrorResponse(movie);
     }
-    const missing = paths.value.filter((path) => !existsSync20(join26(project.value.path, path.slice("res://".length))));
+    const missing = paths.value.filter((path) => !existsSync20(join27(project.value.path, path.slice("res://".length))));
     const asked = paths.value.filter((path) => !missing.includes(path));
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    const noRunner = !existsSync20(join26(project.value.path, runner));
+    const noRunner = !existsSync20(join27(project.value.path, runner));
     if (asked.length === 0) {
       const verdict = `nothing at ${missing.join(" and ")}`;
       const andNoRunner = noRunner ? `, and gdUnit4 is not installed in this project: no ${runner}` : "";
@@ -46062,21 +46235,21 @@ class GodotServer {
       await untilGone([run.process.pid]);
     }
     await run.settled;
-    const reportsDir = join26(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join27(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
       const written = existsSync20(reportsDir) ? readdirSync11(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
       const newest = written.at(-1);
       if (newest !== undefined) {
-        report = parseJUnit(readFileSync23(join26(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync23(join27(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
     } finally {
       discard(reportsDir, userData);
       try {
-        rmdirSync2(dirname19(reportsDir));
+        rmdirSync2(dirname20(reportsDir));
       } catch {}
     }
     const engineEntries = foldedRepeats(run.log.select({
@@ -46308,31 +46481,9 @@ class GodotServer {
   async diagnosticsOf(args) {
     const answer = await this.handleLSP("lsp_get_diagnostics", args);
     const payload = asParams(JSON.parse(answer.content[0]?.text ?? "{}"));
-    if (payload["error"] !== undefined) {
-      const reason = typeof payload["error"] === "string" ? payload["error"] : JSON.stringify(payload["error"]);
-      if (payload["refusedArguments"] === true) {
-        return { refusal: this.createErrorResponse(reason), perScript: true };
-      }
-      if (payload["stillReading"] === true) {
-        return { refusal: this.createErrorResponse(`Diagnostics unavailable: ${reason}`), perScript: false };
-      }
-      if (typeof payload["serves"] === "string") {
-        return {
-          refusal: this.createErrorResponse(`Diagnostics unavailable: ${reason}`, [
-            "editor_status names the editor on the bridge and the port it says it serves",
-            "editor_launch opens this project's own editor, on a language server port of its own",
-            "GDHARNESS_LSP_PORT points this server at the right one"
-          ]),
-          perScript: false
-        };
-      }
-      return {
-        refusal: this.createErrorResponse(`Diagnostics unavailable: ${reason}`, [
-          `Ensure the Godot editor is running with its language server enabled, on port ${this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT)}`,
-          "GDHARNESS_LSP_PORT points this server at another one"
-        ]),
-        perScript: payload["aboutThisFile"] === true
-      };
+    const refused = this.languageServerRefusal(payload, "Diagnostics");
+    if (refused !== null) {
+      return refused;
     }
     const diagnostics = readArray(payload, "diagnostics") ?? [];
     const errors = diagnostics.filter((entry) => asParams(entry)["severity"] === "error").length;
@@ -46439,6 +46590,40 @@ class GodotServer {
   async handleLSP(toolName, args) {
     return handleLSPTool(await this.lsp(), toolName, args);
   }
+  async askScriptInfo(toolName, asked, args) {
+    const answer = await this.handleLSP(toolName, args);
+    const refused = this.languageServerRefusal(asParams(JSON.parse(answer.content[0]?.text ?? "{}")), asked);
+    return refused === null ? answer : refused.refusal;
+  }
+  languageServerRefusal(payload, asked) {
+    if (payload["error"] === undefined) {
+      return null;
+    }
+    const reason = typeof payload["error"] === "string" ? payload["error"] : JSON.stringify(payload["error"]);
+    if (payload["refusedArguments"] === true) {
+      return { refusal: this.createErrorResponse(reason), perScript: true };
+    }
+    if (payload["stillReading"] === true) {
+      return { refusal: this.createErrorResponse(`${asked} unavailable: ${reason}`), perScript: false };
+    }
+    if (typeof payload["serves"] === "string") {
+      return {
+        refusal: this.createErrorResponse(`${asked} unavailable: ${reason}`, [
+          "editor_status names the editor on the bridge and the port it says it serves",
+          "editor_launch opens this project's own editor, on a language server port of its own",
+          "GDHARNESS_LSP_PORT points this server at the right one"
+        ]),
+        perScript: false
+      };
+    }
+    return {
+      refusal: this.createErrorResponse(`${asked} unavailable: ${reason}`, [
+        `Ensure the Godot editor is running with its language server enabled, on port ${this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT)}`,
+        "GDHARNESS_LSP_PORT points this server at another one"
+      ]),
+      perScript: payload["aboutThisFile"] === true
+    };
+  }
   async lsp() {
     const port = this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT);
     if (this.lspClient !== null && this.lspClient.port !== port) {
@@ -46539,7 +46724,7 @@ class GodotServer {
       return;
     }
     try {
-      appendFileSync(run.transcript, line.endsWith(`
+      appendFileSync2(run.transcript, line.endsWith(`
 `) ? line : `${line}
 `);
     } catch (error) {
@@ -46750,7 +46935,8 @@ class GodotServer {
           serverSpeaks: RUNTIME_PROTOCOL,
           behind: game.protocol > RUNTIME_PROTOCOL ? "server" : "addon"
         }))
-      }
+      },
+      server: { pid: process.pid, version: SERVER_VERSION, lifecycleLog: lifecycleLogPath() }
     });
   }
   async editorServersListening() {
@@ -46782,7 +46968,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync23(join26(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync23(join27(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -46838,6 +47024,10 @@ class GodotServer {
   async handleCloseEditor() {
     const before = this.godotBridge.getStatus();
     if (!before.connected) {
+      const launched = this.launchedEditor;
+      if (launched !== null && await this.launchedEditorIsUp() && !this.godotBridge.isConnected()) {
+        return await this.stopTheLaunchedEditor(launched);
+      }
       return this.createErrorResponse("No editor is connected, so there is nothing to close.", [
         "editor_status says whether the bridge is up and what has reached it"
       ]);
@@ -46871,6 +47061,31 @@ class GodotServer {
       tookMs: Date.now() - began
     });
   }
+  async stopTheLaunchedEditor(launched) {
+    const began = Date.now();
+    try {
+      process.kill(launched.pid);
+    } catch (error) {
+      if (alive(launched.pid)) {
+        return this.createErrorResponse(`The editor this server opened, pid ${launched.pid}, has not connected, and stopping it failed: ${errorMessage(error)}`, ["editor_status says whether it has since connected"]);
+      }
+    }
+    const stopWaitMs = 1e4;
+    if (!await this.waitForBridge(() => !alive(launched.pid), began + stopWaitMs)) {
+      return this.createErrorResponse(`The editor this server opened, pid ${launched.pid}, had not connected and was told to stop, and is still running after ${stopWaitMs / 1000}s.`, ["editor_status says whether it has since connected"]);
+    }
+    this.closedHere = { editorPid: launched.pid, at: new Date().toISOString() };
+    this.launchedEditor = null;
+    this.launchedFrom = null;
+    return this.jsonTextResponse({
+      closed: true,
+      editorPid: launched.pid,
+      projectPath: launched.projectPath,
+      beforeConnecting: true,
+      note: "It had not reached the bridge, so it was stopped rather than asked to save and quit, and held nothing of this server's to save.",
+      tookMs: Date.now() - began
+    });
+  }
   settleTheLaunchReading() {
     const watched = this.launchedFrom;
     const status = this.godotBridge.getStatus();
@@ -47006,13 +47221,9 @@ class GodotServer {
         `editor_launch with projectPath ${this.ownProject} opens the editor this server serves`
       ]);
     }
-    const report = inspectProject(projectPath);
-    const installed = report.addons.some((addon) => addon.name === "gdharness_editor" && addon.installed);
-    if (!installed || !report.pluginsEnabled.includes("gdharness_editor")) {
-      return this.createErrorResponse(`The gdharness editor addon is not ${installed ? "enabled" : "installed"} in ${projectPath}, so an editor opened on it would never reach this server.`, installed ? [
-        "gdharness setup in the project enables it",
-        "Or enable it under Project Settings, Plugins, in an editor opened by hand"
-      ] : ["gdharness setup in the project installs and enables it"]);
+    const missing = editorAddonMissing(projectPath);
+    if (missing !== null) {
+      return this.createErrorResponse(`${missing.why}, so an editor opened on it would never reach this server.`, missing.remedies);
     }
     const owed = restartOwed(projectPath);
     if (owed !== null && restartUnderway(owed)) {
@@ -47040,7 +47251,8 @@ class GodotServer {
     writeEditorLogNote(projectPath, launched.pid);
     this.launchedEditor = {
       pid: launched.pid,
-      startedAt: (await startTimesOf([launched.pid])).get(launched.pid) ?? null
+      startedAt: (await startTimesOf([launched.pid])).get(launched.pid) ?? null,
+      projectPath
     };
     this.closedHere = null;
     return { pid: launched.pid, error: null };
@@ -47177,7 +47389,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync20(join26(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync20(join27(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, {
         addon: false,
         budgetMs,
@@ -47262,7 +47474,7 @@ class GodotServer {
     }
     let announcedAt;
     try {
-      announcedAt = statSync9(endpoint.file).mtimeMs;
+      announcedAt = statSync10(endpoint.file).mtimeMs;
     } catch {
       return;
     }
@@ -47431,7 +47643,7 @@ class GodotServer {
         return;
       }
       if (game.transcript !== null) {
-        appendFileSync(game.transcript, reported);
+        appendFileSync2(game.transcript, reported);
       } else {
         game.log.append("stderr", reported);
       }
@@ -48135,7 +48347,7 @@ class GodotServer {
     }
     const going = await this.runStillGoing(run);
     const projectPath = run.projectPath;
-    const projectGone = projectPath !== null && !existsSync20(join26(projectPath, "project.godot"));
+    const projectGone = projectPath !== null && !existsSync20(join27(projectPath, "project.godot"));
     if (projectGone && callersName !== undefined) {
       return this.createErrorResponse(`callersOf reads the project's scripts, and the run's project at ${projectPath} has no project.godot any more.`, ["editor_run profile without callersOf answers with the profile itself"]);
     }
@@ -48306,7 +48518,11 @@ class GodotServer {
     if (!greeted && launched === null && status.connected) {
       return this.createErrorResponse("The editor has connected and has not yet said who it is, so whose console to read cannot be told yet.", ["Ask again in a moment; editor_status shows greeting until it has"]);
     }
-    const projectPath = status.projectPath ?? this.ownProject ?? undefined;
+    const projectPath = status.projectPath ?? this.launchedEditor?.projectPath ?? this.ownProject ?? undefined;
+    const elsewhere = this.anotherProjectNamed(args, projectPath);
+    if (elsewhere !== null) {
+      return elsewhere;
+    }
     if (projectPath === undefined || !greeted && launched === null) {
       return this.createErrorResponse("No editor is connected, so there is no console to read.", [
         "editor_status says whether one is connected and whether it may yet be",
@@ -48357,6 +48573,19 @@ class GodotServer {
       omitted: selected.omitted === 0 ? undefined : selected.omitted
     });
   }
+  anotherProjectNamed(args, ofWhatIsRead) {
+    const named = readNonEmptyString(args, "projectPath");
+    if (named === undefined || ofWhatIsRead === null || ofWhatIsRead === undefined || ofWhatIsRead === "") {
+      return null;
+    }
+    if (isSameDirectory(named, ofWhatIsRead)) {
+      return null;
+    }
+    return this.createErrorResponse(`editor_output reads what this server holds, which is of ${ofWhatIsRead}, and this call names ${named}.`, [
+      "Another project's run is read through that project's own gdharness server",
+      "editor_status names every game running on the machine under runtimes"
+    ]);
+  }
   async handleGetDebugOutput(args, waitedMs) {
     if (readString(args, "op") === "editor") {
       return this.handleEditorConsole(args);
@@ -48366,6 +48595,10 @@ class GodotServer {
     if (!run) {
       return this.createErrorResponse(this.nothingOfOursIsRunning());
     }
+    const elsewhere = this.anotherProjectNamed(args, run.projectPath ?? this.godotBridge.getStatus().projectPath);
+    if (elsewhere !== null) {
+      return elsewhere;
+    }
     await this.tieThePlayedGame(run);
     this.drainEditorOutput(run);
     this.drainTranscript(run);
@@ -48402,7 +48635,7 @@ class GodotServer {
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync20(join26(run.projectPath, RUNTIME_AUTOLOAD.path)),
+        couldAnnounce: run.projectPath !== null && existsSync20(join27(run.projectPath, RUNTIME_AUTOLOAD.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -49182,15 +49415,47 @@ class GodotServer {
     const holds = held["classes"].map(String);
     return { unseen: unseenByEditor(projectPath, holds), stillHeld: heldButGone(projectPath, holds) };
   }
+  async noEditorYet(args, instead) {
+    const project = readNonEmptyString(args, "projectPath") ?? this.ownProject;
+    const missing = project === null ? null : editorAddonMissing(project);
+    if (missing !== null) {
+      return this.createErrorResponse(`Editor not connected, and no editor of this project can connect: ${missing.why}.`, [...instead, ...missing.remedies, "editor_launch then opens an editor that connects"]);
+    }
+    const launched = this.launchedEditor;
+    if (launched !== null && await this.launchedEditorIsUp()) {
+      const began = Date.now();
+      await this.waitForBridge(() => hasSaidWhoItIs(this.godotBridge.getStatus()) || !alive(launched.pid), began + editorRestartTimeoutMs());
+      if (this.godotBridge.isConnected()) {
+        return null;
+      }
+      const opened = `the editor this server opened on ${launched.projectPath}, pid ${launched.pid}`;
+      if (alive(launched.pid)) {
+        return this.createErrorResponse(`Editor not connected: ${opened}, is still running and has not reached the bridge in the ${String(Math.round((Date.now() - began) / 1000))}s this call waited. An editor dials in once it has imported the project and loaded its plugins, and the first open of a large project imports for minutes.`, [
+          ...instead,
+          "editor_status names it under awaitingLaunchedEditor until it has connected",
+          "editor_output op editor shows what it is printing meanwhile"
+        ]);
+      }
+      return this.createErrorResponse(`Editor not connected: ${opened}, exited without reaching the bridge.`, [
+        ...instead,
+        "editor_output op editor shows what it printed before it went",
+        "editor_launch open starts another"
+      ]);
+    }
+    return this.createErrorResponse("Editor not connected: no Godot editor with the gdharness editor addon has reached this server.", [
+      ...instead,
+      "Open the project in the editor with editor_launch, or by hand",
+      "Enable the addon under Project > Project Settings > Plugins",
+      "editor_status says whether the bridge is up and what it is listening on"
+    ]);
+  }
   async handleViaBridge(toolName, args, askedAs) {
     if (!this.godotBridge.isConnected()) {
-      const instead = askedAs !== undefined && Object.hasOwn(EDITOR_FREE_INSTEAD, askedAs) ? EDITOR_FREE_INSTEAD[askedAs] : undefined;
-      return this.createErrorResponse("Editor not connected: no Godot editor with the gdharness editor addon has reached this server.", [
-        ...instead === undefined ? [] : [instead],
-        "Open the project in the editor with editor_launch, or by hand",
-        "Enable the addon under Project > Project Settings > Plugins",
-        "editor_status says whether the bridge is up and what it is listening on"
-      ]);
+      const alternative = askedAs !== undefined && Object.hasOwn(EDITOR_FREE_INSTEAD, askedAs) ? EDITOR_FREE_INSTEAD[askedAs] : undefined;
+      const refused = await this.noEditorYet(args, alternative === undefined ? [] : [alternative]);
+      if (refused !== null) {
+        return refused;
+      }
     }
     const open = this.godotBridge.getStatus().projectPath;
     const meant = readNonEmptyString(args, "projectPath");
@@ -49263,7 +49528,7 @@ class GodotServer {
   async ownRunOnItsWay(projectPath, budgetMs) {
     const run = await this.currentRun();
     const project = projectPath ?? run?.projectPath ?? null;
-    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync20(join26(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync20(join27(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -49272,7 +49537,7 @@ class GodotServer {
         return !run.announcedBefore.has(one.pid);
       }
       try {
-        return statSync9(one.file).mtimeMs >= run.startedAt;
+        return statSync10(one.file).mtimeMs >= run.startedAt;
       } catch {
         return false;
       }
@@ -49348,7 +49613,7 @@ class GodotServer {
       }
     }
     const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
-    const screenshotPath = screenshotDir ? join26(screenshotDir, "capture.png") : null;
+    const screenshotPath = screenshotDir ? join27(screenshotDir, "capture.png") : null;
     const staleNote = this.runtimeStaleNote(choice.endpoint);
     const stale = staleNote === undefined ? {} : { addonIsStale: true, staleNote };
     const refused = (message) => this.createErrorResponse(staleNote === undefined ? message : `${message}
@@ -49499,7 +49764,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run4, __dirname2, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, EDITOR_FREE_INSTEAD, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run4, __dirname2, PARENT_ASKED_AFTER_MS = 5000, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, EDITOR_FREE_INSTEAD, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
 var init_server = __esm(() => {
   init_dist();
   init_stdio();
@@ -49528,6 +49793,7 @@ var init_server = __esm(() => {
   init_junit();
   init_keeper_channel();
   init_launch();
+  init_lifecycle_log();
   init_lsp_client();
   init_outside();
   init_paths();
@@ -49553,7 +49819,7 @@ var init_server = __esm(() => {
   init_tool_reference();
   init_update_check();
   run4 = promisify5(execFile5);
-  __dirname2 = dirname19(fileURLToPath5(import.meta.url));
+  __dirname2 = dirname20(fileURLToPath5(import.meta.url));
   CONSOLE_WRAPPER = /_console(\.exe)?$/i;
   LONGEST_BOOT_NOTED_MS = 5 * 60000;
   VALUE_NAMES = {
@@ -49612,7 +49878,7 @@ init_bridge_announce();
 init_errors();
 init_godot_path();
 import { existsSync as existsSync21 } from "node:fs";
-import { join as join27, resolve as resolve8 } from "node:path";
+import { join as join28, resolve as resolve8 } from "node:path";
 
 // src/harnesses.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
@@ -50773,7 +51039,9 @@ emptily: no game running, a game with no debugger behind it, a game running rath
 control outside a headless viewport. Read the refusal instead of retrying the call.
 
 Every answer is read back from the engine after the change rather than echoed from the request, and
-whatever the engine said on stderr comes back under \`engine_messages\`.
+whatever the engine said on stderr comes back under \`engine_messages\`. A headless engine runs the
+project's autoloads after the operation has answered, and what it reports from then until it exits
+comes back separately, under \`engine_messages_after_answer\`: none of it changes the answer.
 
 ## More
 
@@ -50875,7 +51143,7 @@ class UsageError extends Refusal {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve8(named ?? ".");
-  if (!existsSync21(join27(projectPath, "project.godot"))) {
+  if (!existsSync21(join28(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -50920,7 +51188,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync21(join27(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync21(join28(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
     console.log(`  that file is not in this project, so it boots with a missing script: restore it, or point the entry at res://${RUNTIME_AUTOLOAD.path}`);
   }
 }