gdharness 1.0.6 → 1.0.7

package/build/cli.js

@@ -15694,7 +15694,7 @@ var init_tool_definitions = __esm(() => {
           requires: []
         },
         refresh_classes: {
-          summary: 'rewrite .godot/global_script_class_cache.cfg from the class_name declarations on disk, and name under unseenByEditor any class the editor open on this project still cannot resolve: rewriting the file does not reach the list a running editor loaded, so "added: []" means the file was already right rather than that nothing is wrong',
+          summary: 'rewrite .godot/global_script_class_cache.cfg from the class_name declarations on disk, and name under unseenByEditor any class the editor open on this project still cannot resolve: rewriting the file does not reach the list a running editor loaded, so "added: []" means the file was already right rather than that nothing is wrong. A class the cache held after the last rebuild and had lost when this one began is named under lostSinceLastRebuild: the editor wrote the file without it in between, on a save or a scan, and will again until restarted',
           requires: []
         }
       }
@@ -15719,7 +15719,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "project_test",
-      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. Needs gdUnit4 under addons/gdUnit4.",
+      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. Needs gdUnit4 under addons/gdUnit4.",
       parameters: {
         projectPath: PROJECT_PATH,
         path: {
@@ -15936,7 +15936,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "script_diagnostics",
-      description: "Errors and warnings for a script from the editor's language server, and whether the script is clean. Needs the editor running. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares comes back under contradictedByTheFile, and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
+      description: "Errors and warnings for a script from the editor's language server, and whether the script is clean. Needs the editor running. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares comes back under contradictedByTheFile, and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. The one exception is named when it applies: an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
       parameters: {
         projectPath: PROJECT_PATH,
         scriptPath: SCRIPT_PATH
@@ -37616,7 +37616,7 @@ import {
   statSync as statSync5
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename4, dirname as dirname13, join as join20, normalize as normalize3, relative as relative3 } from "node:path";
+import { basename as basename4, dirname as dirname13, join as join20, normalize as normalize3, relative as relative3, resolve as resolve5 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { promisify as promisify7 } from "node:util";
@@ -37920,6 +37920,8 @@ class GodotServer {
   successorWatch = null;
   lastProjectPath = null;
   shutdownInitiated = false;
+  shortListEditors = new Map;
+  cacheLastRebuilt = new Map;
   launchedEditor = null;
   launchedFrom = null;
   ownProject;
@@ -38333,8 +38335,15 @@ class GodotServer {
         const contained = this.containProjectFiles(asks);
         return contained.ok ? await this.handleViaBridge(editorSide, contained.value) : contained.response;
       }
-      const answered = await this.headless(headless, answerable);
-      return headless === "refresh_class_cache" && this.godotBridge.isConnected() ? await this.alsoSayWhatTheEditorCannotSee(answered, args) : answered;
+      if (headless !== "refresh_class_cache") {
+        return await this.headless(headless, answerable);
+      }
+      const project = this.project(answerable);
+      if (!project.ok) {
+        return project.response;
+      }
+      const answered = this.answer(await this.rebuildClassCache(project.value.path));
+      return this.godotBridge.isConnected() ? await this.alsoSayWhatTheEditorCannotSee(answered, args) : answered;
     }
     const { op: _op, ...arguments_ } = args;
     const bridge = async (command, extra = {}) => {
@@ -38923,7 +38932,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const classes = await this.operation("refresh_class_cache", {}, project.value.path);
+    const classes = await this.rebuildClassCache(project.value.path);
     if (!classes.ok) {
       return this.answer(classes);
     }
@@ -39140,7 +39149,8 @@ class GodotServer {
     }
     const stale = unloaded.filter((type) => type.inTheClassCache);
     if (stale.length > 0) {
-      notes.push(`${stale.map((type) => type.type).join(", ")} ${stale.length === 1 ? "is" : "are"} in the class cache and still unresolved here, which is the editor's loaded list being behind rather than anything on disk. A game launched now reads the cache and resolves ${stale.length === 1 ? "it" : "them"}, so the run and the diagnostics disagree. editor_rescan clears it, measured against a real editor with waiting the same length ruled out; editor_launch restart also does, and costs more.`);
+      const remedy = this.editorWritesAShortList(projectPath) ? "editor_rescan will not clear it here: this editor wrote the class cache from a list shorter than the file on its last scan and writes the same list on every scan, so editor_launch restart is what loads it." : "editor_rescan clears it, measured against a real editor with waiting the same length ruled out; editor_launch restart also does, and costs more.";
+      notes.push(`${stale.map((type) => type.type).join(", ")} ${stale.length === 1 ? "is" : "are"} in the class cache and still unresolved here, which is the editor's loaded list being behind rather than anything on disk. A game launched now reads the cache and resolves ${stale.length === 1 ? "it" : "them"}, so the run and the diagnostics disagree. ${remedy}`);
     }
     return {
       ...contradicted.length === 0 ? {} : { contradictedByTheFile: contradicted },
@@ -39148,6 +39158,10 @@ class GodotServer {
       ...notes.length === 0 ? {} : { staleAnalysis: notes.join(" ") }
     };
   }
+  editorWritesAShortList(projectPath) {
+    const key = resolve5(projectPath);
+    return this.shortListEditors.has(key) && this.shortListEditors.get(key) === this.godotBridge.getStatus().editorPid;
+  }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
     if (!contained.ok || !existsSync14(contained.absolutePath)) {
@@ -40497,6 +40511,9 @@ class GodotServer {
     }
     const after = projectPath === "" || busy ? null : cachedClasses(projectPath);
     const lost = before === null || after === null ? [] : [...before.keys()].filter((name) => !after.has(name));
+    if (lost.length > 0) {
+      this.shortListEditors.set(resolve5(projectPath), this.godotBridge.getStatus().editorPid);
+    }
     const atMissingPaths = after === null ? [] : cachedAtMissingPaths(after, projectPath);
     const restored = lost.length > 0 || atMissingPaths.length > 0 ? await this.rebuildCacheAfterLoss(projectPath, lost) : [];
     const rebuilt = atMissingPaths.length > 0 ? cachedClasses(projectPath) : null;
@@ -40552,7 +40569,7 @@ class GodotServer {
     if (projectPath === "") {
       return [];
     }
-    const rebuilt = await this.operation("refresh_class_cache", {}, projectPath);
+    const rebuilt = await this.rebuildClassCache(projectPath);
     if (!rebuilt.ok) {
       this.logDebug(`Could not rebuild the class cache after a scan: ${rebuilt.message}`);
       return [];
@@ -40560,6 +40577,34 @@ class GodotServer {
     const now = cachedClasses(projectPath);
     return now === null ? [] : lost.filter((name) => now.has(name));
   }
+  async rebuildClassCache(projectPath) {
+    const key = resolve5(projectPath);
+    const before = cachedClasses(projectPath);
+    const remembered = this.cacheLastRebuilt.get(key);
+    const rebuilt = await this.operation("refresh_class_cache", {}, projectPath);
+    if (!rebuilt.ok) {
+      return rebuilt;
+    }
+    const after = cachedClasses(projectPath);
+    if (after === null) {
+      return rebuilt;
+    }
+    this.cacheLastRebuilt.set(key, new Set(after.keys()));
+    const lost = remembered === undefined || before === null ? [] : [...remembered].filter((name) => !before.has(name) && after.has(name)).sort();
+    if (lost.length === 0 || !this.godotBridge.isConnected()) {
+      return rebuilt;
+    }
+    this.shortListEditors.set(key, this.godotBridge.getStatus().editorPid);
+    const them = lost.length === 1 ? "it" : "them";
+    return {
+      ...rebuilt,
+      payload: {
+        ...rebuilt.payload,
+        lostSinceLastRebuild: lost,
+        note: `The cache held ${lost.join(", ")} after the last rebuild and not when this one began, so the editor holding this project wrote it without ${them} in between: it holds a list shorter than the files and writes that list on every save and scan, and each rebuild puts ${them} back. editor_launch restart is what ends it.`
+      }
+    };
+  }
   async alsoSayWhatTheEditorCannotSee(answered, args) {
     const first = answered.content[0];
     if (answered.isError || first?.type !== "text" || typeof first.text !== "string") {
@@ -40570,15 +40615,18 @@ class GodotServer {
     if (checked.unseen.length === 0 && stillHeld.length === 0 && checked.unchecked === undefined) {
       return answered;
     }
-    const notes = [];
+    const payload = asParams(JSON.parse(first.text));
+    const said = readString(payload, "note");
+    const notes = said === undefined ? [] : [said];
     if (checked.unseen.length > 0) {
-      notes.push("The cache on disk is right now, and the editor holding this project is still not resolving these: rewriting the file does not reach the list it already loaded. editor_rescan does, on its own and with no change to the declaring script; editor_launch restart also does, and costs more.");
+      const projectPath = typeof args["projectPath"] === "string" ? args["projectPath"] : "";
+      notes.push(projectPath !== "" && this.editorWritesAShortList(projectPath) ? "The cache on disk is right now, and the editor holding this project is still not resolving these: rewriting the file does not reach the list it already loaded. editor_rescan will not reach it either on this editor, whose last scan wrote the cache from a list shorter than the file and would again; editor_launch restart is what loads them." : "The cache on disk is right now, and the editor holding this project is still not resolving these: rewriting the file does not reach the list it already loaded. editor_rescan does, on its own and with no change to the declaring script; editor_launch restart also does, and costs more.");
     }
     if (stillHeld.length > 0) {
       notes.push(`The editor is still holding ${stillHeld.join(", ")}, which this project no longer declares, and it will write that list back over the cache this call just corrected. The entry returns pointing at a script that is gone, and the next engine to walk get_global_class_list() dies on "File not found". A rescan does not clear this one: it picks up a class that has appeared and does not drop one that has gone. editor_launch restart does.`);
     }
     return this.jsonTextResponse({
-      ...asParams(JSON.parse(first.text)),
+      ...payload,
       unseenByEditor: checked.unseen.length > 0 ? checked.unseen : undefined,
       stillHeldByEditor: stillHeld.length > 0 ? stillHeld : undefined,
       classesUnchecked: checked.unchecked,
@@ -40871,7 +40919,7 @@ var init_server3 = __esm(() => {
 
 // src/cli.ts
 import { existsSync as existsSync15 } from "fs";
-import { join as join21, resolve as resolve5 } from "path";
+import { join as join21, resolve as resolve6 } from "path";
 
 // src/errors.ts
 class Refusal extends Error {
@@ -42575,7 +42623,7 @@ class UsageError extends Refusal {
 }
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
-  const projectPath = resolve5(named ?? ".");
+  const projectPath = resolve6(named ?? ".");
   if (!existsSync15(join21(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }

package/build/godot/addons/gdharness_runtime/runtime_autoload.gd

@@ -267,23 +267,46 @@ func _announce(bind_address: String) -> void:
 		)
 		return
 	var path: String = directory.path_join("runtime-%d.json" % OS.get_process_id())
-	var file: FileAccess = FileAccess.open(path, FileAccess.WRITE)
+	# Written whole under a name no server reads and moved into place, so no look ever meets
+	# the file empty: a server sweeping the directory between an open and a write took the
+	# announcement for a dead game's leftover, and the directory is shared by every server on
+	# the machine, older ones included.
+	var staged: String = path + ".tmp"
+	var file: FileAccess = FileAccess.open(staged, FileAccess.WRITE)
 	if file == null:
 		push_warning(
 			(
 				"[gdharness] cannot write %s (%s); the server will not find this game"
-				% [path, FileAccess.get_open_error()]
+				% [staged, FileAccess.get_open_error()]
 			)
 		)
 		return
-	var announced: bool = file.store_string(JSON.stringify(_identity(bind_address)))
+	var written: bool = file.store_string(JSON.stringify(_identity(bind_address)))
 	file.close()
-	if not announced:
-		push_warning("[gdharness] cannot write %s; the server will not find this game" % path)
+	if not written:
+		push_warning("[gdharness] cannot write %s; the server will not find this game" % staged)
+		_unstage(staged)
+		return
+	var moved: Error = DirAccess.rename_absolute(staged, path)
+	if moved != OK:
+		push_warning(
+			(
+				"[gdharness] cannot move %s to %s (%s); the server will not find this game"
+				% [staged, path, moved]
+			)
+		)
+		_unstage(staged)
 		return
 	_announcement = path
 
 
+## Takes a staged announcement down after a write or a move that failed. The answer is taken
+## rather than dropped, since these scripts compile under the game's own warning levels; a
+## staged file that will not go either is nothing any server reads.
+func _unstage(staged: String) -> void:
+	var _removed: Error = DirAccess.remove_absolute(staged)
+
+
 ## What the announcement file and the welcome both carry: enough to pick this game out of
 ## several and to know whether the server speaks its protocol.
 func _identity(bind_address: String) -> Dictionary:

package/build/index.js

@@ -10184,7 +10184,7 @@ import {
   statSync as statSync5
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename3, dirname as dirname8, join as join14, normalize as normalize2, relative as relative3 } from "node:path";
+import { basename as basename3, dirname as dirname8, join as join14, normalize as normalize2, relative as relative3, resolve as resolve5 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { promisify as promisify5 } from "node:util";
@@ -29468,7 +29468,7 @@ var TOOL_SPECS = [
         requires: []
       },
       refresh_classes: {
-        summary: 'rewrite .godot/global_script_class_cache.cfg from the class_name declarations on disk, and name under unseenByEditor any class the editor open on this project still cannot resolve: rewriting the file does not reach the list a running editor loaded, so "added: []" means the file was already right rather than that nothing is wrong',
+        summary: 'rewrite .godot/global_script_class_cache.cfg from the class_name declarations on disk, and name under unseenByEditor any class the editor open on this project still cannot resolve: rewriting the file does not reach the list a running editor loaded, so "added: []" means the file was already right rather than that nothing is wrong. A class the cache held after the last rebuild and had lost when this one began is named under lostSinceLastRebuild: the editor wrote the file without it in between, on a save or a scan, and will again until restarted',
         requires: []
       }
     }
@@ -29493,7 +29493,7 @@ var TOOL_SPECS = [
   },
   {
     name: "project_test",
-    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. Needs gdUnit4 under addons/gdUnit4.",
+    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. Needs gdUnit4 under addons/gdUnit4.",
     parameters: {
       projectPath: PROJECT_PATH,
       path: {
@@ -29710,7 +29710,7 @@ var TOOL_SPECS = [
   },
   {
     name: "script_diagnostics",
-    description: "Errors and warnings for a script from the editor's language server, and whether the script is clean. Needs the editor running. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares comes back under contradictedByTheFile, and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
+    description: "Errors and warnings for a script from the editor's language server, and whether the script is clean. Needs the editor running. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares comes back under contradictedByTheFile, and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. The one exception is named when it applies: an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
     parameters: {
       projectPath: PROJECT_PATH,
       scriptPath: SCRIPT_PATH
@@ -30658,6 +30658,8 @@ class GodotServer {
   successorWatch = null;
   lastProjectPath = null;
   shutdownInitiated = false;
+  shortListEditors = new Map;
+  cacheLastRebuilt = new Map;
   launchedEditor = null;
   launchedFrom = null;
   ownProject;
@@ -31071,8 +31073,15 @@ class GodotServer {
         const contained = this.containProjectFiles(asks);
         return contained.ok ? await this.handleViaBridge(editorSide, contained.value) : contained.response;
       }
-      const answered = await this.headless(headless, answerable);
-      return headless === "refresh_class_cache" && this.godotBridge.isConnected() ? await this.alsoSayWhatTheEditorCannotSee(answered, args) : answered;
+      if (headless !== "refresh_class_cache") {
+        return await this.headless(headless, answerable);
+      }
+      const project = this.project(answerable);
+      if (!project.ok) {
+        return project.response;
+      }
+      const answered = this.answer(await this.rebuildClassCache(project.value.path));
+      return this.godotBridge.isConnected() ? await this.alsoSayWhatTheEditorCannotSee(answered, args) : answered;
     }
     const { op: _op, ...arguments_ } = args;
     const bridge = async (command, extra = {}) => {
@@ -31661,7 +31670,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const classes = await this.operation("refresh_class_cache", {}, project.value.path);
+    const classes = await this.rebuildClassCache(project.value.path);
     if (!classes.ok) {
       return this.answer(classes);
     }
@@ -31878,7 +31887,8 @@ class GodotServer {
     }
     const stale = unloaded.filter((type) => type.inTheClassCache);
     if (stale.length > 0) {
-      notes.push(`${stale.map((type) => type.type).join(", ")} ${stale.length === 1 ? "is" : "are"} in the class cache and still unresolved here, which is the editor's loaded list being behind rather than anything on disk. A game launched now reads the cache and resolves ${stale.length === 1 ? "it" : "them"}, so the run and the diagnostics disagree. editor_rescan clears it, measured against a real editor with waiting the same length ruled out; editor_launch restart also does, and costs more.`);
+      const remedy = this.editorWritesAShortList(projectPath) ? "editor_rescan will not clear it here: this editor wrote the class cache from a list shorter than the file on its last scan and writes the same list on every scan, so editor_launch restart is what loads it." : "editor_rescan clears it, measured against a real editor with waiting the same length ruled out; editor_launch restart also does, and costs more.";
+      notes.push(`${stale.map((type) => type.type).join(", ")} ${stale.length === 1 ? "is" : "are"} in the class cache and still unresolved here, which is the editor's loaded list being behind rather than anything on disk. A game launched now reads the cache and resolves ${stale.length === 1 ? "it" : "them"}, so the run and the diagnostics disagree. ${remedy}`);
     }
     return {
       ...contradicted.length === 0 ? {} : { contradictedByTheFile: contradicted },
@@ -31886,6 +31896,10 @@ class GodotServer {
       ...notes.length === 0 ? {} : { staleAnalysis: notes.join(" ") }
     };
   }
+  editorWritesAShortList(projectPath) {
+    const key = resolve5(projectPath);
+    return this.shortListEditors.has(key) && this.shortListEditors.get(key) === this.godotBridge.getStatus().editorPid;
+  }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
     if (!contained.ok || !existsSync9(contained.absolutePath)) {
@@ -33235,6 +33249,9 @@ class GodotServer {
     }
     const after = projectPath === "" || busy ? null : cachedClasses(projectPath);
     const lost = before === null || after === null ? [] : [...before.keys()].filter((name) => !after.has(name));
+    if (lost.length > 0) {
+      this.shortListEditors.set(resolve5(projectPath), this.godotBridge.getStatus().editorPid);
+    }
     const atMissingPaths = after === null ? [] : cachedAtMissingPaths(after, projectPath);
     const restored = lost.length > 0 || atMissingPaths.length > 0 ? await this.rebuildCacheAfterLoss(projectPath, lost) : [];
     const rebuilt = atMissingPaths.length > 0 ? cachedClasses(projectPath) : null;
@@ -33290,7 +33307,7 @@ class GodotServer {
     if (projectPath === "") {
       return [];
     }
-    const rebuilt = await this.operation("refresh_class_cache", {}, projectPath);
+    const rebuilt = await this.rebuildClassCache(projectPath);
     if (!rebuilt.ok) {
       this.logDebug(`Could not rebuild the class cache after a scan: ${rebuilt.message}`);
       return [];
@@ -33298,6 +33315,34 @@ class GodotServer {
     const now = cachedClasses(projectPath);
     return now === null ? [] : lost.filter((name) => now.has(name));
   }
+  async rebuildClassCache(projectPath) {
+    const key = resolve5(projectPath);
+    const before = cachedClasses(projectPath);
+    const remembered = this.cacheLastRebuilt.get(key);
+    const rebuilt = await this.operation("refresh_class_cache", {}, projectPath);
+    if (!rebuilt.ok) {
+      return rebuilt;
+    }
+    const after = cachedClasses(projectPath);
+    if (after === null) {
+      return rebuilt;
+    }
+    this.cacheLastRebuilt.set(key, new Set(after.keys()));
+    const lost = remembered === undefined || before === null ? [] : [...remembered].filter((name) => !before.has(name) && after.has(name)).sort();
+    if (lost.length === 0 || !this.godotBridge.isConnected()) {
+      return rebuilt;
+    }
+    this.shortListEditors.set(key, this.godotBridge.getStatus().editorPid);
+    const them = lost.length === 1 ? "it" : "them";
+    return {
+      ...rebuilt,
+      payload: {
+        ...rebuilt.payload,
+        lostSinceLastRebuild: lost,
+        note: `The cache held ${lost.join(", ")} after the last rebuild and not when this one began, so the editor holding this project wrote it without ${them} in between: it holds a list shorter than the files and writes that list on every save and scan, and each rebuild puts ${them} back. editor_launch restart is what ends it.`
+      }
+    };
+  }
   async alsoSayWhatTheEditorCannotSee(answered, args) {
     const first = answered.content[0];
     if (answered.isError || first?.type !== "text" || typeof first.text !== "string") {
@@ -33308,15 +33353,18 @@ class GodotServer {
     if (checked.unseen.length === 0 && stillHeld.length === 0 && checked.unchecked === undefined) {
       return answered;
     }
-    const notes = [];
+    const payload = asParams(JSON.parse(first.text));
+    const said = readString(payload, "note");
+    const notes = said === undefined ? [] : [said];
     if (checked.unseen.length > 0) {
-      notes.push("The cache on disk is right now, and the editor holding this project is still not resolving these: rewriting the file does not reach the list it already loaded. editor_rescan does, on its own and with no change to the declaring script; editor_launch restart also does, and costs more.");
+      const projectPath = typeof args["projectPath"] === "string" ? args["projectPath"] : "";
+      notes.push(projectPath !== "" && this.editorWritesAShortList(projectPath) ? "The cache on disk is right now, and the editor holding this project is still not resolving these: rewriting the file does not reach the list it already loaded. editor_rescan will not reach it either on this editor, whose last scan wrote the cache from a list shorter than the file and would again; editor_launch restart is what loads them." : "The cache on disk is right now, and the editor holding this project is still not resolving these: rewriting the file does not reach the list it already loaded. editor_rescan does, on its own and with no change to the declaring script; editor_launch restart also does, and costs more.");
     }
     if (stillHeld.length > 0) {
       notes.push(`The editor is still holding ${stillHeld.join(", ")}, which this project no longer declares, and it will write that list back over the cache this call just corrected. The entry returns pointing at a script that is gone, and the next engine to walk get_global_class_list() dies on "File not found". A rescan does not clear this one: it picks up a class that has appeared and does not drop one that has gone. editor_launch restart does.`);
     }
     return this.jsonTextResponse({
-      ...asParams(JSON.parse(first.text)),
+      ...payload,
       unseenByEditor: checked.unseen.length > 0 ? checked.unseen : undefined,
       stillHeldByEditor: stillHeld.length > 0 ? stillHeld : undefined,
       classesUnchecked: checked.unchecked,

package/package.json

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