gdharness 0.9.7 → 0.10.1

package/build/cli.js

@@ -7474,6 +7474,9 @@ import { join as join6 } from "node:path";
 function declaredClasses(projectPath) {
   const declared = new Map;
   const visit = (directory, prefix) => {
+    if (existsSync6(join6(directory, ".gdignore"))) {
+      return;
+    }
     for (const entry of readdirSync2(directory, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) {
         continue;
@@ -7511,6 +7514,12 @@ function staleClassNames(projectPath) {
   const cached = cachedClasses(projectPath);
   return cached === null ? [...declaredClasses(projectPath).keys()] : staleAgainst(cached, projectPath);
 }
+function unseenByEditor(projectPath, editorHolds) {
+  const held = new Set(editorHolds);
+  const declared = declaredClasses(projectPath);
+  const source = cachedClasses(projectPath) ?? declared;
+  return [...source].filter(([name]) => !held.has(name) && declared.has(name)).map(([className, path]) => ({ className, path: declared.get(className) ?? path }));
+}
 var init_class_cache = () => {};
 
 // src/headless.ts
@@ -15371,7 +15380,7 @@ var init_tool_definitions = __esm(() => {
         uid: { summary: "the UID of one file", requires: ["resourcePath"] },
         refresh_uids: { summary: "resave every resource so UID references are current", requires: [] },
         refresh_classes: {
-          summary: "rewrite .godot/global_script_class_cache.cfg from the class_name declarations on disk, for an editor whose list has gone stale",
+          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',
           requires: []
         }
       }
@@ -15671,7 +15680,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_run",
-      description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way.",
+      description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice.",
       parameters: {
         projectPath: PROJECT_PATH,
         scene: { type: "string", description: "A scene to run instead of the main scene." },
@@ -15716,7 +15725,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_rescan",
-      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. The scan is a change-detecting walk rather than an unconditional reparse, so a file the editor has already recorded and reads as unchanged is one it does not look inside again: a class_name usually becomes visible this way and on one project did not, with the cache on disk still missing it after the scan said it was done. project_import refresh_classes is the one that rebuilds the class list from the declarations on disk, whatever the editor thinks it has seen. Needs the editor connected.",
+      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is a change to the declaring script, or editor_launch restart; project_import refresh_classes rewrites the cache and does not touch what the editor is holding. Needs the editor connected.",
       parameters: {
         projectPath: PROJECT_PATH,
         timeoutMs: { type: "number", description: "How long to wait for the scan. Default 30000." }
@@ -35771,6 +35780,7 @@ import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync a
 import { createConnection as createConnection3 } from "node:net";
 import { tmpdir as tmpdir4 } from "node:os";
 import { join as join13, resolve as resolve4 } from "node:path";
+import { setTimeout as delay2 } from "node:timers/promises";
 function runtimeDirectory(variables = process.env) {
   const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
   if (explicit) {
@@ -35859,6 +35869,22 @@ function announcedIn(directory) {
   }
   return found;
 }
+async function announcedSince(projectPath, before, waiting = {}) {
+  const wanted = resolve4(projectPath);
+  const directories = waiting.directories ?? runtimeDirectories();
+  const until = Date.now() + Math.max(waiting.budgetMs ?? ANNOUNCE_BUDGET_MS, 0);
+  for (;; ) {
+    const fresh = discoverRuntimes(directories).find((endpoint) => !before.has(endpoint.pid) && resolve4(endpoint.project.path) === wanted);
+    if (fresh !== undefined) {
+      return fresh;
+    }
+    const left = until - Date.now();
+    if (left <= 0 || waiting.giveUp?.() === true) {
+      return null;
+    }
+    await delay2(Math.min(LOOK_EVERY_MS, left));
+  }
+}
 function describe2(endpoint) {
   return `pid ${endpoint.pid} on ${endpoint.address}:${endpoint.port} (${endpoint.project.name || "unnamed"} at ${endpoint.project.path})`;
 }
@@ -35985,7 +36011,7 @@ function runtimeRequest(endpoint, command, params, timeoutMs) {
     });
   });
 }
-var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, nextRequestId = 1;
+var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1;
 var init_runtime_client = __esm(() => {
   ANNOUNCEMENT_PATTERN = /^runtime-(\d+)\.json$/;
 });
@@ -36001,13 +36027,17 @@ function installedAddonVersion(projectPath) {
   const said = readFileSync12(marker, "utf8").trim();
   return said === "" ? null : said;
 }
-var ADDONS2, VERSION_MARKER2 = ".gdharness-version";
+var ADDONS2, RUNTIME_AUTOLOAD2, VERSION_MARKER2 = ".gdharness-version";
 var init_setup = __esm(() => {
   init_class_cache();
   init_headless();
   init_resources();
   init_server_version();
   ADDONS2 = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
+  RUNTIME_AUTOLOAD2 = {
+    name: "GdharnessRuntime",
+    path: "addons/gdharness_runtime/runtime_autoload.gd"
+  };
 });
 
 // src/server.ts
@@ -36015,7 +36045,7 @@ import { execFile as execFile5, spawn } from "node:child_process";
 import { existsSync as existsSync12, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync3, readdirSync as readdirSync6, readFileSync as readFileSync13, realpathSync as realpathSync2, rmSync as rmSync8 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
 import { basename as basename2, dirname as dirname9, join as join15, normalize as normalize3 } from "node:path";
-import { setTimeout as delay2 } from "node:timers/promises";
+import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { promisify as promisify5 } from "node:util";
 function patienceForFrames(frames, atLeast) {
@@ -36092,6 +36122,10 @@ function realPathOr(path) {
     return path;
   }
 }
+function samePath(one, other) {
+  const settled = (path) => realPathOr(path).replaceAll("\\", "/").replace(/\/+$/, "").toLowerCase();
+  return settled(one) === settled(other);
+}
 function aboveTheRunner(entry) {
   const runner = entry.detail.findIndex((line) => line.includes(RUNNER_DIRECTORY));
   if (runner < 0) {
@@ -36522,7 +36556,8 @@ class GodotServer {
   async dispatch(tool, op, args) {
     const headless = HEADLESS_OPERATIONS[tool]?.[op];
     if (headless !== undefined) {
-      return await this.headless(headless, args);
+      const answered = await this.headless(headless, args);
+      return headless === "refresh_class_cache" && this.godotBridge.isConnected() ? await this.alsoSayWhatTheEditorCannotSee(answered, args) : answered;
     }
     const { op: _op, ...arguments_ } = args;
     const bridge = async (command, extra = {}) => {
@@ -37327,7 +37362,7 @@ class GodotServer {
       if (Date.now() >= deadline) {
         return false;
       }
-      await delay2(250);
+      await delay3(250);
     }
   }
   async handleLaunchEditor(args) {
@@ -37423,12 +37458,13 @@ class GodotServer {
       this.logDebug("Ending the running game before starting another");
       await this.endActiveGame();
     }
+    const alreadyPlaying = new Set(discoverRuntimes().map((endpoint) => endpoint.pid));
     const headless = resolveHeadless(args["headless"], {
       platform: process.platform,
       variables: process.env
     });
     if (this.godotBridge.isConnected() && (!headless || editorPlaysHeadless(project.value.file))) {
-      return await this.playThroughEditor(sceneArgument, refreshed.value);
+      return await this.playThroughEditor(sceneArgument, refreshed.value, project.value.path, alreadyPlaying);
     }
     const cmdArgs = runArguments({
       projectPath: project.value.path,
@@ -37444,10 +37480,31 @@ class GodotServer {
       pid: started.process.pid ?? null,
       arguments: cmdArgs,
       refreshedClasses: refreshed.value,
+      runtime: await this.runtimeUp(project.value.path, alreadyPlaying),
       message: "Use editor_output for what it prints and editor_run stop to end it."
     });
   }
-  async playThroughEditor(scene, refreshedClasses) {
+  async runtimeUp(projectPath, before) {
+    if (!existsSync12(join15(projectPath, RUNTIME_AUTOLOAD2.path))) {
+      return {
+        listening: false,
+        note: "this project has no gdharness_runtime addon, so the runtime_* tools have nothing to talk to"
+      };
+    }
+    const endpoint = await announcedSince(projectPath, before, {
+      giveUp: () => this.dapClient?.isStopped() === true
+    });
+    if (endpoint === null) {
+      const held = this.dapClient?.whereItStopped() ?? null;
+      return {
+        listening: false,
+        note: held === null ? `nothing announced itself within ${ANNOUNCE_BUDGET_MS}ms: the game may be slow to boot, or its runtime is not coming up` : "the game stopped before its runtime came up, so the runtime_* tools have nothing to talk to yet: debug_control continue lets it carry on",
+        heldAt: held
+      };
+    }
+    return { listening: true, pid: endpoint.pid, port: endpoint.port };
+  }
+  async playThroughEditor(scene, refreshedClasses, projectPath, alreadyPlaying) {
     const log = new GameLog;
     try {
       await this.dap().connect();
@@ -37476,6 +37533,7 @@ class GodotServer {
       scene: scene === null ? "the main scene" : `res://${scene}`,
       refreshedClasses,
       debugPort: readNumber(asParams(JSON.parse(answer.content[0]?.text ?? "{}")), "debugPort"),
+      runtime: await this.runtimeUp(projectPath, alreadyPlaying),
       message: "The editor is playing it, so its debugger holds it: the debug_* tools can reach it, " + "editor_output reads its console through the debug adapter, and editor_run stop ends it."
     });
   }
@@ -37630,13 +37688,59 @@ class GodotServer {
       const status = asParams(await this.godotBridge.invokeTool("rescan_filesystem", { ...args, statusOnly: true }));
       busy = Boolean(status["scanning"]) || Boolean(status["importing"]);
     }
+    const checked = busy ? { unseen: [] } : await this.classesTheEditorCannotSee(args);
+    const unseen = checked.unseen;
     return this.jsonTextResponse({
-      ok: !busy,
+      ok: !busy && unseen.length === 0 && checked.unchecked === undefined,
       stillWorking: busy,
       waitedMs: Date.now() - started,
-      note: busy ? "The editor was still scanning or importing when the wait ran out, so new files may not be visible yet." : undefined
+      unseenByEditor: unseen.length > 0 ? unseen : undefined,
+      classesUnchecked: checked.unchecked,
+      note: busy ? "The editor was still scanning or importing when the wait ran out, so new files may not be visible yet." : unseen.length > 0 ? "The scan finished and these classes are still not in the list the editor resolves against, so every use of them reads as an unknown identifier. Its walk skips a file another engine has already imported. Change the declaring script and rescan, or restart the editor with editor_launch restart." : undefined
     });
   }
+  async alsoSayWhatTheEditorCannotSee(answered, args) {
+    const first = answered.content[0];
+    if (answered.isError || first?.type !== "text" || typeof first.text !== "string") {
+      return answered;
+    }
+    const checked = await this.classesTheEditorCannotSee(args);
+    if (checked.unseen.length === 0 && checked.unchecked === undefined) {
+      return answered;
+    }
+    return this.jsonTextResponse({
+      ...asParams(JSON.parse(first.text)),
+      unseenByEditor: checked.unseen.length > 0 ? checked.unseen : undefined,
+      classesUnchecked: checked.unchecked,
+      note: checked.unseen.length > 0 ? "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. Change the declaring script and editor_rescan, or restart the editor with editor_launch restart." : undefined
+    });
+  }
+  async classesTheEditorCannotSee(args) {
+    const projectPath = typeof args["projectPath"] === "string" ? args["projectPath"] : "";
+    if (projectPath === "") {
+      return { unseen: [], unchecked: "no projectPath, so there was nothing to read the cache from" };
+    }
+    const open = this.godotBridge.getStatus().projectPath;
+    if (open === undefined || !samePath(open, projectPath)) {
+      return {
+        unseen: [],
+        unchecked: `the connected editor is open on ${open ?? "a project it did not name"}, not this one`
+      };
+    }
+    let held;
+    try {
+      held = asParams(await this.godotBridge.invokeTool("global_classes", args));
+    } catch (error) {
+      return {
+        unseen: [],
+        unchecked: `the editor would not say what classes it is holding: ${errorMessage(error)}`
+      };
+    }
+    if (!Array.isArray(held["classes"])) {
+      return { unseen: [], unchecked: "the editor answered without a class list in it" };
+    }
+    return { unseen: unseenByEditor(projectPath, held["classes"].map(String)) };
+  }
   async handleViaBridge(toolName, args) {
     if (!this.godotBridge.isConnected()) {
       return this.createErrorResponse("Editor not connected: no Godot editor with the gdharness editor addon has reached this server.", [
@@ -39226,6 +39330,12 @@ formatting. \`script_diagnostics\` and \`script_info\` come from the editor's ow
 \`editor_classes\` need nothing open: they run a short headless engine and are gone before the
 answer is printed.
 
+A wall of "Could not find type" on the project's own classes means the editor is not holding
+them. \`editor_rescan\` asks it to scan and names any class it still cannot resolve under
+\`unseenByEditor\`: its walk skips a file a headless engine has already imported, so the
+declaration and the cache can both be right while the editor stays blind to it. Change the
+declaring script, or restart the editor.
+
 ## Refusals are useful
 
 An unknown op, an argument the tool does not name, or a missing required one is refused with the

package/build/godot/addons/gdharness_editor/tool_executor.gd

@@ -9,6 +9,7 @@ const SceneTools = preload("tools/scene_tools.gd")
 const ResourceTools = preload("tools/resource_tools.gd")
 const AnimationTools = preload("tools/animation_tools.gd")
 const PlayTools = preload("tools/play_tools.gd")
+const ClassTools = preload("tools/class_tools.gd")
 
 var _editor_plugin: EditorPlugin = null
 
@@ -16,6 +17,7 @@ var _scene_tools: SceneTools = null
 var _resource_tools: ResourceTools = null
 var _animation_tools: AnimationTools = null
 var _play_tools: PlayTools = null
+var _class_tools: ClassTools = null
 
 var _tool_map: Dictionary = {}
 var _initialized: bool = false
@@ -28,6 +30,7 @@ func set_editor_plugin(plugin: EditorPlugin) -> void:
 	_resource_tools.set_editor_plugin(plugin)
 	_animation_tools.set_editor_plugin(plugin)
 	_play_tools.set_editor_plugin(plugin)
+	_class_tools.set_editor_plugin(plugin)
 
 
 func _init_tools() -> void:
@@ -51,6 +54,10 @@ func _init_tools() -> void:
 	_play_tools.name = "PlayTools"
 	add_child(_play_tools)
 
+	_class_tools = ClassTools.new()
+	_class_tools.name = "ClassTools"
+	add_child(_class_tools)
+
 	_tool_map = {
 		# Scene tools
 		"create_scene": [_scene_tools, "create_scene"],
@@ -66,6 +73,7 @@ func _init_tools() -> void:
 		"disconnect_signal": [_scene_tools, "disconnect_signal"],
 		"list_connections": [_scene_tools, "list_connections"],
 		"rescan_filesystem": [_scene_tools, "rescan_filesystem"],
+		"global_classes": [_class_tools, "global_classes"],
 		# Resource tools
 		"create_resource": [_resource_tools, "create_resource"],
 		"modify_resource": [_resource_tools, "modify_resource"],

package/build/godot/addons/gdharness_editor/tools/class_tools.gd

@@ -0,0 +1,56 @@
+@tool
+extends Node
+
+## The global classes the running editor is holding.
+##
+## The editor fixes this list when it starts and adds to it only from a filesystem scan, and
+## that scan is change-detecting: a file another engine has already imported looks settled, so
+## the walk goes past it without reading the declaration inside. The class is then declared on
+## disk, listed in `.godot/global_script_class_cache.cfg`, and absent from the editor, whose
+## analyser reports every use of it as an unknown identifier. Rebuilding the cache does not
+## help, because nothing rereads it.
+##
+## Every check there was compares one file on disk against another, so all of them call that
+## state clean. The editor is the only thing that can say otherwise, so it is asked.
+##
+## Read off the editor's own filesystem entries rather than from
+## `ProjectSettings.get_global_class_list()`. The entries are what the scan itself recorded, so
+## nothing but a scan can change them; the settings list is loaded from the cache file when it is
+## first asked for, which makes it a poor witness against a cache that was just rewritten, and
+## rewriting the cache is the call most in need of an honest answer here.
+##
+## A file the scan skipped is either missing from the tree or recorded with no class name against
+## it, and both come back as a class the editor does not have, which is the whole of the question.
+
+var _editor_plugin: EditorPlugin = null
+
+
+func set_editor_plugin(plugin: EditorPlugin) -> void:
+	_editor_plugin = plugin
+
+
+func global_classes(_args: Dictionary) -> Dictionary:
+	if not _editor_plugin:
+		return {"ok": false, "error": "Editor plugin unavailable"}
+
+	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
+	var names: PackedStringArray = []
+	_walk(filesystem.get_filesystem(), names)
+	names.sort()
+	return {
+		"ok": true,
+		"classes": names,
+		"scanning": filesystem.is_scanning(),
+		"importing": filesystem.is_importing(),
+	}
+
+
+func _walk(directory: EditorFileSystemDirectory, into: PackedStringArray) -> void:
+	if directory == null:
+		return
+	for index: int in range(directory.get_file_count()):
+		var declared: String = directory.get_file_script_class_name(index)
+		if not declared.is_empty():
+			into.append(declared)
+	for index: int in range(directory.get_subdir_count()):
+		_walk(directory.get_subdir(index), into)

package/build/godot/addons/gdharness_editor/tools/class_tools.gd.uid

@@ -0,0 +1 @@
+uid://bodtvclhs3toc

package/build/godot/operations/project_config.gd

@@ -45,6 +45,17 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 		old_value = ProjectSettings.get_setting(setting_path)
 
 	var final_value: Variant = _values.deserialize_value(value)
+	var wanted: int = _wanted_type(setting_path, old_value if had_value else null)
+	if wanted > TYPE_NIL and final_value != null and typeof(final_value) != wanted:
+		if not _converts_faithfully(final_value, wanted):
+			return _log.failure(
+				(
+					"%s is declared as %s, and %s (%s) cannot be written as that without losing something."
+					% [setting_path, type_string(wanted), str(final_value), type_string(typeof(final_value))]
+				)
+			)
+		final_value = type_convert(final_value, wanted)
+
 	ProjectSettings.set_setting(setting_path, final_value)
 	var err: Error = ProjectSettings.save()
 	if err != OK:
@@ -59,6 +70,33 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 	}
 
 
+# The type a setting wants, or TYPE_NIL where the engine names none and there is nothing to go on.
+#
+# JSON carries one number type, so every number arrives as a float and an int setting was written
+# to project.godot as "50.0". Every reader casts it back, so the tool, the editor and the running
+# game all answer 50 afterwards and only the committed file says otherwise, where it reads as
+# something having gone wrong.
+#
+# The engine's own property list is what is asked, rather than the value that is there: a setting
+# already written as "50.0" reads back as a float, so the value on hand agrees with the mistake and
+# no project that has made it once could be set right again. The property list still says int.
+# A setting the engine does not declare has only its current value to go on, and a new one has
+# neither, which is the caller's type to choose.
+func _wanted_type(setting_path: String, current: Variant) -> int:
+	for info: Dictionary in ProjectSettings.get_property_list():
+		if str(info.get("name", "")) == setting_path:
+			return int(info.get("type", TYPE_NIL))
+	return typeof(current)
+
+
+# What separates a narrowing from a guess: 50.0 through int and out again is 50.0, so it was an int
+# all along, while 50.5 comes back as 50.0 and "loud" comes back as "0". Those are a caller meaning
+# something the setting cannot hold, and are refused rather than written as whatever the cast
+# happened to produce.
+func _converts_faithfully(value: Variant, to: int) -> bool:
+	return type_convert(type_convert(value, to), typeof(value)) == value
+
+
 # Add an autoload singleton
 func add_autoload(params: Dictionary) -> Dictionary:
 	var name: String = str(params.get("name", ""))

package/build/index.js

@@ -10129,7 +10129,7 @@ import { execFile as execFile3, spawn } from "node:child_process";
 import { existsSync as existsSync7, mkdirSync as mkdirSync4, mkdtempSync as mkdtempSync2, readdirSync as readdirSync5, readFileSync as readFileSync9, realpathSync as realpathSync2, rmSync as rmSync4 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
 import { basename, dirname as dirname4, join as join9, normalize as normalize2 } from "node:path";
-import { setTimeout as delay2 } from "node:timers/promises";
+import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { promisify as promisify3 } from "node:util";
 
@@ -24758,6 +24758,9 @@ import { join as join3 } from "node:path";
 function declaredClasses(projectPath) {
   const declared = new Map;
   const visit = (directory, prefix) => {
+    if (existsSync2(join3(directory, ".gdignore"))) {
+      return;
+    }
     for (const entry of readdirSync(directory, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) {
         continue;
@@ -24795,6 +24798,12 @@ function staleClassNames(projectPath) {
   const cached = cachedClasses(projectPath);
   return cached === null ? [...declaredClasses(projectPath).keys()] : staleAgainst(cached, projectPath);
 }
+function unseenByEditor(projectPath, editorHolds) {
+  const held = new Set(editorHolds);
+  const declared = declaredClasses(projectPath);
+  const source = cachedClasses(projectPath) ?? declared;
+  return [...source].filter(([name]) => !held.has(name) && declared.has(name)).map(([className, path]) => ({ className, path: declared.get(className) ?? path }));
+}
 
 // src/dap_client.ts
 import { createConnection } from "node:net";
@@ -27408,6 +27417,7 @@ import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as
 import { createConnection as createConnection3 } from "node:net";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join7, resolve as resolve4 } from "node:path";
+import { setTimeout as delay2 } from "node:timers/promises";
 
 // src/tool-args.ts
 function asParams(value) {
@@ -27551,6 +27561,24 @@ function announcedIn(directory) {
   }
   return found;
 }
+var LOOK_EVERY_MS = 50;
+var ANNOUNCE_BUDGET_MS = 5000;
+async function announcedSince(projectPath, before, waiting = {}) {
+  const wanted = resolve4(projectPath);
+  const directories = waiting.directories ?? runtimeDirectories();
+  const until = Date.now() + Math.max(waiting.budgetMs ?? ANNOUNCE_BUDGET_MS, 0);
+  for (;; ) {
+    const fresh = discoverRuntimes(directories).find((endpoint) => !before.has(endpoint.pid) && resolve4(endpoint.project.path) === wanted);
+    if (fresh !== undefined) {
+      return fresh;
+    }
+    const left = until - Date.now();
+    if (left <= 0 || waiting.giveUp?.() === true) {
+      return null;
+    }
+    await delay2(Math.min(LOOK_EVERY_MS, left));
+  }
+}
 function describe2(endpoint) {
   return `pid ${endpoint.pid} on ${endpoint.address}:${endpoint.port} (${endpoint.project.name || "unnamed"} at ${endpoint.project.path})`;
 }
@@ -27683,6 +27711,10 @@ function runtimeRequest(endpoint, command, params, timeoutMs) {
 import { cpSync, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync8, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "node:fs";
 import { dirname as dirname3, join as join8 } from "node:path";
 var ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
+var RUNTIME_AUTOLOAD = {
+  name: "GdharnessRuntime",
+  path: "addons/gdharness_runtime/runtime_autoload.gd"
+};
 var VERSION_MARKER = ".gdharness-version";
 function installedAddonVersion(projectPath) {
   const marker = join8(projectPath, "addons", ADDONS[0], VERSION_MARKER);
@@ -27981,7 +28013,7 @@ var TOOL_SPECS = [
       uid: { summary: "the UID of one file", requires: ["resourcePath"] },
       refresh_uids: { summary: "resave every resource so UID references are current", requires: [] },
       refresh_classes: {
-        summary: "rewrite .godot/global_script_class_cache.cfg from the class_name declarations on disk, for an editor whose list has gone stale",
+        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',
         requires: []
       }
     }
@@ -28281,7 +28313,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_run",
-    description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way.",
+    description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice.",
     parameters: {
       projectPath: PROJECT_PATH,
       scene: { type: "string", description: "A scene to run instead of the main scene." },
@@ -28326,7 +28358,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_rescan",
-    description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. The scan is a change-detecting walk rather than an unconditional reparse, so a file the editor has already recorded and reads as unchanged is one it does not look inside again: a class_name usually becomes visible this way and on one project did not, with the cache on disk still missing it after the scan said it was done. project_import refresh_classes is the one that rebuilds the class list from the declarations on disk, whatever the editor thinks it has seen. Needs the editor connected.",
+    description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is a change to the declaring script, or editor_launch restart; project_import refresh_classes rewrites the cache and does not touch what the editor is holding. Needs the editor connected.",
     parameters: {
       projectPath: PROJECT_PATH,
       timeoutMs: { type: "number", description: "How long to wait for the scan. Default 30000." }
@@ -28871,6 +28903,10 @@ function realPathOr(path) {
     return path;
   }
 }
+function samePath(one, other) {
+  const settled = (path) => realPathOr(path).replaceAll("\\", "/").replace(/\/+$/, "").toLowerCase();
+  return settled(one) === settled(other);
+}
 var RUNNER_DIRECTORY = "addons/gdUnit4/";
 function aboveTheRunner(entry) {
   const runner = entry.detail.findIndex((line) => line.includes(RUNNER_DIRECTORY));
@@ -29302,7 +29338,8 @@ class GodotServer {
   async dispatch(tool, op, args) {
     const headless = HEADLESS_OPERATIONS[tool]?.[op];
     if (headless !== undefined) {
-      return await this.headless(headless, args);
+      const answered = await this.headless(headless, args);
+      return headless === "refresh_class_cache" && this.godotBridge.isConnected() ? await this.alsoSayWhatTheEditorCannotSee(answered, args) : answered;
     }
     const { op: _op, ...arguments_ } = args;
     const bridge = async (command, extra = {}) => {
@@ -30107,7 +30144,7 @@ class GodotServer {
       if (Date.now() >= deadline) {
         return false;
       }
-      await delay2(250);
+      await delay3(250);
     }
   }
   async handleLaunchEditor(args) {
@@ -30203,12 +30240,13 @@ class GodotServer {
       this.logDebug("Ending the running game before starting another");
       await this.endActiveGame();
     }
+    const alreadyPlaying = new Set(discoverRuntimes().map((endpoint) => endpoint.pid));
     const headless = resolveHeadless(args["headless"], {
       platform: process.platform,
       variables: process.env
     });
     if (this.godotBridge.isConnected() && (!headless || editorPlaysHeadless(project.value.file))) {
-      return await this.playThroughEditor(sceneArgument, refreshed.value);
+      return await this.playThroughEditor(sceneArgument, refreshed.value, project.value.path, alreadyPlaying);
     }
     const cmdArgs = runArguments({
       projectPath: project.value.path,
@@ -30224,10 +30262,31 @@ class GodotServer {
       pid: started.process.pid ?? null,
       arguments: cmdArgs,
       refreshedClasses: refreshed.value,
+      runtime: await this.runtimeUp(project.value.path, alreadyPlaying),
       message: "Use editor_output for what it prints and editor_run stop to end it."
     });
   }
-  async playThroughEditor(scene, refreshedClasses) {
+  async runtimeUp(projectPath, before) {
+    if (!existsSync7(join9(projectPath, RUNTIME_AUTOLOAD.path))) {
+      return {
+        listening: false,
+        note: "this project has no gdharness_runtime addon, so the runtime_* tools have nothing to talk to"
+      };
+    }
+    const endpoint = await announcedSince(projectPath, before, {
+      giveUp: () => this.dapClient?.isStopped() === true
+    });
+    if (endpoint === null) {
+      const held = this.dapClient?.whereItStopped() ?? null;
+      return {
+        listening: false,
+        note: held === null ? `nothing announced itself within ${ANNOUNCE_BUDGET_MS}ms: the game may be slow to boot, or its runtime is not coming up` : "the game stopped before its runtime came up, so the runtime_* tools have nothing to talk to yet: debug_control continue lets it carry on",
+        heldAt: held
+      };
+    }
+    return { listening: true, pid: endpoint.pid, port: endpoint.port };
+  }
+  async playThroughEditor(scene, refreshedClasses, projectPath, alreadyPlaying) {
     const log = new GameLog;
     try {
       await this.dap().connect();
@@ -30256,6 +30315,7 @@ class GodotServer {
       scene: scene === null ? "the main scene" : `res://${scene}`,
       refreshedClasses,
       debugPort: readNumber(asParams(JSON.parse(answer.content[0]?.text ?? "{}")), "debugPort"),
+      runtime: await this.runtimeUp(projectPath, alreadyPlaying),
       message: "The editor is playing it, so its debugger holds it: the debug_* tools can reach it, " + "editor_output reads its console through the debug adapter, and editor_run stop ends it."
     });
   }
@@ -30410,13 +30470,59 @@ class GodotServer {
       const status = asParams(await this.godotBridge.invokeTool("rescan_filesystem", { ...args, statusOnly: true }));
       busy = Boolean(status["scanning"]) || Boolean(status["importing"]);
     }
+    const checked = busy ? { unseen: [] } : await this.classesTheEditorCannotSee(args);
+    const unseen = checked.unseen;
     return this.jsonTextResponse({
-      ok: !busy,
+      ok: !busy && unseen.length === 0 && checked.unchecked === undefined,
       stillWorking: busy,
       waitedMs: Date.now() - started,
-      note: busy ? "The editor was still scanning or importing when the wait ran out, so new files may not be visible yet." : undefined
+      unseenByEditor: unseen.length > 0 ? unseen : undefined,
+      classesUnchecked: checked.unchecked,
+      note: busy ? "The editor was still scanning or importing when the wait ran out, so new files may not be visible yet." : unseen.length > 0 ? "The scan finished and these classes are still not in the list the editor resolves against, so every use of them reads as an unknown identifier. Its walk skips a file another engine has already imported. Change the declaring script and rescan, or restart the editor with editor_launch restart." : undefined
     });
   }
+  async alsoSayWhatTheEditorCannotSee(answered, args) {
+    const first = answered.content[0];
+    if (answered.isError || first?.type !== "text" || typeof first.text !== "string") {
+      return answered;
+    }
+    const checked = await this.classesTheEditorCannotSee(args);
+    if (checked.unseen.length === 0 && checked.unchecked === undefined) {
+      return answered;
+    }
+    return this.jsonTextResponse({
+      ...asParams(JSON.parse(first.text)),
+      unseenByEditor: checked.unseen.length > 0 ? checked.unseen : undefined,
+      classesUnchecked: checked.unchecked,
+      note: checked.unseen.length > 0 ? "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. Change the declaring script and editor_rescan, or restart the editor with editor_launch restart." : undefined
+    });
+  }
+  async classesTheEditorCannotSee(args) {
+    const projectPath = typeof args["projectPath"] === "string" ? args["projectPath"] : "";
+    if (projectPath === "") {
+      return { unseen: [], unchecked: "no projectPath, so there was nothing to read the cache from" };
+    }
+    const open = this.godotBridge.getStatus().projectPath;
+    if (open === undefined || !samePath(open, projectPath)) {
+      return {
+        unseen: [],
+        unchecked: `the connected editor is open on ${open ?? "a project it did not name"}, not this one`
+      };
+    }
+    let held;
+    try {
+      held = asParams(await this.godotBridge.invokeTool("global_classes", args));
+    } catch (error) {
+      return {
+        unseen: [],
+        unchecked: `the editor would not say what classes it is holding: ${errorMessage(error)}`
+      };
+    }
+    if (!Array.isArray(held["classes"])) {
+      return { unseen: [], unchecked: "the editor answered without a class list in it" };
+    }
+    return { unseen: unseenByEditor(projectPath, held["classes"].map(String)) };
+  }
   async handleViaBridge(toolName, args) {
     if (!this.godotBridge.isConnected()) {
       return this.createErrorResponse("Editor not connected: no Godot editor with the gdharness editor addon has reached this server.", [

package/package.json

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