gdharness 0.13.28 → 0.13.30

package/build/cli.js

@@ -7626,7 +7626,7 @@ function staleAnalysisNote(contradicted, dependsOn) {
   const types = new Set(contradicted.map((one) => one.type));
   const declaring = [...new Set(contradicted.map((one) => one.declaredIn))].sort();
   const lever = dependsOn.length === 0 ? ", and the named types depend on no other global class, so that lever is not available here. " + "That is the common case rather than the awkward one: an edit near a type that depends on " + "something refreshes it before the fault is noticed, which is why a type with no " + "dependencies is where this turns up" : `, so changing ${[...dependsOn].sort().join(", ")} and rescanning is worth a try`;
-  return `The editor is reporting against an older copy of ${types.size === 1 ? "a type" : "some types"} ` + "named under contradictedByTheFile. Each member listed is declared in the file the class cache " + "points at, so those diagnostics are wrong however the code is written. Run editor_rescan first: " + "it costs about half a second, it cleared this in one of five attempts in the project that " + "reported it, and it cleared both reproductions measured in a second project, the scan itself " + "returning in 243ms and 275ms. " + "The fault behind it is that a script the editor has loaded keeps the copy it built, and nothing " + `rebuilds that copy when the file changes; ${declaring.length === 1 ? `editor_rescan with reloadScript set to ${declaring[0]} recompiles that copy` : `reloadScript takes one script, so a call each for ${declaring.join(" and ")} recompiles those copies`} from the file into the same ` + "object and answers with the members it has afterwards under reloadedMethods. Read that and the " + "next diagnostics as two readings, because they are of two things: measured in one window on " + "one editor, the analyser resolved a call to a newly added method while the built copy of that " + "same script did not have it. So the reload is worth doing and is not what clears these; the " + "scan is. The other lever measured is that a held type is refreshed when something it " + `depends on changes rather than when it changes itself${lever}. editor_launch restart has always ` + "worked and costs a window. project_import refresh_classes does not, and answers added: [] while " + "this is happening.";
+  return `The editor is reporting against an older copy of ${types.size === 1 ? "a type" : "some types"} ` + "named under contradictedByTheFile. Each member listed is declared in the file the class cache " + "points at, so those diagnostics are wrong however the code is written. Run editor_rescan first: " + "it costs about half a second, and it has cleared this in every reproduction measured since the " + "scan timing was fixed: both in one project, the scan returning in 243ms and 275ms, and one in " + "another where the same call also rebuilt the copy. " + "The fault behind it is that a script the editor has loaded keeps the copy it built, and nothing " + `rebuilds that copy when the file changes; ${declaring.length === 1 ? `editor_rescan with reloadScript set to ${declaring[0]} recompiles that copy` : `reloadScript takes one script, so a call each for ${declaring.join(" and ")} recompiles those copies`} from the file into the same ` + "object and answers with the members it has afterwards under reloadedMethods. Read that and the " + "next diagnostics as two readings, because they are of two things: measured in one window on " + "one editor, the analyser resolved a call to a newly added method while the built copy of that " + "same script did not have it. So the reload is worth doing and is not what clears these; the " + "scan is. The other lever measured is that a held type is refreshed when something it " + `depends on changes rather than when it changes itself${lever}. editor_launch restart has always ` + "worked and costs a window. project_import refresh_classes does not, and answers added: [] while " + "this is happening.";
 }
 function uncachedClassNote(types) {
   if (types.length === 0) {
@@ -15044,6 +15044,16 @@ function settingKeys(content) {
   }
   return named;
 }
+function settingsDroppedReport(before, after) {
+  const dropped = [...before].filter(([key]) => !after.has(key));
+  if (dropped.length === 0) {
+    return {};
+  }
+  return {
+    settingsDropped: dropped.map(([setting, was]) => ({ setting, was })),
+    settingsNote: `The editor saved project.godot and these keys are no longer in it, with the value each one held. Godot writes only what differs from its own defaults, so a key named deliberately at its default value is redundant to the editor and is dropped on save; it will be dropped again the next time one opens. If any of them were pinned on purpose, to keep "set to this on purpose" and "not set" apart, project_settings set puts one back: ${dropped.map(([setting, was]) => `setting "${setting}" value ${JSON.stringify(was)}`).join(", ")}. Nothing else will say they have gone until something depends on one.`
+  };
+}
 function parseProjectGodot(content) {
   const result = emptyRecord();
   let section = emptyRecord();
@@ -15895,7 +15905,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_launch",
-      description: "Opens the Godot editor on a project, in a window on this machine, or restarts the one already connected. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect; it saves open scenes on the way out and answers with the version that came back. Only an editor with a window can be restarted, 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. A restart saves project.godot on the way out, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped: settingsDropped names any that went, because nothing else will say so until something depends on one.",
+      description: "Opens the Godot editor on a project, in a window on this machine, or restarts the one already connected. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect; it saves open scenes on the way out and answers with the version that came back. Only an editor with a window can be restarted, 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.",
       parameters: { projectPath: { ...PROJECT_PATH, ops: ["open"] } },
       requires: [],
       operations: {
@@ -15985,7 +15995,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_status",
-      description: 'Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means "not reached yet" as often as it means "no editor". True is worth waiting out; false is an editor that is not there. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read.',
+      description: 'Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means "not reached yet" as often as it means "no editor". True is worth waiting out; false is an editor that is not there. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer.',
       parameters: {},
       requires: []
     },
@@ -31408,7 +31418,7 @@ class GodotDAPClient {
       socket.once("error", handleError);
     });
   }
-  async disconnect() {
+  async abandon() {
     if (!this.socket) {
       this.connected = false;
       this.initialized = false;
@@ -31416,11 +31426,6 @@ class GodotDAPClient {
       this.halt = null;
       return;
     }
-    if (this.connected) {
-      try {
-        await this.sendRequest("disconnect", { restart: false });
-      } catch {}
-    }
     await new Promise((resolve) => {
       const socket = this.socket;
       if (!socket) {
@@ -34722,6 +34727,9 @@ function servedPort(said) {
 function mayYetConnect(listeningSince, now = Date.now()) {
   return listeningSince === undefined || now - listeningSince.getTime() < CONNECT_WINDOW_MS;
 }
+function anEditorIsStillComing(listeningSince, launchedEditorIsAlive, now = Date.now()) {
+  return mayYetConnect(listeningSince, now) || launchedEditorIsAlive;
+}
 function getDefaultBridge(ownProject = null) {
   defaultBridge ??= new GodotBridge(resolveDefaultBridgePort(), resolveDefaultBridgeHost(), DEFAULT_TIMEOUT_MS, ownProject);
   return defaultBridge;
@@ -37005,6 +37013,8 @@ class GodotServer {
   successorWatch = null;
   lastProjectPath = null;
   shutdownInitiated = false;
+  launchedEditor = null;
+  launchedFrom = null;
   ownProject;
   announcedAt = null;
   constructor() {
@@ -37158,9 +37168,9 @@ class GodotServer {
     }
     if (this.dapClient) {
       try {
-        await this.dapClient.disconnect();
+        await this.dapClient.abandon();
       } catch (error) {
-        this.logDebug(`DAP client did not disconnect cleanly: ${errorMessage(error)}`);
+        this.logDebug(`DAP client did not let go cleanly: ${errorMessage(error)}`);
       }
       this.dapClient = null;
     }
@@ -38212,6 +38222,9 @@ class GodotServer {
     }
     return `The debug adapter on port ${port} belongs to process ${holder}, and the editor on this server's bridge is process ${ours}. Godot gives every editor the same debug adapter port by default, so the one this editor names in its settings is not necessarily the one it holds. Playing the game now would put another editor's console and another project's debugger under this project's name.`;
   }
+  anEditorIsStillComing(listeningSince) {
+    return anEditorIsStillComing(listeningSince, this.launchedEditor !== null && alive(this.launchedEditor));
+  }
   dap() {
     const port = this.editorServes("dapPort", "GDHARNESS_DAP_PORT", DEFAULT_DAP_PORT);
     if (this.dapClient !== null && this.dapClient.port !== port) {
@@ -38255,7 +38268,9 @@ class GodotServer {
       serverVersion: SERVER_VERSION,
       addonIsStale: status.connected ? stale : undefined,
       bridgeAvailable: this.bridgeStartupError === null,
-      mayYetConnect: status.connected ? undefined : mayYetConnect(status.listeningSince),
+      mayYetConnect: status.connected ? undefined : this.anEditorIsStillComing(status.listeningSince),
+      awaitingLaunchedEditor: status.connected || this.launchedEditor === null || !alive(this.launchedEditor) ? undefined : this.launchedEditor,
+      ...status.connected ? this.whatTheLaunchedEditorDropped() : {},
       startupError: this.bridgeStartupError,
       staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION) : undefined,
       retryingBridge: this.bridgeRetry === null ? undefined : true,
@@ -38352,7 +38367,6 @@ class GodotServer {
     }
     const now = this.godotBridge.getStatus();
     const after = this.settingKeysOf(before.projectPath);
-    const dropped = [...settingsBefore].filter(([key]) => !after.has(key));
     return this.jsonTextResponse({
       restarted: true,
       editorPid: now.editorPid,
@@ -38360,11 +38374,21 @@ class GodotServer {
       serverVersion: SERVER_VERSION,
       addonIsStale: now.addonVersion !== SERVER_VERSION,
       staleNote: addonMismatch(now.addonVersion, SERVER_VERSION),
-      settingsDropped: dropped.length > 0 ? dropped.map(([setting, was]) => ({ setting, was })) : undefined,
-      settingsNote: dropped.length > 0 ? `The editor saved project.godot on its way out and these keys are no longer in it, with the value each one held. Godot writes only what differs from its own defaults, so a key named deliberately at its default value is redundant to the editor and is dropped on save; it will be dropped again on the next restart. If any of them were pinned on purpose, to keep "set to this on purpose" and "not set" apart, project_settings set puts one back: ${dropped.map(([setting, was]) => `setting "${setting}" value ${JSON.stringify(was)}`).join(", ")}. Nothing else will say they have gone until something depends on one.` : undefined,
+      ...this.whatTheEditorDropped(settingsBefore, after),
       tookMs: Date.now() - began
     });
   }
+  whatTheLaunchedEditorDropped() {
+    const watched = this.launchedFrom;
+    if (watched === null) {
+      return {};
+    }
+    this.launchedFrom = null;
+    return this.whatTheEditorDropped(watched.before, this.settingKeysOf(watched.projectPath));
+  }
+  whatTheEditorDropped(before, after) {
+    return settingsDroppedReport(before, after);
+  }
   async startItAgain(projectPath, editorPid) {
     const engine = await this.engine();
     if (!engine.ok) {
@@ -38414,16 +38438,19 @@ class GodotServer {
     }
     this.logDebug(`Launching Godot editor for project: ${project.value.path}`);
     const ports = await this.portsForAnEditor();
+    const before = this.settingKeysOf(project.value.path);
     const opened = await this.openAnEditor(engine.value, project.value.path, ports);
     if (opened.error !== null) {
       return this.createErrorResponse(`Could not start the editor: ${opened.error}`);
     }
+    this.launchedFrom = { projectPath: project.value.path, before };
     return this.jsonTextResponse({
       launched: true,
       pid: opened.pid,
       projectPath: project.value.path,
       lspPort: ports.lsp,
-      dapPort: ports.dap
+      dapPort: ports.dap,
+      settingsNote: before.size === 0 ? undefined : "Opening a project imports it and saves project.godot, and Godot drops any key sitting at its own default. editor_status names anything lost under settingsDropped once this editor has connected."
     });
   }
   async openAnEditor(engine, projectPath, ports) {
@@ -38450,6 +38477,7 @@ class GodotServer {
       return { pid: null, error: started };
     }
     editor.unref();
+    this.launchedEditor = editor.pid ?? null;
     return { pid: editor.pid ?? null, error: null };
   }
   async portsForAnEditor() {
@@ -38836,15 +38864,16 @@ class GodotServer {
     return adopted;
   }
   nothingOfOursIsRunning() {
+    const status = this.godotBridge.getStatus();
+    const noEditor = !status.connected ? " No editor is connected, so a game the editor is playing cannot be seen from here at all:" + " editor_status says whether one is on its way, and a run of yours that is still up is" + " reachable again once it is." : "";
     const record = readRunRecord();
     if (record === null) {
-      return "No game is running. Start one with editor_run.";
+      return `No game is running.${noEditor} Start one with editor_run.`;
     }
-    const status = this.godotBridge.getStatus();
     const mine = this.ownProject ?? (status.connected ? status.projectPath ?? null : null);
     const whose = record.projectPath === "" ? "a project it does not name" : record.projectPath;
     const ours = mine === null ? "this server was started without GDHARNESS_PROJECT and has no editor connected, so it cannot say whose that run is" : `this server serves ${mine}`;
-    return `No game of this server's is running. A run started from ${whose} is recorded on this machine, and ${ours}, so it is not this server's to answer for or to end. Start one with editor_run.`;
+    return `No game of this server's is running.${noEditor} A run started from ${whose} is recorded on this machine, and ${ours}, so it is not this server's to answer for or to end. Start one with editor_run.`;
   }
   couldBeOurs(project) {
     const status = this.godotBridge.getStatus();

package/build/index.js

@@ -24886,7 +24886,7 @@ function staleAnalysisNote(contradicted, dependsOn) {
   const types = new Set(contradicted.map((one) => one.type));
   const declaring = [...new Set(contradicted.map((one) => one.declaredIn))].sort();
   const lever = dependsOn.length === 0 ? ", and the named types depend on no other global class, so that lever is not available here. " + "That is the common case rather than the awkward one: an edit near a type that depends on " + "something refreshes it before the fault is noticed, which is why a type with no " + "dependencies is where this turns up" : `, so changing ${[...dependsOn].sort().join(", ")} and rescanning is worth a try`;
-  return `The editor is reporting against an older copy of ${types.size === 1 ? "a type" : "some types"} ` + "named under contradictedByTheFile. Each member listed is declared in the file the class cache " + "points at, so those diagnostics are wrong however the code is written. Run editor_rescan first: " + "it costs about half a second, it cleared this in one of five attempts in the project that " + "reported it, and it cleared both reproductions measured in a second project, the scan itself " + "returning in 243ms and 275ms. " + "The fault behind it is that a script the editor has loaded keeps the copy it built, and nothing " + `rebuilds that copy when the file changes; ${declaring.length === 1 ? `editor_rescan with reloadScript set to ${declaring[0]} recompiles that copy` : `reloadScript takes one script, so a call each for ${declaring.join(" and ")} recompiles those copies`} from the file into the same ` + "object and answers with the members it has afterwards under reloadedMethods. Read that and the " + "next diagnostics as two readings, because they are of two things: measured in one window on " + "one editor, the analyser resolved a call to a newly added method while the built copy of that " + "same script did not have it. So the reload is worth doing and is not what clears these; the " + "scan is. The other lever measured is that a held type is refreshed when something it " + `depends on changes rather than when it changes itself${lever}. editor_launch restart has always ` + "worked and costs a window. project_import refresh_classes does not, and answers added: [] while " + "this is happening.";
+  return `The editor is reporting against an older copy of ${types.size === 1 ? "a type" : "some types"} ` + "named under contradictedByTheFile. Each member listed is declared in the file the class cache " + "points at, so those diagnostics are wrong however the code is written. Run editor_rescan first: " + "it costs about half a second, and it has cleared this in every reproduction measured since the " + "scan timing was fixed: both in one project, the scan returning in 243ms and 275ms, and one in " + "another where the same call also rebuilt the copy. " + "The fault behind it is that a script the editor has loaded keeps the copy it built, and nothing " + `rebuilds that copy when the file changes; ${declaring.length === 1 ? `editor_rescan with reloadScript set to ${declaring[0]} recompiles that copy` : `reloadScript takes one script, so a call each for ${declaring.join(" and ")} recompiles those copies`} from the file into the same ` + "object and answers with the members it has afterwards under reloadedMethods. Read that and the " + "next diagnostics as two readings, because they are of two things: measured in one window on " + "one editor, the analyser resolved a call to a newly added method while the built copy of that " + "same script did not have it. So the reload is worth doing and is not what clears these; the " + "scan is. The other lever measured is that a held type is refreshed when something it " + `depends on changes rather than when it changes itself${lever}. editor_launch restart has always ` + "worked and costs a window. project_import refresh_classes does not, and answers added: [] while " + "this is happening.";
 }
 function uncachedClassNote(types) {
   if (types.length === 0) {
@@ -25160,7 +25160,7 @@ class GodotDAPClient {
       socket.once("error", handleError);
     });
   }
-  async disconnect() {
+  async abandon() {
     if (!this.socket) {
       this.connected = false;
       this.initialized = false;
@@ -25168,11 +25168,6 @@ class GodotDAPClient {
       this.halt = null;
       return;
     }
-    if (this.connected) {
-      try {
-        await this.sendRequest("disconnect", { restart: false });
-      } catch {}
-    }
     await new Promise((resolve) => {
       const socket = this.socket;
       if (!socket) {
@@ -25761,6 +25756,9 @@ var CONNECT_WINDOW_MS = 35000;
 function mayYetConnect(listeningSince, now = Date.now()) {
   return listeningSince === undefined || now - listeningSince.getTime() < CONNECT_WINDOW_MS;
 }
+function anEditorIsStillComing(listeningSince, launchedEditorIsAlive, now = Date.now()) {
+  return mayYetConnect(listeningSince, now) || launchedEditorIsAlive;
+}
 
 class GodotBridge extends EventEmitter {
   listeningSince = null;
@@ -27732,6 +27730,16 @@ function settingKeys(content) {
   }
   return named;
 }
+function settingsDroppedReport(before, after) {
+  const dropped = [...before].filter(([key]) => !after.has(key));
+  if (dropped.length === 0) {
+    return {};
+  }
+  return {
+    settingsDropped: dropped.map(([setting, was]) => ({ setting, was })),
+    settingsNote: `The editor saved project.godot and these keys are no longer in it, with the value each one held. Godot writes only what differs from its own defaults, so a key named deliberately at its default value is redundant to the editor and is dropped on save; it will be dropped again the next time one opens. If any of them were pinned on purpose, to keep "set to this on purpose" and "not set" apart, project_settings set puts one back: ${dropped.map(([setting, was]) => `setting "${setting}" value ${JSON.stringify(was)}`).join(", ")}. Nothing else will say they have gone until something depends on one.`
+  };
+}
 function parseProjectGodot(content) {
   const result = emptyRecord();
   let section = emptyRecord();
@@ -29002,7 +29010,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_launch",
-    description: "Opens the Godot editor on a project, in a window on this machine, or restarts the one already connected. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect; it saves open scenes on the way out and answers with the version that came back. Only an editor with a window can be restarted, 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. A restart saves project.godot on the way out, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped: settingsDropped names any that went, because nothing else will say so until something depends on one.",
+    description: "Opens the Godot editor on a project, in a window on this machine, or restarts the one already connected. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect; it saves open scenes on the way out and answers with the version that came back. Only an editor with a window can be restarted, 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.",
     parameters: { projectPath: { ...PROJECT_PATH, ops: ["open"] } },
     requires: [],
     operations: {
@@ -29092,7 +29100,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_status",
-    description: 'Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means "not reached yet" as often as it means "no editor". True is worth waiting out; false is an editor that is not there. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read.',
+    description: 'Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means "not reached yet" as often as it means "no editor". True is worth waiting out; false is an editor that is not there. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer.',
     parameters: {},
     requires: []
   },
@@ -29747,6 +29755,8 @@ class GodotServer {
   successorWatch = null;
   lastProjectPath = null;
   shutdownInitiated = false;
+  launchedEditor = null;
+  launchedFrom = null;
   ownProject;
   announcedAt = null;
   constructor() {
@@ -29900,9 +29910,9 @@ class GodotServer {
     }
     if (this.dapClient) {
       try {
-        await this.dapClient.disconnect();
+        await this.dapClient.abandon();
       } catch (error) {
-        this.logDebug(`DAP client did not disconnect cleanly: ${errorMessage(error)}`);
+        this.logDebug(`DAP client did not let go cleanly: ${errorMessage(error)}`);
       }
       this.dapClient = null;
     }
@@ -30954,6 +30964,9 @@ class GodotServer {
     }
     return `The debug adapter on port ${port} belongs to process ${holder}, and the editor on this server's bridge is process ${ours}. Godot gives every editor the same debug adapter port by default, so the one this editor names in its settings is not necessarily the one it holds. Playing the game now would put another editor's console and another project's debugger under this project's name.`;
   }
+  anEditorIsStillComing(listeningSince) {
+    return anEditorIsStillComing(listeningSince, this.launchedEditor !== null && alive(this.launchedEditor));
+  }
   dap() {
     const port = this.editorServes("dapPort", "GDHARNESS_DAP_PORT", DEFAULT_DAP_PORT);
     if (this.dapClient !== null && this.dapClient.port !== port) {
@@ -30997,7 +31010,9 @@ class GodotServer {
       serverVersion: SERVER_VERSION,
       addonIsStale: status.connected ? stale : undefined,
       bridgeAvailable: this.bridgeStartupError === null,
-      mayYetConnect: status.connected ? undefined : mayYetConnect(status.listeningSince),
+      mayYetConnect: status.connected ? undefined : this.anEditorIsStillComing(status.listeningSince),
+      awaitingLaunchedEditor: status.connected || this.launchedEditor === null || !alive(this.launchedEditor) ? undefined : this.launchedEditor,
+      ...status.connected ? this.whatTheLaunchedEditorDropped() : {},
       startupError: this.bridgeStartupError,
       staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION) : undefined,
       retryingBridge: this.bridgeRetry === null ? undefined : true,
@@ -31094,7 +31109,6 @@ class GodotServer {
     }
     const now = this.godotBridge.getStatus();
     const after = this.settingKeysOf(before.projectPath);
-    const dropped = [...settingsBefore].filter(([key]) => !after.has(key));
     return this.jsonTextResponse({
       restarted: true,
       editorPid: now.editorPid,
@@ -31102,11 +31116,21 @@ class GodotServer {
       serverVersion: SERVER_VERSION,
       addonIsStale: now.addonVersion !== SERVER_VERSION,
       staleNote: addonMismatch(now.addonVersion, SERVER_VERSION),
-      settingsDropped: dropped.length > 0 ? dropped.map(([setting, was]) => ({ setting, was })) : undefined,
-      settingsNote: dropped.length > 0 ? `The editor saved project.godot on its way out and these keys are no longer in it, with the value each one held. Godot writes only what differs from its own defaults, so a key named deliberately at its default value is redundant to the editor and is dropped on save; it will be dropped again on the next restart. If any of them were pinned on purpose, to keep "set to this on purpose" and "not set" apart, project_settings set puts one back: ${dropped.map(([setting, was]) => `setting "${setting}" value ${JSON.stringify(was)}`).join(", ")}. Nothing else will say they have gone until something depends on one.` : undefined,
+      ...this.whatTheEditorDropped(settingsBefore, after),
       tookMs: Date.now() - began
     });
   }
+  whatTheLaunchedEditorDropped() {
+    const watched = this.launchedFrom;
+    if (watched === null) {
+      return {};
+    }
+    this.launchedFrom = null;
+    return this.whatTheEditorDropped(watched.before, this.settingKeysOf(watched.projectPath));
+  }
+  whatTheEditorDropped(before, after) {
+    return settingsDroppedReport(before, after);
+  }
   async startItAgain(projectPath, editorPid) {
     const engine = await this.engine();
     if (!engine.ok) {
@@ -31156,16 +31180,19 @@ class GodotServer {
     }
     this.logDebug(`Launching Godot editor for project: ${project.value.path}`);
     const ports = await this.portsForAnEditor();
+    const before = this.settingKeysOf(project.value.path);
     const opened = await this.openAnEditor(engine.value, project.value.path, ports);
     if (opened.error !== null) {
       return this.createErrorResponse(`Could not start the editor: ${opened.error}`);
     }
+    this.launchedFrom = { projectPath: project.value.path, before };
     return this.jsonTextResponse({
       launched: true,
       pid: opened.pid,
       projectPath: project.value.path,
       lspPort: ports.lsp,
-      dapPort: ports.dap
+      dapPort: ports.dap,
+      settingsNote: before.size === 0 ? undefined : "Opening a project imports it and saves project.godot, and Godot drops any key sitting at its own default. editor_status names anything lost under settingsDropped once this editor has connected."
     });
   }
   async openAnEditor(engine, projectPath, ports) {
@@ -31192,6 +31219,7 @@ class GodotServer {
       return { pid: null, error: started };
     }
     editor.unref();
+    this.launchedEditor = editor.pid ?? null;
     return { pid: editor.pid ?? null, error: null };
   }
   async portsForAnEditor() {
@@ -31578,15 +31606,16 @@ class GodotServer {
     return adopted;
   }
   nothingOfOursIsRunning() {
+    const status = this.godotBridge.getStatus();
+    const noEditor = !status.connected ? " No editor is connected, so a game the editor is playing cannot be seen from here at all:" + " editor_status says whether one is on its way, and a run of yours that is still up is" + " reachable again once it is." : "";
     const record = readRunRecord();
     if (record === null) {
-      return "No game is running. Start one with editor_run.";
+      return `No game is running.${noEditor} Start one with editor_run.`;
     }
-    const status = this.godotBridge.getStatus();
     const mine = this.ownProject ?? (status.connected ? status.projectPath ?? null : null);
     const whose = record.projectPath === "" ? "a project it does not name" : record.projectPath;
     const ours = mine === null ? "this server was started without GDHARNESS_PROJECT and has no editor connected, so it cannot say whose that run is" : `this server serves ${mine}`;
-    return `No game of this server's is running. A run started from ${whose} is recorded on this machine, and ${ours}, so it is not this server's to answer for or to end. Start one with editor_run.`;
+    return `No game of this server's is running.${noEditor} A run started from ${whose} is recorded on this machine, and ${ours}, so it is not this server's to answer for or to end. Start one with editor_run.`;
   }
   couldBeOurs(project) {
     const status = this.godotBridge.getStatus();

package/package.json

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