gdharness 0.13.2 → 0.13.4

package/build/index.js

@@ -10142,19 +10142,18 @@ import { execFile as execFile4, spawn } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   closeSync,
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   fstatSync,
   mkdirSync as mkdirSync5,
   mkdtempSync as mkdtempSync2,
   openSync as openSync2,
   readdirSync as readdirSync6,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync11,
   readSync,
-  realpathSync as realpathSync2,
   rmSync as rmSync5
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename2, dirname as dirname4, join as join10, normalize as normalize2 } from "node:path";
+import { basename as basename2, dirname as dirname4, join as join11, normalize as normalize2 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { promisify as promisify4 } from "node:util";
@@ -24779,7 +24778,7 @@ function withdrawBridge(path) {
 }
 
 // src/class-cache.ts
-import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync4, statSync } from "node:fs";
 import { join as join3 } from "node:path";
 function declaredClasses(projectPath) {
   const declared = new Map;
@@ -24817,6 +24816,14 @@ function cachedClasses(projectPath) {
   }
   return listed;
 }
+function cacheWrittenAt(projectPath) {
+  const cache = join3(projectPath, ".godot", "global_script_class_cache.cfg");
+  try {
+    return statSync(cache).mtimeMs;
+  } catch {
+    return null;
+  }
+}
 function staleAgainst(cached, projectPath) {
   return [...declaredClasses(projectPath)].filter(([name, path]) => cached.get(name) !== path).map(([name]) => name);
 }
@@ -24829,6 +24836,33 @@ function unseenByEditor(projectPath, editorHolds) {
   return [...declaredClasses(projectPath)].filter(([name]) => !held.has(name)).map(([className, path]) => ({ className, path }));
 }
 
+// src/config-pin.ts
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "node:fs";
+import { join as join4 } from "node:path";
+var PINNED = /\bgdharness@(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\b/g;
+function versionsNamedInConfig(projectPath) {
+  const config = join4(projectPath, ".mcp.json");
+  if (!existsSync3(config)) {
+    return [];
+  }
+  let text;
+  try {
+    text = readFileSync5(config, "utf8");
+    JSON.parse(text);
+  } catch {
+    return [];
+  }
+  return [...new Set([...text.matchAll(PINNED)].map((found) => found[1] ?? ""))].filter((version) => version !== "");
+}
+function configDisagrees(projectPath, serverVersion) {
+  const named = versionsNamedInConfig(projectPath);
+  const others = named.filter((version) => version !== serverVersion);
+  if (others.length === 0) {
+    return null;
+  }
+  return `.mcp.json in this project names gdharness@${others.join(" and gdharness@")}, and this server ` + `is ${serverVersion}. Whichever is meant to be right, nothing will change version until the ` + "MCP server is reconnected, and a pin kept anywhere else does not reach this file.";
+}
+
 // src/dap_client.ts
 import { createConnection } from "node:net";
 import { setTimeout as delay } from "node:timers/promises";
@@ -25554,11 +25588,19 @@ var import_websocket = __toESM(require_websocket(), 1);
 var import_websocket_server = __toESM(require_websocket_server(), 1);
 
 // src/paths.ts
+import { realpathSync } from "node:fs";
 import { isAbsolute, relative, resolve, sep } from "node:path";
 var RESOURCE_SCHEME = "res://";
 var OTHER_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]+:\/\//;
+function realPathOr(path) {
+  try {
+    return realpathSync.native(path);
+  } catch {
+    return path;
+  }
+}
 function isSameDirectory(onePath, otherPath) {
-  return relative(resolve(onePath), resolve(otherPath)) === "";
+  return relative(realPathOr(resolve(onePath)), realPathOr(resolve(otherPath))) === "";
 }
 function isWithinRoot(rootPath, candidatePath) {
   const step = relative(resolve(rootPath), resolve(candidatePath));
@@ -26082,14 +26124,14 @@ function getDefaultBridge(ownProject = null) {
 
 // src/godot-path.ts
 import { execFile } from "node:child_process";
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 import { normalize } from "node:path";
 import { promisify } from "node:util";
 
 // src/detection.ts
-import { existsSync as existsSync3, readdirSync as readdirSync2, statSync } from "node:fs";
+import { existsSync as existsSync4, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 function resolveHomeDirectory() {
   try {
     return homedir2();
@@ -26098,7 +26140,7 @@ function resolveHomeDirectory() {
   }
 }
 function scanDirectoryForGodotBinaries(directory, platform) {
-  if (!directory || !existsSync3(directory)) {
+  if (!directory || !existsSync4(directory)) {
     return [];
   }
   let entries;
@@ -26113,16 +26155,16 @@ function scanDirectoryForGodotBinaries(directory, platform) {
     if (!pattern.test(name)) {
       continue;
     }
-    const fullPath = join4(directory, name);
+    const fullPath = join5(directory, name);
     try {
-      const stat = statSync(fullPath);
+      const stat = statSync2(fullPath);
       if (stat.isFile()) {
         matches.push({ name, mtime: stat.mtimeMs });
       }
     } catch {}
   }
   matches.sort((a, b) => b.mtime - a.mtime);
-  return matches.map((m) => join4(directory, m.name));
+  return matches.map((m) => join5(directory, m.name));
 }
 function conventionalPaths(platform, home) {
   const paths = ["godot"];
@@ -26254,7 +26296,7 @@ class GodotLocator {
       return known;
     }
     let ok = false;
-    if (path === "godot" || existsSync4(path)) {
+    if (path === "godot" || existsSync5(path)) {
       try {
         await run(path, ["--version"]);
         ok = true;
@@ -26271,7 +26313,7 @@ class GodotLocator {
 import { execFile as execFile2 } from "node:child_process";
 import { mkdtempSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 var run2 = promisify2(execFile2);
 function snakeCased(params) {
@@ -26312,13 +26354,13 @@ function reason(stdout, stderr) {
   return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
 }
 async function runOperation(engine, operation, params, projectPath) {
-  const paramsDir = mkdtempSync(join5(tmpdir2(), "gdharness-params-"));
-  const paramsFile = join5(paramsDir, `${operation}.json`);
+  const paramsDir = mkdtempSync(join6(tmpdir2(), "gdharness-params-"));
+  const paramsFile = join6(paramsDir, `${operation}.json`);
   writeFileSync3(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
     "--log-file",
-    join5(paramsDir, "engine.log"),
+    join6(paramsDir, "engine.log"),
     "--path",
     projectPath,
     "--script",
@@ -26392,6 +26434,9 @@ var HEADLESS_OPERATIONS = dictionary({
     inheritance: "inspect_inheritance"
   })
 });
+var EDITOR_READS = dictionary({
+  project_settings: dictionary({ get: "get_project_setting" })
+});
 
 // src/issues.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -26718,7 +26763,7 @@ function orphansPrinted(printed) {
 }
 
 // src/lsp_client.ts
-import { realpathSync } from "node:fs";
+import { realpathSync as realpathSync2 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection2 } from "node:net";
 import { dirname as dirname2, resolve as resolve2 } from "node:path";
@@ -26736,7 +26781,7 @@ function diagnosticsKey(uri) {
     return decoded;
   }
   try {
-    return realpathSync.native(fileURLToPath(decoded)).toLowerCase();
+    return realpathSync2.native(fileURLToPath(decoded)).toLowerCase();
   } catch {
     return decoded.toLowerCase();
   }
@@ -27287,14 +27332,14 @@ function secondsFromClock(printed) {
 }
 
 // src/project-scan.ts
-import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync5 } from "node:fs";
-import { join as join6 } from "node:path";
+import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync6 } from "node:fs";
+import { join as join7 } from "node:path";
 var SKIPPED = new Set(["node_modules"]);
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
 function steppedOver(directory) {
-  return existsSync5(join6(directory, ".gdignore"));
+  return existsSync6(join7(directory, ".gdignore"));
 }
 var ASSET_EXTENSIONS = new Set(["png", "jpg", "jpeg", "webp", "svg", "ttf", "otf", "wav", "mp3", "ogg"]);
 function projectStructure(projectPath) {
@@ -27308,7 +27353,7 @@ function projectStructure(projectPath) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join6(directory, entry.name));
+        visit(join7(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (extension === "tscn") {
@@ -27353,7 +27398,7 @@ function searchProject(projectPath, options) {
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join6(directory, entry.name);
+      const entryPath = join7(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -27364,7 +27409,7 @@ function searchProject(projectPath, options) {
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync5(entryPath, "utf8").split(`
+      for (const [index, line] of readFileSync6(entryPath, "utf8").split(`
 `).entries()) {
         if (full()) {
           break;
@@ -27387,7 +27432,7 @@ function searchProject(projectPath, options) {
 }
 
 // src/resources.ts
-import { readFileSync as readFileSync6 } from "node:fs";
+import { readFileSync as readFileSync7 } from "node:fs";
 import { extname, resolve as resolve3 } from "node:path";
 var STATIC_RESOURCES = [
   {
@@ -27558,7 +27603,7 @@ function readResourceText(uri, getProjectPath) {
   const parsedUri = parseGodotUri(uri);
   if (parsedUri.kind === "project-info") {
     const projectFilePath = resolveProjectFile(projectPath, "project.godot");
-    const rawProject = readFileSync6(projectFilePath, "utf-8");
+    const rawProject = readFileSync7(projectFilePath, "utf-8");
     const parsedProject = parseProjectGodot(rawProject);
     return {
       mimeType: "application/json",
@@ -27567,7 +27612,7 @@ function readResourceText(uri, getProjectPath) {
   }
   const filePath = resolveProjectFile(projectPath, parsedUri.resourcePath);
   ensureAllowedExtension(parsedUri.kind, filePath);
-  const text = readFileSync6(filePath, "utf-8");
+  const text = readFileSync7(filePath, "utf-8");
   return {
     mimeType: parsedUri.kind === "script" ? "text/x-gdscript" : "text/plain",
     text
@@ -27605,14 +27650,14 @@ function setupResourceHandlers(mcp, getProjectPath) {
 
 // src/run-record.ts
 import { execFileSync } from "node:child_process";
-import { mkdirSync as mkdirSync3, openSync, readdirSync as readdirSync5, readFileSync as readFileSync8, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync4 } from "node:fs";
-import { basename, join as join8 } from "node:path";
+import { mkdirSync as mkdirSync3, openSync, readdirSync as readdirSync5, readFileSync as readFileSync9, rmSync as rmSync3, statSync as statSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { basename, join as join9 } from "node:path";
 
 // src/runtime-client.ts
-import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync7, unlinkSync } from "node:fs";
+import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync8, unlinkSync } from "node:fs";
 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 { join as join8, resolve as resolve4 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
 
 // src/tool-args.ts
@@ -27680,13 +27725,13 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join7(perUser ?? tmpdir3(), "gdharness");
+  return join8(perUser ?? tmpdir3(), "gdharness");
 }
 function runtimeDirectories(variables = process.env) {
   const candidates = [runtimeDirectory(variables)];
   const fallbacks = process.platform === "win32" ? [envValue("SystemRoot", variables) ?? envValue("windir", variables) ?? "C:\\Windows"] : ["/tmp", "/var/tmp"];
   for (const base of fallbacks) {
-    candidates.push(join7(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+    candidates.push(join8(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
   return [...new Set(candidates.map((path) => resolve4(path)))];
 }
@@ -27701,7 +27746,7 @@ function processAlive(pid) {
 function parseAnnouncement(file, pid) {
   let fields;
   try {
-    fields = asParams(JSON.parse(readFileSync7(file, "utf8")));
+    fields = asParams(JSON.parse(readFileSync8(file, "utf8")));
   } catch {
     return { kind: "rubbish" };
   }
@@ -27740,7 +27785,7 @@ function discoverRuntimes(directories = runtimeDirectories()) {
   return runtimesAnnounced(directories).running;
 }
 function announcedIn(directory) {
-  if (!existsSync6(directory)) {
+  if (!existsSync7(directory)) {
     return [];
   }
   const found = [];
@@ -27749,7 +27794,7 @@ function announcedIn(directory) {
     if (!match) {
       continue;
     }
-    const file = join7(directory, entry);
+    const file = join8(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
     const announced = processAlive(pid) ? parseAnnouncement(file, pid) : { kind: "rubbish" };
     if (announced.kind === "rubbish") {
@@ -27910,17 +27955,17 @@ function runtimeRequest(endpoint, command, params, timeoutMs) {
 
 // src/run-record.ts
 function runsDirectory() {
-  return join8(runtimeDirectory(), "runs");
+  return join9(runtimeDirectory(), "runs");
 }
 function recordPath() {
-  return join8(runsDirectory(), "run.json");
+  return join9(runsDirectory(), "run.json");
 }
 function recordPaths() {
-  return runtimeDirectories().map((directory) => join8(directory, "runs", "run.json"));
+  return runtimeDirectories().map((directory) => join9(directory, "runs", "run.json"));
 }
 function openTranscript(startedAt) {
   mkdirSync3(runsDirectory(), { recursive: true });
-  const path = join8(runsDirectory(), `run-${startedAt}.log`);
+  const path = join9(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync(path, "a") };
 }
 function writeRunRecord(record) {
@@ -27949,7 +27994,7 @@ function readRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync8(path, "utf8"));
+    parsed = JSON.parse(readFileSync9(path, "utf8"));
   } catch {
     return null;
   }
@@ -27985,7 +28030,7 @@ function runningAs(pid) {
   }
   try {
     if (process.platform === "linux") {
-      const raw = readFileSync8(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync9(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw };
     }
     const args = execFileSync("ps", ["-p", String(pid), "-o", "args="], {
@@ -28060,7 +28105,7 @@ function clearRunRecord(ours = () => true) {
 }
 function ageMs(path, now) {
   try {
-    return now - statSync2(path).mtimeMs;
+    return now - statSync3(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -28078,7 +28123,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join8(directory, entry);
+    const path = join9(directory, entry);
     if (path === keep || ageMs(path, now) < keepMs) {
       continue;
     }
@@ -28089,8 +28134,8 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
 }
 
 // src/setup.ts
-import { cpSync, existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync9, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname3, join as join9 } from "node:path";
+import { cpSync, existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync10, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname3, join as join10 } from "node:path";
 var ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
 var RUNTIME_AUTOLOAD = {
   name: "GdharnessRuntime",
@@ -28098,15 +28143,23 @@ var RUNTIME_AUTOLOAD = {
 };
 var VERSION_MARKER = ".gdharness-version";
 function installedAddonVersion(projectPath) {
-  const marker = join9(projectPath, "addons", ADDONS[0], VERSION_MARKER);
-  if (!existsSync7(marker)) {
+  const marker = join10(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  if (!existsSync8(marker)) {
     return null;
   }
-  const said = readFileSync9(marker, "utf8").trim();
+  const said = readFileSync10(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 
 // src/tool-definitions.ts
+var PROJECT_INFO_SECTIONS = [
+  "autoloads",
+  "plugins",
+  "export_presets",
+  "audio_buses",
+  "health",
+  "validation"
+];
 function opTakes(spec, op, name) {
   const ops = spec.parameters[name]?.ops;
   return ops === undefined || ops.includes(op);
@@ -28140,7 +28193,7 @@ var NODE_PATH = {
 };
 var PROPERTIES = {
   type: "object",
-  description: 'Properties to set, keyed by Godot property name. Vectors, colours and the like may be written as {"x": 1, "y": 2} or tagged {"_type": "Vector2", "x": 1, "y": 2}.',
+  description: 'Properties to set, keyed by Godot property name. Vectors, colours and the like may be written as {"x": 1, "y": 2} or tagged {"_type": "Vector2", "x": 1, "y": 2}, which is the form a read answers with, so a value read off one node can be written straight to another.',
   additionalProperties: true
 };
 var XY = {
@@ -28263,10 +28316,7 @@ var TOOL_SPECS = [
       projectPath: PROJECT_PATH,
       include: {
         type: "array",
-        items: {
-          type: "string",
-          enum: ["autoloads", "plugins", "export_presets", "audio_buses", "health", "validation"]
-        },
+        items: { type: "string", enum: PROJECT_INFO_SECTIONS },
         description: "Extra sections: registered autoloads, addons and whether each is enabled, export presets, the audio bus layout, a health report, or export validation."
       },
       preset: { type: "string", description: "For validation: the export preset to validate against." },
@@ -28284,6 +28334,12 @@ var TOOL_SPECS = [
     parameters: {
       projectPath: PROJECT_PATH,
       setting: { type: "string", description: 'Setting path, such as "display/window/size/viewport_width".' },
+      from: {
+        type: "string",
+        enum: ["disk", "editor"],
+        ops: ["get"],
+        description: "get: where to read. Default disk, which starts a short-lived engine and reads project.godot, needs no editor and is what an automatic check can reproduce. editor asks the open editor instead, which costs no engine and answers what the editor holds, including changes nobody has saved. Asking for editor with none connected is refused rather than answered from disk, so an answer never means the other one quietly."
+      },
       prefix: {
         type: "string",
         ops: ["get"],
@@ -28775,7 +28831,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 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. The scan also writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class it cannot resolve is one the scan drops out of that file: unseenByEditor names it before a fresh engine, a CI run or a clone inherits it. 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 both halves in order: a change to the declaring script, saved, and then a rescan. Measured downstream, neither works alone, and a change on its own reads as the cure having failed. editor_launch restart also does it, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve can go out of that file with it, which one project saw and two could not reproduce; where it happens the answer names what the file lost under cacheLost, before a fresh engine, a CI run or a clone inherits it. Needs the editor connected.",
     parameters: {
       projectPath: PROJECT_PATH,
       timeoutMs: { type: "number", description: "How long to wait for the scan. Default 30000." }
@@ -29285,8 +29341,34 @@ function wrongTypes(spec, args) {
   }
   return complaints;
 }
+function unlistedValues(schema, value, path) {
+  if (typeof schema !== "object" || schema === null) {
+    return [];
+  }
+  const fields = schema;
+  const listed = fields["enum"];
+  if (Array.isArray(listed) && typeof value === "string") {
+    return listed.includes(value) ? [] : [`${path} as one of ${listed.join(", ")}, not ${JSON.stringify(value)}`];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((element, index) => unlistedValues(fields["items"], element, `${path}[${index}]`));
+  }
+  const properties = fields["properties"];
+  if (isPlainObject3(properties) && isPlainObject3(value)) {
+    return Object.entries(value).flatMap(([field, held]) => Object.hasOwn(properties, field) ? unlistedValues(properties[field], held, `${path}.${field}`) : []);
+  }
+  return [];
+}
+function isPlainObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function outsideTheirLists(spec, args) {
+  return Object.entries(args).flatMap(([name, value]) => unlistedValues(spec.parameters[name], value, name));
+}
 var BRIDGE_RETRY_MS = 2000;
 var SUCCESSOR_CHECK_MS = 1e4;
+var CACHE_WRITE_MS = 2000;
+var SCAN_START_MS = 2000;
 var WAIT_FOR_RUN_MS = 600000;
 var RUN_POLL_MS = 250;
 var PATH_SOLUTIONS = [
@@ -29320,7 +29402,7 @@ var DEBUG_STATE_CALLS = dictionary({
   output: "dap_get_output",
   variables: "dap_get_variables"
 });
-var PROJECT_INFO_SECTIONS = dictionary({
+var PROJECT_INFO_SECTIONS2 = dictionary({
   autoloads: { operation: "list_autoloads", params: () => ({}) },
   plugins: { operation: "list_plugins", params: () => ({}) },
   export_presets: { operation: "list_export_presets", params: () => ({}) },
@@ -29331,17 +29413,6 @@ var PROJECT_INFO_SECTIONS = dictionary({
     params: (args, detailed) => ({ preset: readString(args, "preset") ?? "", includeSuggestions: detailed })
   }
 });
-function realPathOr(path) {
-  try {
-    return realpathSync2.native(path);
-  } catch {
-    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));
@@ -29356,7 +29427,7 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync8(join10(projectPath, wanted))) {
+  if (wanted === "" || existsSync9(join11(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -29370,11 +29441,11 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync10(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync11(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync10(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync11(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -29390,7 +29461,7 @@ function camelCased(params) {
 class GodotServer {
   mcp;
   locator = new GodotLocator;
-  operationsScript = join10(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join11(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -29664,6 +29735,18 @@ class GodotServer {
         }
       });
     }
+    const disagreement = this.configDisagreement();
+    if (disagreement !== null) {
+      this.noticedUpdate = true;
+      this.callsSinceNotice = 0;
+      return this.saying(answer, {
+        config_names_another_version: {
+          server_is: SERVER_VERSION,
+          said: disagreement,
+          what_to_do: "Tell the user which version their config names and which one is answering, and that " + "the two will not meet until .mcp.json is right and the MCP server is reconnected. Do " + "not edit their config without asking: which of the two they meant is theirs to say."
+        }
+      });
+    }
     const notice = this.updates.notice();
     if (notice === null) {
       return answer;
@@ -29690,6 +29773,9 @@ class GodotServer {
     const installed = installedAddonVersion(this.ownProject);
     return installed === null || installed === SERVER_VERSION ? null : installed;
   }
+  configDisagreement() {
+    return this.ownProject === null ? null : configDisagrees(this.ownProject, SERVER_VERSION);
+  }
   withFeedbackNotice(answer) {
     this.callsSinceFeedback += 1;
     if (this.callsSinceFeedback < FEEDBACK_NOTICE_EVERY) {
@@ -29715,7 +29801,7 @@ class GodotServer {
         response: this.createErrorResponse(`${where} does not take ${unknown.join(", ")}. ${takes} This is gdharness ${SERVER_VERSION}, which is what decides whether an argument exists.`)
       };
     }
-    const wrong = wrongTypes(spec, args);
+    const wrong = [...wrongTypes(spec, args), ...outsideTheirLists(spec, args)];
     if (wrong.length > 0) {
       return { ok: false, response: this.createErrorResponse(`${spec.name} takes ${wrong.join("; ")}.`) };
     }
@@ -29767,7 +29853,25 @@ class GodotServer {
   async dispatch(tool, op, args) {
     const headless = HEADLESS_OPERATIONS[tool]?.[op];
     if (headless !== undefined) {
-      const answered = await this.headless(headless, args);
+      const { from: asked, ...answerable } = args;
+      if (asked === "editor") {
+        const editorSide = EDITOR_READS[tool]?.[op];
+        if (editorSide === undefined) {
+          return this.createErrorResponse(`${tool} ${op} cannot be read from the editor, only from disk.`, [
+            'Leave from unset, or pass from: "disk"'
+          ]);
+        }
+        if (!this.godotBridge.isConnected()) {
+          return this.createErrorResponse(`${tool} ${op} was asked of the editor, and no editor has reached this server.`, [
+            "editor_status says whether the bridge is up and whether an editor may yet connect",
+            'Open the project with editor_launch, or pass from: "disk" to read the file instead'
+          ]);
+        }
+        const { op: _dropped, ...asks } = answerable;
+        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;
     }
     const { op: _op, ...arguments_ } = args;
@@ -29982,8 +30086,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join10(path, "project.godot");
-    if (!existsSync8(file)) {
+    const file = join11(path, "project.godot");
+    if (!existsSync9(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -30140,9 +30244,9 @@ class GodotServer {
   }
   async handleProjectInfo(args) {
     const include = readStringArray(args, "include") ?? [];
-    const unknown = include.filter((name) => PROJECT_INFO_SECTIONS[name] === undefined);
+    const unknown = include.filter((name) => PROJECT_INFO_SECTIONS2[name] === undefined);
     if (unknown.length > 0) {
-      return this.createErrorResponse(`project_info cannot include ${unknown.join(", ")}. Sections: ${Object.keys(PROJECT_INFO_SECTIONS).join(", ")}.`);
+      return this.createErrorResponse(`project_info cannot include ${unknown.join(", ")}. Sections: ${Object.keys(PROJECT_INFO_SECTIONS2).join(", ")}.`);
     }
     const project = this.project(args);
     if (!project.ok) {
@@ -30152,7 +30256,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync10(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync11(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -30164,7 +30268,7 @@ class GodotServer {
     };
     const detailed = args["detail"] === "full";
     for (const section of include) {
-      const spec = PROJECT_INFO_SECTIONS[section];
+      const spec = PROJECT_INFO_SECTIONS2[section];
       if (spec === undefined) {
         continue;
       }
@@ -30220,11 +30324,11 @@ class GodotServer {
       return this.createErrorResponse(`Cannot create ${dirname4(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
-    const exportLogs = mkdtempSync2(join10(tmpdir4(), "gdharness-export-"));
+    const exportLogs = mkdtempSync2(join11(tmpdir4(), "gdharness-export-"));
     const exportArgs = [
       "--headless",
       "--log-file",
-      join10(exportLogs, "engine.log"),
+      join11(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -30252,7 +30356,7 @@ class GodotServer {
     log.finish();
     const problems = log.select({ severity: "warning", sinceLastCall: false, limit: 200 });
     const verdict = {
-      exported: exitCode === 0 && log.count("error") === 0 && existsSync8(output.absolutePath),
+      exported: exitCode === 0 && log.count("error") === 0 && existsSync9(output.absolutePath),
       preset,
       outputPath: output.relativePath,
       debug,
@@ -30282,7 +30386,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync8(join10(project.value.path, runner))) {
+    if (!existsSync9(join11(project.value.path, runner))) {
       return this.createErrorResponse(`gdUnit4 is not installed in this project: no ${runner}.`, [
         "Install gdUnit4 under addons/gdUnit4, from https://github.com/godot-gdunit-labs/gdUnit4"
       ]);
@@ -30317,7 +30421,7 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync2(join10(tmpdir4(), "gdharness-tests-"));
+    const userData = mkdtempSync2(join11(tmpdir4(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const hung = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -30333,14 +30437,14 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join10(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join11(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync8(reportsDir) ? readdirSync6(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync9(reportsDir) ? readdirSync6(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
       const newest = written.at(-1);
       if (newest !== undefined) {
-        report = parseJUnit(readFileSync10(join10(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync11(join11(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -30503,6 +30607,7 @@ class GodotServer {
       retryingBridge: this.bridgeRetry === null ? undefined : true,
       announcedAt: this.announcedAt ?? undefined,
       projectIs: this.projectHasMovedOn() ?? undefined,
+      configIs: this.configDisagreement() ?? undefined,
       note: isPortConflict ? "Bridge port is already in use. Another gdharness instance owns the editor bridge, so this server cannot reach the editor. Usually the server this one replaced, still on its way out." : undefined,
       suggestion: isPortConflict ? `This server is asking for the port again every ${BRIDGE_RETRY_MS / 1000}s and takes it the moment the other one lets go, so editor tools come back on their own. Ask again, or end the older gdharness process to have it now.` : undefined
     };
@@ -30758,7 +30863,7 @@ class GodotServer {
     return runIsUp(run, editorSays);
   }
   async runtimeUp(projectPath, before, budgetMs) {
-    if (!existsSync8(join10(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync9(join11(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false });
     }
     const endpoint = await announcedSince(projectPath, before, {
@@ -31013,7 +31118,7 @@ class GodotServer {
     if (mine === null) {
       return false;
     }
-    return project !== "" && samePath(mine, project);
+    return project !== "" && isSameDirectory(mine, project);
   }
   currentRun() {
     return this.activeProcess ?? this.adoptRecordedRun();
@@ -31144,6 +31249,11 @@ class GodotServer {
   async handleRescanFilesystem(args) {
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 30000;
     const started = Date.now();
+    const projectPath = typeof args["projectPath"] === "string" ? args["projectPath"] : "";
+    const before = projectPath === "" ? null : cachedClasses(projectPath);
+    const writtenBefore = projectPath === "" ? null : cacheWrittenAt(projectPath);
+    const blind = projectPath === "" ? { unseen: [] } : await this.classesTheEditorCannotSee(args);
+    const atRisk = before === null ? [] : blind.unseen.filter((one) => before.has(one.className));
     const first = await this.handleViaBridge("rescan_filesystem", args);
     if (first.isError) {
       return first;
@@ -31152,17 +31262,27 @@ class GodotServer {
     while (busy && Date.now() - started < timeoutMs) {
       await new Promise((settle) => setTimeout(settle, 100));
       const status = asParams(await this.godotBridge.invokeTool("rescan_filesystem", { ...args, statusOnly: true }));
-      busy = Boolean(status["scanning"]) || Boolean(status["importing"]);
+      const pending = Boolean(status["pending"]) && Date.now() - started < SCAN_START_MS;
+      busy = Boolean(status["scanning"]) || Boolean(status["importing"]) || pending;
+    }
+    if (!busy && atRisk.length > 0) {
+      const until = Date.now() + CACHE_WRITE_MS;
+      while (Date.now() < until && cacheWrittenAt(projectPath) === writtenBefore) {
+        await new Promise((settle) => setTimeout(settle, 100));
+      }
     }
+    const after = projectPath === "" || busy ? null : cachedClasses(projectPath);
+    const lost = before === null || after === null ? [] : [...before.keys()].filter((name) => !after.has(name));
     const checked = busy ? { unseen: [] } : await this.classesTheEditorCannotSee(args);
     const unseen = checked.unseen;
     return this.jsonTextResponse({
-      ok: !busy && unseen.length === 0 && checked.unchecked === undefined,
+      ok: !busy && unseen.length === 0 && lost.length === 0 && checked.unchecked === undefined,
       stillWorking: busy,
       waitedMs: Date.now() - started,
       unseenByEditor: unseen.length > 0 ? unseen : undefined,
+      cacheLost: lost.length > 0 ? lost : 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
+      note: busy ? "The editor was still scanning or importing when the wait ran out, so new files may not be visible yet." : lost.length > 0 ? "The scan wrote the class cache from the list this editor is holding, and that list is shorter than the file was: these classes were in it before the scan and are not now. Every engine that reads the cache next, including a test run, will report them as unknown identifiers in files nobody touched. Run project_import refresh_classes to put them back, and do not rescan again until the editor has been restarted with editor_launch restart, because it will write the same short list over it." : 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) {
@@ -31187,7 +31307,7 @@ class GodotServer {
       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)) {
+    if (open === undefined || !isSameDirectory(open, projectPath)) {
       return {
         unseen: [],
         unchecked: `the connected editor is open on ${open ?? "a project it did not name"}, not this one`
@@ -31215,6 +31335,14 @@ class GodotServer {
         "editor_status says whether the bridge is up and what it is listening on"
       ]);
     }
+    const open = this.godotBridge.getStatus().projectPath;
+    const meant = readNonEmptyString(args, "projectPath");
+    if (open !== undefined && open !== "" && meant !== undefined && !isSameDirectory(open, meant)) {
+      return this.createErrorResponse(`This call names ${meant}, and the editor on this bridge has ${open} open.`, [
+        "editor_status names the project this server's editor is showing",
+        "One server serves one editor: start a second server for the other project"
+      ]);
+    }
     try {
       return this.jsonTextResponse(markIfStale(await this.godotBridge.invokeTool(toolName, args), this.godotBridge.getStatus().addonVersion, SERVER_VERSION));
     } catch (error) {
@@ -31233,8 +31361,8 @@ class GodotServer {
       return this.createErrorResponse(choice.problem);
     }
     const expectsScreenshot = command === "capture_screenshot" || command === "capture_viewport";
-    const screenshotDir = expectsScreenshot ? mkdtempSync2(join10(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join10(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? mkdtempSync2(join11(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
+    const screenshotPath = screenshotDir ? join11(screenshotDir, "capture.png") : null;
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs);
       if (!reply.ok) {
@@ -31255,7 +31383,7 @@ class GodotServer {
       return {
         content: [
           { type: "text", text: `Screenshot captured: ${dimensions}` },
-          { type: "image", data: readFileSync10(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync11(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {