gdharness 0.13.27 → 0.13.29

package/build/cli.js

@@ -7626,7 +7626,14 @@ 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 rather than one: a built copy has been seen stale here while " + "the diagnostics on it read clean, so the reload is worth doing and is not known to be what " + "clears these. 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) {
+    return "";
+  }
+  const one = types.length === 1;
+  return `${types.join(", ")} ${one ? "is declared" : "are declared"} in this project and missing from ` + `.godot/global_script_class_cache.cfg, so a game launched now would not resolve ${one ? "it" : "them"} ` + "either. Try editor_rescan first: it asks the editor already running and starts nothing, and it " + "cleared this in 314ms in a second project with a 31-worker fan-out still importing. It is not " + "always enough, because a file another engine has already imported reads as settled and the " + "walk does not look inside it. project_import refresh_classes rewrites the cache from the " + "declarations on disk and does reach that case, at the cost of a short headless engine, which " + "is worth knowing when something else is already running against this project.";
 }
 function cacheWrittenAt(projectPath) {
   const cache = join6(projectPath, ".godot", "global_script_class_cache.cfg");
@@ -15037,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();
@@ -15978,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: []
     },
@@ -31401,7 +31418,7 @@ class GodotDAPClient {
       socket.once("error", handleError);
     });
   }
-  async disconnect() {
+  async abandon() {
     if (!this.socket) {
       this.connected = false;
       this.initialized = false;
@@ -31409,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) {
@@ -34715,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;
@@ -36998,6 +37013,8 @@ class GodotServer {
   successorWatch = null;
   lastProjectPath = null;
   shutdownInitiated = false;
+  launchedEditor = null;
+  launchedFrom = null;
   ownProject;
   announcedAt = null;
   constructor() {
@@ -37151,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;
     }
@@ -38157,7 +38174,7 @@ class GodotServer {
     }
     const uncached = unloaded.filter((type) => !type.inTheClassCache);
     if (uncached.length > 0) {
-      notes.push(`${uncached.map((type) => type.type).join(", ")} ${uncached.length === 1 ? "is declared" : "are declared"} in this project and missing from .godot/global_script_class_cache.cfg, so a game launched now would not resolve ${uncached.length === 1 ? "it" : "them"} either. project_import refresh_classes rewrites the cache from the declarations on disk.`);
+      notes.push(uncachedClassNote(uncached.map((type) => type.type)));
     }
     const stale = unloaded.filter((type) => type.inTheClassCache);
     if (stale.length > 0) {
@@ -38205,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) {
@@ -38248,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,
@@ -38345,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,
@@ -38353,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) {
@@ -38407,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) {
@@ -38443,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() {

package/build/index.js

@@ -24886,7 +24886,14 @@ 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 rather than one: a built copy has been seen stale here while " + "the diagnostics on it read clean, so the reload is worth doing and is not known to be what " + "clears these. 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) {
+    return "";
+  }
+  const one = types.length === 1;
+  return `${types.join(", ")} ${one ? "is declared" : "are declared"} in this project and missing from ` + `.godot/global_script_class_cache.cfg, so a game launched now would not resolve ${one ? "it" : "them"} ` + "either. Try editor_rescan first: it asks the editor already running and starts nothing, and it " + "cleared this in 314ms in a second project with a 31-worker fan-out still importing. It is not " + "always enough, because a file another engine has already imported reads as settled and the " + "walk does not look inside it. project_import refresh_classes rewrites the cache from the " + "declarations on disk and does reach that case, at the cost of a short headless engine, which " + "is worth knowing when something else is already running against this project.";
 }
 function cacheWrittenAt(projectPath) {
   const cache = join3(projectPath, ".godot", "global_script_class_cache.cfg");
@@ -25153,7 +25160,7 @@ class GodotDAPClient {
       socket.once("error", handleError);
     });
   }
-  async disconnect() {
+  async abandon() {
     if (!this.socket) {
       this.connected = false;
       this.initialized = false;
@@ -25161,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) {
@@ -25754,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;
@@ -27725,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();
@@ -29085,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: []
   },
@@ -29740,6 +29755,8 @@ class GodotServer {
   successorWatch = null;
   lastProjectPath = null;
   shutdownInitiated = false;
+  launchedEditor = null;
+  launchedFrom = null;
   ownProject;
   announcedAt = null;
   constructor() {
@@ -29893,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;
     }
@@ -30899,7 +30916,7 @@ class GodotServer {
     }
     const uncached = unloaded.filter((type) => !type.inTheClassCache);
     if (uncached.length > 0) {
-      notes.push(`${uncached.map((type) => type.type).join(", ")} ${uncached.length === 1 ? "is declared" : "are declared"} in this project and missing from .godot/global_script_class_cache.cfg, so a game launched now would not resolve ${uncached.length === 1 ? "it" : "them"} either. project_import refresh_classes rewrites the cache from the declarations on disk.`);
+      notes.push(uncachedClassNote(uncached.map((type) => type.type)));
     }
     const stale = unloaded.filter((type) => type.inTheClassCache);
     if (stale.length > 0) {
@@ -30947,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) {
@@ -30990,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,
@@ -31087,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,
@@ -31095,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) {
@@ -31149,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) {
@@ -31185,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() {

package/package.json

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