gdharness 0.13.12 → 0.13.14

package/build/cli.js

@@ -7557,6 +7557,41 @@ function cachedClasses(projectPath) {
   }
   return listed;
 }
+function missingMemberIn(message) {
+  const found = /The (method|property) "([^"(]+)(?:\(\))?" is not present on the inferred type "([^"]+)"/.exec(message);
+  if (found === null) {
+    return null;
+  }
+  return {
+    kind: found[1] === "property" ? "property" : "method",
+    member: found[2] ?? "",
+    type: found[3] ?? ""
+  };
+}
+function declaresMember(source, missing) {
+  const name = missing.member.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const declaration = missing.kind === "method" ? new RegExp(String.raw`^\s*(?:static\s+)?func\s+${name}\s*\(`, "m") : new RegExp(String.raw`^\s*(?:static\s+)?(?:@export\s+)?(?:var|const)\s+${name}\b`, "m");
+  return declaration.test(source);
+}
+function contradictedDiagnostics(messages, classes, sourceOf) {
+  const read = new Map;
+  const found = [];
+  for (const message of messages) {
+    const missing = missingMemberIn(message);
+    const declaredIn = missing === null ? undefined : classes.get(missing.type);
+    if (missing === null || declaredIn === undefined) {
+      continue;
+    }
+    if (!read.has(declaredIn)) {
+      read.set(declaredIn, sourceOf(declaredIn));
+    }
+    const source = read.get(declaredIn) ?? null;
+    if (source !== null && declaresMember(source, missing)) {
+      found.push({ ...missing, declaredIn });
+    }
+  }
+  return found;
+}
 function cacheWrittenAt(projectPath) {
   const cache = join6(projectPath, ".godot", "global_script_class_cache.cfg");
   try {
@@ -7621,6 +7656,36 @@ function reason2(stdout, stderr) {
   }
   return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
 }
+async function runImport(godotPath, projectPath) {
+  const logDir = mkdtempSync2(join7(tmpdir3(), "gdharness-import-"));
+  try {
+    const { stderr } = await run3(godotPath, [
+      "--headless",
+      "--log-file",
+      join7(logDir, "engine.log"),
+      "--path",
+      projectPath,
+      "--import"
+    ]);
+    return { ok: true, messages: problems2(stderr) };
+  } catch (error) {
+    if (error instanceof Error && "stdout" in error && "stderr" in error) {
+      const failed = error;
+      return {
+        ok: false,
+        message: `the import pass failed (exit ${failed.code ?? "unknown"}): ${reason2(failed.stdout, failed.stderr)}`,
+        messages: problems2(failed.stderr)
+      };
+    }
+    return {
+      ok: false,
+      message: `the import pass could not be run: ${error instanceof Error ? error.message : String(error)}`,
+      messages: []
+    };
+  } finally {
+    discard(logDir);
+  }
+}
 async function runOperation2(engine, operation, params, projectPath) {
   const paramsDir = mkdtempSync2(join7(tmpdir3(), "gdharness-params-"));
   const paramsFile = join7(paramsDir, `${operation}.json`);
@@ -15475,7 +15540,10 @@ var init_tool_definitions = __esm(() => {
           requires: []
         },
         uid: { summary: "the UID of one file", requires: ["resourcePath"] },
-        refresh_uids: { summary: "resave every resource so UID references are current", requires: [] },
+        refresh_uids: {
+          summary: "import the project so every script and shader has its .uid sidecar, and name under uidsCreated the ones this made and under stillWithoutUid the ones the engine would not import: it writes no scene and no script, so a project whose sidecars are all present is left untouched",
+          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',
           requires: []
@@ -15716,7 +15784,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.",
+      description: "Errors and warnings for a script from the editor's language server, and whether the script is clean. Needs the editor running. Any diagnostic saying a member is not present on an inferred type is checked against the file the class cache points at, and one the file contradicts is named under contradictedByTheFile with staleAnalysis saying what to do: the language server hands dependents the type it analysed at startup, so a method added to an existing class_name is reported missing at every caller until the editor restarts.",
       parameters: {
         projectPath: PROJECT_PATH,
         scriptPath: SCRIPT_PATH
@@ -16223,7 +16291,7 @@ var init_tool_definitions = __esm(() => {
 });
 
 // src/headless-operations.ts
-var HEADLESS_OPERATIONS, EDITOR_READS;
+var HEADLESS_OPERATIONS, ENGINE_PASSES, EDITOR_READS;
 var init_headless_operations = __esm(() => {
   HEADLESS_OPERATIONS = dictionary({
     project_settings: dictionary({
@@ -16245,7 +16313,6 @@ var init_headless_operations = __esm(() => {
       set_options: "set_import_options",
       reimport: "reimport_resource",
       uid: "get_uid",
-      refresh_uids: "resave_resources",
       refresh_classes: "refresh_class_cache"
     }),
     project_export: dictionary({ list: "list_export_presets" }),
@@ -16257,6 +16324,9 @@ var init_headless_operations = __esm(() => {
       inheritance: "inspect_inheritance"
     })
   });
+  ENGINE_PASSES = dictionary({
+    project_import: dictionary({ refresh_uids: "import" })
+  });
   EDITOR_READS = dictionary({
     project_settings: dictionary({ get: "get_project_setting" })
   });
@@ -36049,6 +36119,33 @@ function projectStructure(projectPath) {
   visit(projectPath);
   return structure;
 }
+function scriptsWithoutUid(projectPath) {
+  const found = [];
+  const visit = (directory, prefix) => {
+    if (steppedOver(directory)) {
+      return;
+    }
+    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
+      if (skipped(entry.name)) {
+        continue;
+      }
+      const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+      if (entry.isDirectory()) {
+        visit(join13(directory, entry.name), spelled);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
+      if (CARRIES_A_UID.has(extension) && !existsSync11(join13(directory, `${entry.name}.uid`))) {
+        found.push(spelled);
+      }
+    }
+  };
+  visit(projectPath, "");
+  return found.sort();
+}
 function searchProject(projectPath, options) {
   const extensions = new Set(options.fileTypes.map((ext) => ext.replace(/^\./, "").toLowerCase()).filter(Boolean));
   const result = {
@@ -36108,10 +36205,11 @@ function searchProject(projectPath, options) {
   visit(projectPath);
   return result;
 }
-var SKIPPED, ASSET_EXTENSIONS;
+var SKIPPED, ASSET_EXTENSIONS, CARRIES_A_UID;
 var init_project_scan = __esm(() => {
   SKIPPED = new Set(["node_modules"]);
   ASSET_EXTENSIONS = new Set(["png", "jpg", "jpeg", "webp", "svg", "ttf", "otf", "wav", "mp3", "ogg"]);
+  CARRIES_A_UID = new Set(["gd", "shader", "gdshader"]);
 });
 
 // src/runtime-client.ts
@@ -37218,6 +37316,9 @@ class GodotServer {
     return { ok: true, op };
   }
   async dispatch(tool, op, args) {
+    if (ENGINE_PASSES[tool]?.[op] !== undefined) {
+      return await this.handleRefreshUids(args);
+    }
     const headless = HEADLESS_OPERATIONS[tool]?.[op];
     if (headless !== undefined) {
       const { from: asked, ...answerable } = args;
@@ -37588,6 +37689,33 @@ class GodotServer {
     const { op: _op, projectPath: _projectPath, ...params } = contained.value;
     return this.answer(await this.operation(operation, params, project.value.path));
   }
+  async handleRefreshUids(args) {
+    const project = this.project(args);
+    if (!project.ok) {
+      return project.response;
+    }
+    const engine = await this.engine();
+    if (!engine.ok) {
+      return this.createErrorResponse("No Godot executable found.");
+    }
+    const projectPath = project.value.path;
+    const before = scriptsWithoutUid(projectPath);
+    const imported = await runImport(engine.value, projectPath);
+    if (!imported.ok) {
+      return this.answer(imported);
+    }
+    const after = scriptsWithoutUid(projectPath);
+    const given = before.filter((script) => !after.includes(script));
+    return this.answer({
+      ok: true,
+      messages: imported.messages,
+      payload: {
+        uidsCreated: given,
+        stillWithoutUid: after,
+        note: after.length > 0 ? `${after.length} still have no .uid, which is the engine declining to import them rather than this op skipping them. No scene was written.` : "No scene was written: this reads the project and imports it, and does not resave anything."
+      }
+    });
+  }
   async operation(operation, params, projectPath) {
     const engine = await this.engine();
     if (!engine.ok) {
@@ -37922,14 +38050,44 @@ class GodotServer {
       const severity = asParams(entry)["severity"];
       return severity === 1 || severity === "error" || severity === "ERROR";
     }).length;
+    const contradicted = this.contradictedByTheFile(diagnostics, args);
     return this.jsonTextResponse(markIfStale({
       scriptPath: readString(args, "scriptPath"),
       clean: errors === 0,
       errors,
       warnings: diagnostics.length - errors,
-      diagnostics
+      diagnostics,
+      ...contradicted.length === 0 ? {} : {
+        contradictedByTheFile: contradicted,
+        staleAnalysis: `The editor is reporting against an older copy of ${contradicted.length === 1 ? "a type" : "some types"} named above. Each member listed is declared in the file the class cache points at, so those diagnostics are wrong however the code is written. editor_launch restart clears it; editor_rescan and project_import refresh_classes do not, because neither reaches the analysed types the language server built at startup.`
+      }
     }, this.godotBridge.getStatus().addonVersion, SERVER_VERSION));
   }
+  contradictedByTheFile(diagnostics, args) {
+    const messages = diagnostics.map((entry) => asParams(entry)["message"]).filter((message) => typeof message === "string");
+    if (!messages.some((message) => missingMemberIn(message) !== null)) {
+      return [];
+    }
+    const project = this.project(args);
+    if (!project.ok) {
+      return [];
+    }
+    const classes = cachedClasses(project.value.path);
+    if (classes === null) {
+      return [];
+    }
+    return contradictedDiagnostics(messages, classes, (resourcePath) => {
+      const contained = resolveWithinProject(project.value.path, resourcePath);
+      if (!contained.ok || !existsSync14(contained.absolutePath)) {
+        return null;
+      }
+      try {
+        return readFileSync15(contained.absolutePath, "utf8");
+      } catch {
+        return null;
+      }
+    });
+  }
   async handleLSP(toolName, args) {
     const port = this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT);
     if (this.lspClient !== null && this.lspClient.port !== port) {
@@ -40347,7 +40505,13 @@ function namedType(declared) {
   return "any";
 }
 function headlessSection() {
-  const byTool = Object.entries(HEADLESS_OPERATIONS).map(([tool, ops]) => `\`${tool}\` (${Object.keys(ops).join(", ")})`).sort();
+  const everyOp = new Map;
+  for (const table of [HEADLESS_OPERATIONS, ENGINE_PASSES]) {
+    for (const [tool, ops] of Object.entries(table)) {
+      everyOp.set(tool, [...everyOp.get(tool) ?? [], ...Object.keys(ops)]);
+    }
+  }
+  const byTool = [...everyOp].map(([tool, ops]) => `\`${tool}\` (${ops.join(", ")})`).sort();
   return [
     "## What a gate can call",
     "",
@@ -40360,7 +40524,8 @@ function headlessSection() {
     "Needing nothing is not the same as changing nothing, and a gate wants both. Most of these",
     "write to the project because that is what they are for: `script_edit create` writes a file,",
     "`project_settings set` rewrites `project.godot`, `project_import reimport` and `refresh_classes`",
-    "write under `.godot`. The reading ops are the ones to gate on, and which is which is in each",
+    "write under `.godot`, and `project_import refresh_uids` writes a `.uid` beside each script that",
+    "had none. The reading ops are the ones to gate on, and which is which is in each",
     "op's own summary below rather than assumed from this list.",
     "",
     "Everything else needs the editor (`editor_*`, `debug_*`, `scene_*`, `resource_*`) or a running",

package/build/godot/operations/godot_operations.gd

@@ -108,8 +108,6 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 		# Resource files
 		"get_uid":
 			payload = ResourceFiles.new(_log).get_uid(params)
-		"resave_resources":
-			payload = ResourceFiles.new(_log).resave_resources(params)
 		"refresh_class_cache":
 			payload = ClassCache.new(_log).refresh_class_cache(params)
 

package/build/godot/operations/resource_files.gd

@@ -1,10 +1,8 @@
 extends RefCounted
 
-const FileWalk = preload("file_walk.gd")
 const Log = preload("logger.gd")
 
 var _log: Log
-var _files: FileWalk = FileWalk.new()
 
 
 func _init(p_log: Log) -> void:
@@ -41,92 +39,3 @@ func get_uid(params: Dictionary) -> Dictionary:
 	return {
 		"file": file_path, "absolute_path": absolute_path, "uid": uid_content.strip_edges(), "exists": true
 	}
-
-
-# Resave every scene, script and shader so that UID references are current.
-func resave_resources(_params: Dictionary) -> Dictionary:
-	_log.info("Resaving all resources to update UID references...")
-	var project_path: String = "res://"
-
-	var scenes: Array[String] = _files.find_files(project_path, ".tscn")
-	_log.debug("Found " + str(scenes.size()) + " scenes")
-
-	# Resave each scene
-	var success_count: int = 0
-	var error_count: int = 0
-
-	for scene_path: String in scenes:
-		_log.debug("Processing scene: " + scene_path)
-
-		if not FileAccess.file_exists(scene_path):
-			_log.error("Scene file does not exist at: " + scene_path)
-			error_count += 1
-			continue
-
-		var scene: Resource = load(scene_path)
-		if not scene:
-			error_count += 1
-			_log.error("Failed to load: " + scene_path)
-			continue
-
-		var error: Error = ResourceSaver.save(scene, scene_path)
-		if error != OK:
-			error_count += 1
-			_log.error("Failed to save: " + scene_path + ", error: " + str(error))
-			continue
-
-		success_count += 1
-		if _log.debug_mode:
-			_log.debug("Scene saved successfully: " + scene_path)
-			var file_check_after: bool = FileAccess.file_exists(scene_path)
-			_log.debug("File exists check after save: " + str(file_check_after))
-			if not file_check_after:
-				_log.error("File reported as saved but does not exist at: " + scene_path)
-
-	# A UID sits beside every script and shader as a .uid file. Outside the editor the save
-	# below answers OK and writes no sidecar, so what comes back is what was resaved and how
-	# many are still without one, rather than a count of UIDs this made.
-	var scripts: Array[String] = (
-		_files.find_files(project_path, ".gd")
-		+ _files.find_files(project_path, ".shader")
-		+ _files.find_files(project_path, ".gdshader")
-	)
-	_log.debug("Found " + str(scripts.size()) + " scripts/shaders")
-
-	var missing_uids: int = 0
-	var resaved_scripts: int = 0
-
-	for script_path: String in scripts:
-		_log.debug("Checking UID for: " + script_path)
-		var uid_path: String = script_path + ".uid"
-
-		var f: FileAccess = FileAccess.open(uid_path, FileAccess.READ)
-		if f:
-			_log.debug("UID file already exists for: " + script_path)
-			continue
-
-		missing_uids += 1
-		_log.debug("Missing UID file for: " + script_path + ", resaving...")
-
-		var res: Resource = load(script_path)
-		if not res:
-			_log.error("Failed to load resource: " + script_path)
-			continue
-
-		var error: Error = ResourceSaver.save(res, script_path)
-		if error != OK:
-			_log.error("Failed to resave: " + script_path + ", error: " + str(error))
-			continue
-
-		resaved_scripts += 1
-		_log.debug("Resaved: " + script_path)
-
-	_log.info("Resave operation complete")
-
-	return {
-		"scenes_processed": scenes.size(),
-		"scenes_saved": success_count,
-		"scenes_with_errors": error_count,
-		"scripts_missing_uids": missing_uids,
-		"scripts_resaved": resaved_scripts
-	}

package/build/index.js

@@ -24817,6 +24817,41 @@ function cachedClasses(projectPath) {
   }
   return listed;
 }
+function missingMemberIn(message) {
+  const found = /The (method|property) "([^"(]+)(?:\(\))?" is not present on the inferred type "([^"]+)"/.exec(message);
+  if (found === null) {
+    return null;
+  }
+  return {
+    kind: found[1] === "property" ? "property" : "method",
+    member: found[2] ?? "",
+    type: found[3] ?? ""
+  };
+}
+function declaresMember(source, missing) {
+  const name = missing.member.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const declaration = missing.kind === "method" ? new RegExp(String.raw`^\s*(?:static\s+)?func\s+${name}\s*\(`, "m") : new RegExp(String.raw`^\s*(?:static\s+)?(?:@export\s+)?(?:var|const)\s+${name}\b`, "m");
+  return declaration.test(source);
+}
+function contradictedDiagnostics(messages, classes, sourceOf) {
+  const read = new Map;
+  const found = [];
+  for (const message of messages) {
+    const missing = missingMemberIn(message);
+    const declaredIn = missing === null ? undefined : classes.get(missing.type);
+    if (missing === null || declaredIn === undefined) {
+      continue;
+    }
+    if (!read.has(declaredIn)) {
+      read.set(declaredIn, sourceOf(declaredIn));
+    }
+    const source = read.get(declaredIn) ?? null;
+    if (source !== null && declaresMember(source, missing)) {
+      found.push({ ...missing, declaredIn });
+    }
+  }
+  return found;
+}
 function cacheWrittenAt(projectPath) {
   const cache = join3(projectPath, ".godot", "global_script_class_cache.cfg");
   try {
@@ -26390,6 +26425,36 @@ function reason(stdout, stderr) {
   }
   return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
 }
+async function runImport(godotPath, projectPath) {
+  const logDir = mkdtempSync(join6(tmpdir2(), "gdharness-import-"));
+  try {
+    const { stderr } = await run2(godotPath, [
+      "--headless",
+      "--log-file",
+      join6(logDir, "engine.log"),
+      "--path",
+      projectPath,
+      "--import"
+    ]);
+    return { ok: true, messages: problems(stderr) };
+  } catch (error) {
+    if (error instanceof Error && "stdout" in error && "stderr" in error) {
+      const failed = error;
+      return {
+        ok: false,
+        message: `the import pass failed (exit ${failed.code ?? "unknown"}): ${reason(failed.stdout, failed.stderr)}`,
+        messages: problems(failed.stderr)
+      };
+    }
+    return {
+      ok: false,
+      message: `the import pass could not be run: ${error instanceof Error ? error.message : String(error)}`,
+      messages: []
+    };
+  } finally {
+    discard(logDir);
+  }
+}
 async function runOperation(engine, operation, params, projectPath) {
   const paramsDir = mkdtempSync(join6(tmpdir2(), "gdharness-params-"));
   const paramsFile = join6(paramsDir, `${operation}.json`);
@@ -26459,7 +26524,6 @@ var HEADLESS_OPERATIONS = dictionary({
     set_options: "set_import_options",
     reimport: "reimport_resource",
     uid: "get_uid",
-    refresh_uids: "resave_resources",
     refresh_classes: "refresh_class_cache"
   }),
   project_export: dictionary({ list: "list_export_presets" }),
@@ -26471,6 +26535,9 @@ var HEADLESS_OPERATIONS = dictionary({
     inheritance: "inspect_inheritance"
   })
 });
+var ENGINE_PASSES = dictionary({
+  project_import: dictionary({ refresh_uids: "import" })
+});
 var EDITOR_READS = dictionary({
   project_settings: dictionary({ get: "get_project_setting" })
 });
@@ -27408,6 +27475,34 @@ function projectStructure(projectPath) {
   visit(projectPath);
   return structure;
 }
+var CARRIES_A_UID = new Set(["gd", "shader", "gdshader"]);
+function scriptsWithoutUid(projectPath) {
+  const found = [];
+  const visit = (directory, prefix) => {
+    if (steppedOver(directory)) {
+      return;
+    }
+    for (const entry of readdirSync3(directory, { withFileTypes: true })) {
+      if (skipped(entry.name)) {
+        continue;
+      }
+      const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+      if (entry.isDirectory()) {
+        visit(join7(directory, entry.name), spelled);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
+      if (CARRIES_A_UID.has(extension) && !existsSync6(join7(directory, `${entry.name}.uid`))) {
+        found.push(spelled);
+      }
+    }
+  };
+  visit(projectPath, "");
+  return found.sort();
+}
 function searchProject(projectPath, options) {
   const extensions = new Set(options.fileTypes.map((ext) => ext.replace(/^\./, "").toLowerCase()).filter(Boolean));
   const result = {
@@ -28562,7 +28657,10 @@ var TOOL_SPECS = [
         requires: []
       },
       uid: { summary: "the UID of one file", requires: ["resourcePath"] },
-      refresh_uids: { summary: "resave every resource so UID references are current", requires: [] },
+      refresh_uids: {
+        summary: "import the project so every script and shader has its .uid sidecar, and name under uidsCreated the ones this made and under stillWithoutUid the ones the engine would not import: it writes no scene and no script, so a project whose sidecars are all present is left untouched",
+        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',
         requires: []
@@ -28803,7 +28901,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.",
+    description: "Errors and warnings for a script from the editor's language server, and whether the script is clean. Needs the editor running. Any diagnostic saying a member is not present on an inferred type is checked against the file the class cache points at, and one the file contradicts is named under contradictedByTheFile with staleAnalysis saying what to do: the language server hands dependents the type it analysed at startup, so a method added to an existing class_name is reported missing at every caller until the editor restarts.",
     parameters: {
       projectPath: PROJECT_PATH,
       scriptPath: SCRIPT_PATH
@@ -29970,6 +30068,9 @@ class GodotServer {
     return { ok: true, op };
   }
   async dispatch(tool, op, args) {
+    if (ENGINE_PASSES[tool]?.[op] !== undefined) {
+      return await this.handleRefreshUids(args);
+    }
     const headless = HEADLESS_OPERATIONS[tool]?.[op];
     if (headless !== undefined) {
       const { from: asked, ...answerable } = args;
@@ -30340,6 +30441,33 @@ class GodotServer {
     const { op: _op, projectPath: _projectPath, ...params } = contained.value;
     return this.answer(await this.operation(operation, params, project.value.path));
   }
+  async handleRefreshUids(args) {
+    const project = this.project(args);
+    if (!project.ok) {
+      return project.response;
+    }
+    const engine = await this.engine();
+    if (!engine.ok) {
+      return this.createErrorResponse("No Godot executable found.");
+    }
+    const projectPath = project.value.path;
+    const before = scriptsWithoutUid(projectPath);
+    const imported = await runImport(engine.value, projectPath);
+    if (!imported.ok) {
+      return this.answer(imported);
+    }
+    const after = scriptsWithoutUid(projectPath);
+    const given = before.filter((script) => !after.includes(script));
+    return this.answer({
+      ok: true,
+      messages: imported.messages,
+      payload: {
+        uidsCreated: given,
+        stillWithoutUid: after,
+        note: after.length > 0 ? `${after.length} still have no .uid, which is the engine declining to import them rather than this op skipping them. No scene was written.` : "No scene was written: this reads the project and imports it, and does not resave anything."
+      }
+    });
+  }
   async operation(operation, params, projectPath) {
     const engine = await this.engine();
     if (!engine.ok) {
@@ -30674,14 +30802,44 @@ class GodotServer {
       const severity = asParams(entry)["severity"];
       return severity === 1 || severity === "error" || severity === "ERROR";
     }).length;
+    const contradicted = this.contradictedByTheFile(diagnostics, args);
     return this.jsonTextResponse(markIfStale({
       scriptPath: readString(args, "scriptPath"),
       clean: errors === 0,
       errors,
       warnings: diagnostics.length - errors,
-      diagnostics
+      diagnostics,
+      ...contradicted.length === 0 ? {} : {
+        contradictedByTheFile: contradicted,
+        staleAnalysis: `The editor is reporting against an older copy of ${contradicted.length === 1 ? "a type" : "some types"} named above. Each member listed is declared in the file the class cache points at, so those diagnostics are wrong however the code is written. editor_launch restart clears it; editor_rescan and project_import refresh_classes do not, because neither reaches the analysed types the language server built at startup.`
+      }
     }, this.godotBridge.getStatus().addonVersion, SERVER_VERSION));
   }
+  contradictedByTheFile(diagnostics, args) {
+    const messages = diagnostics.map((entry) => asParams(entry)["message"]).filter((message) => typeof message === "string");
+    if (!messages.some((message) => missingMemberIn(message) !== null)) {
+      return [];
+    }
+    const project = this.project(args);
+    if (!project.ok) {
+      return [];
+    }
+    const classes = cachedClasses(project.value.path);
+    if (classes === null) {
+      return [];
+    }
+    return contradictedDiagnostics(messages, classes, (resourcePath) => {
+      const contained = resolveWithinProject(project.value.path, resourcePath);
+      if (!contained.ok || !existsSync9(contained.absolutePath)) {
+        return null;
+      }
+      try {
+        return readFileSync11(contained.absolutePath, "utf8");
+      } catch {
+        return null;
+      }
+    });
+  }
   async handleLSP(toolName, args) {
     const port = this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT);
     if (this.lspClient !== null && this.lspClient.port !== port) {

package/package.json

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