gdharness 1.0.6 → 1.0.8

package/build/index.js

@@ -10175,16 +10175,16 @@ import {
   closeSync,
   existsSync as existsSync9,
   fstatSync,
-  mkdirSync as mkdirSync8,
+  mkdirSync as mkdirSync9,
   mkdtempSync as mkdtempSync2,
   openSync as openSync2,
   readdirSync as readdirSync6,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync15,
   readSync,
   statSync as statSync5
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename3, dirname as dirname8, join as join14, normalize as normalize2, relative as relative3 } from "node:path";
+import { basename as basename3, dirname as dirname9, join as join15, normalize as normalize2, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { promisify as promisify5 } from "node:util";
@@ -25814,18 +25814,49 @@ function unseenByEditor(projectPath, editorHolds) {
   return [...declaredClasses(projectPath)].filter(([name]) => !held.has(name)).map(([className, path]) => ({ className, path })).sort((one, other) => one.className < other.className ? -1 : one.className > other.className ? 1 : 0);
 }
 
+// src/class-note.ts
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname5, join as join7 } from "node:path";
+function classNotePath(projectPath) {
+  return join7(projectPath, ".godot", "gdharness-classes.json");
+}
+function readClassNote(projectPath) {
+  try {
+    const fields = asParams(JSON.parse(readFileSync8(classNotePath(projectPath), "utf8")));
+    const rebuiltWith = readArray(fields, "rebuiltWith");
+    if (rebuiltWith === undefined || !rebuiltWith.every((name) => typeof name === "string")) {
+      return null;
+    }
+    const pid = readNumber(fields, "shortListEditorPid");
+    return {
+      rebuiltWith: rebuiltWith.map(String),
+      ...Object.hasOwn(fields, "shortListEditorPid") ? { shortListEditorPid: pid ?? null } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function writeClassNote(projectPath, note) {
+  try {
+    const path = classNotePath(projectPath);
+    mkdirSync5(dirname5(path), { recursive: true });
+    writeFileSync5(path, `${JSON.stringify(note, null, 2)}
+`, "utf8");
+  } catch {}
+}
+
 // src/config-pin.ts
-import { existsSync as existsSync4, readFileSync as readFileSync8 } from "node:fs";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync9 } from "node:fs";
+import { join as join8 } from "node:path";
 var PINNED = /\bgdharness@(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\b/g;
 function versionsNamedInConfig(projectPath) {
-  const config = join7(projectPath, ".mcp.json");
+  const config = join8(projectPath, ".mcp.json");
   if (!existsSync4(config)) {
     return [];
   }
   let text;
   try {
-    text = readFileSync8(config, "utf8");
+    text = readFileSync9(config, "utf8");
     JSON.parse(text);
   } catch {
     return [];
@@ -27192,7 +27223,7 @@ import { promisify as promisify2 } from "node:util";
 // src/detection.ts
 import { existsSync as existsSync5, readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 function resolveHomeDirectory() {
   try {
     return homedir2();
@@ -27216,7 +27247,7 @@ function scanDirectoryForGodotBinaries(directory, platform) {
     if (!pattern.test(name)) {
       continue;
     }
-    const fullPath = join8(directory, name);
+    const fullPath = join9(directory, name);
     try {
       const stat = statSync3(fullPath);
       if (stat.isFile()) {
@@ -27225,7 +27256,7 @@ function scanDirectoryForGodotBinaries(directory, platform) {
     } catch {}
   }
   matches.sort((a, b) => b.mtime - a.mtime);
-  return matches.map((m) => join8(directory, m.name));
+  return matches.map((m) => join9(directory, m.name));
 }
 function conventionalPaths(platform, home) {
   const paths = ["godot"];
@@ -27345,9 +27376,9 @@ class GodotLocator {
 
 // src/headless.ts
 import { execFile as execFile3 } from "node:child_process";
-import { mkdtempSync, writeFileSync as writeFileSync5 } from "node:fs";
+import { mkdtempSync, writeFileSync as writeFileSync6 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 
 // src/scratch.ts
@@ -27413,12 +27444,12 @@ function reason(stdout, stderr) {
   return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
 }
 async function runImport(godotPath, projectPath) {
-  const logDir = mkdtempSync(join9(tmpdir3(), "gdharness-import-"));
+  const logDir = mkdtempSync(join10(tmpdir3(), "gdharness-import-"));
   try {
     const { stderr } = await run3(godotPath, [
       "--headless",
       "--log-file",
-      join9(logDir, "engine.log"),
+      join10(logDir, "engine.log"),
       "--path",
       projectPath,
       "--import"
@@ -27443,13 +27474,13 @@ async function runImport(godotPath, projectPath) {
   }
 }
 async function runOperation(engine, operation, params, projectPath) {
-  const paramsDir = mkdtempSync(join9(tmpdir3(), "gdharness-params-"));
-  const paramsFile = join9(paramsDir, `${operation}.json`);
-  writeFileSync5(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
+  const paramsDir = mkdtempSync(join10(tmpdir3(), "gdharness-params-"));
+  const paramsFile = join10(paramsDir, `${operation}.json`);
+  writeFileSync6(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
     "--log-file",
-    join9(paramsDir, "engine.log"),
+    join10(paramsDir, "engine.log"),
     "--path",
     projectPath,
     "--script",
@@ -27878,7 +27909,7 @@ function orphansPrinted(printed) {
 import { realpathSync as realpathSync2 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname5, resolve as resolve3 } from "node:path";
+import { dirname as dirname6, resolve as resolve3 } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 var DEFAULT_LSP_PORT = 6005;
 var DIAGNOSTICS_TIMEOUT_MS = 5000;
@@ -28008,7 +28039,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname5(resolve3(filePath));
+    const rootPath = this.rootPath ?? dirname6(resolve3(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params) {
@@ -28444,14 +28475,14 @@ function secondsFromClock(printed) {
 }
 
 // src/project-scan.ts
-import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync10 } from "node:fs";
+import { join as join11 } from "node:path";
 var SKIPPED = new Set(["node_modules"]);
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
 function steppedOver(directory) {
-  return existsSync7(join10(directory, ".gdignore"));
+  return existsSync7(join11(directory, ".gdignore"));
 }
 var ASSET_EXTENSIONS = new Set(["png", "jpg", "jpeg", "webp", "svg", "ttf", "otf", "wav", "mp3", "ogg"]);
 function projectStructure(projectPath) {
@@ -28465,7 +28496,7 @@ function projectStructure(projectPath) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join10(directory, entry.name));
+        visit(join11(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (extension === "tscn") {
@@ -28496,14 +28527,14 @@ function scriptsWithoutUid(projectPath) {
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join10(directory, entry.name), spelled);
+        visit(join11(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync7(join10(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync7(join11(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -28538,7 +28569,7 @@ function searchProject(projectPath, options) {
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join10(directory, entry.name);
+      const entryPath = join11(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -28549,7 +28580,7 @@ function searchProject(projectPath, options) {
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync9(entryPath, "utf8").split(`
+      for (const [index, line] of readFileSync10(entryPath, "utf8").split(`
 `).entries()) {
         if (full()) {
           break;
@@ -28572,7 +28603,7 @@ function searchProject(projectPath, options) {
 }
 
 // src/resources.ts
-import { readFileSync as readFileSync10 } from "node:fs";
+import { readFileSync as readFileSync11 } from "node:fs";
 import { extname, resolve as resolve4 } from "node:path";
 var STATIC_RESOURCES = [
   {
@@ -28767,7 +28798,7 @@ function readResourceText(uri, getProjectPath) {
   const parsedUri = parseGodotUri(uri);
   if (parsedUri.kind === "project-info") {
     const projectFilePath = resolveProjectFile(projectPath, "project.godot");
-    const rawProject = readFileSync10(projectFilePath, "utf-8");
+    const rawProject = readFileSync11(projectFilePath, "utf-8");
     const parsedProject = parseProjectGodot(rawProject);
     return {
       mimeType: "application/json",
@@ -28776,7 +28807,7 @@ function readResourceText(uri, getProjectPath) {
   }
   const filePath = resolveProjectFile(projectPath, parsedUri.resourcePath);
   ensureAllowedExtension(parsedUri.kind, filePath);
-  const text = readFileSync10(filePath, "utf-8");
+  const text = readFileSync11(filePath, "utf-8");
   return {
     mimeType: parsedUri.kind === "script" ? "text/x-gdscript" : "text/plain",
     text
@@ -28813,16 +28844,16 @@ function setupResourceHandlers(mcp, getProjectPath) {
 }
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync11, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname6, join as join11 } from "node:path";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync12, rmSync as rmSync4, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname7, join as join12 } from "node:path";
 function restartNotePath(projectPath) {
-  return join11(projectPath, ".godot", "gdharness-restart.json");
+  return join12(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync5(dirname6(path), { recursive: true });
-    writeFileSync6(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync6(dirname7(path), { recursive: true });
+    writeFileSync7(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
@@ -28830,7 +28861,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync11(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync12(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -28853,36 +28884,36 @@ function restartSettled(projectPath) {
 
 // src/run-record.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { mkdirSync as mkdirSync6, openSync, readdirSync as readdirSync5, readFileSync as readFileSync12, rmSync as rmSync5, statSync as statSync4, writeFileSync as writeFileSync7 } from "node:fs";
-import { basename as basename2, join as join12 } from "node:path";
+import { mkdirSync as mkdirSync7, openSync, readdirSync as readdirSync5, readFileSync as readFileSync13, rmSync as rmSync5, statSync as statSync4, writeFileSync as writeFileSync8 } from "node:fs";
+import { basename as basename2, join as join13 } from "node:path";
 function runsDirectory() {
-  return join12(runtimeDirectory(), "runs");
+  return join13(runtimeDirectory(), "runs");
 }
 function recordPath() {
-  return join12(runsDirectory(), "run.json");
+  return join13(runsDirectory(), "run.json");
 }
 function recordPaths() {
-  return runtimeDirectories().map((directory) => join12(directory, "runs", "run.json"));
+  return runtimeDirectories().map((directory) => join13(directory, "runs", "run.json"));
 }
 function openTranscript(startedAt) {
-  mkdirSync6(runsDirectory(), { recursive: true });
-  const path = join12(runsDirectory(), `run-${startedAt}.log`);
+  mkdirSync7(runsDirectory(), { recursive: true });
+  const path = join13(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync(path, "a") };
 }
 function writeRunRecord(record) {
-  mkdirSync6(runsDirectory(), { recursive: true });
-  writeFileSync7(recordPath(), JSON.stringify(record, null, 2), "utf8");
+  mkdirSync7(runsDirectory(), { recursive: true });
+  writeFileSync8(recordPath(), JSON.stringify(record, null, 2), "utf8");
 }
 function editorNotePath() {
-  return join12(runsDirectory(), "editor-run.json");
+  return join13(runsDirectory(), "editor-run.json");
 }
 function writeEditorRunNote(note) {
-  mkdirSync6(runsDirectory(), { recursive: true });
-  writeFileSync7(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
+  mkdirSync7(runsDirectory(), { recursive: true });
+  writeFileSync8(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
 }
 function readEditorRunNote() {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(join12(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(join13(directory, "runs", "editor-run.json"));
     if (note !== null) {
       return note;
     }
@@ -28892,7 +28923,7 @@ function readEditorRunNote() {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync12(path, "utf8"));
+    parsed = JSON.parse(readFileSync13(path, "utf8"));
   } catch {
     return null;
   }
@@ -28915,7 +28946,7 @@ function recordRunEnded(pid, exitCode) {
     return;
   }
   try {
-    writeFileSync7(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
+    writeFileSync8(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
   } catch {}
 }
 function readRunRecord() {
@@ -28930,7 +28961,7 @@ function readRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync12(path, "utf8"));
+    parsed = JSON.parse(readFileSync13(path, "utf8"));
   } catch {
     return null;
   }
@@ -28975,7 +29006,7 @@ function runningAs(pid) {
     const began = startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync12(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync13(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = execFileSync2("ps", ["-p", String(pid), "-o", "args="], {
@@ -29128,7 +29159,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join12(directory, entry);
+    const path = join13(directory, entry);
     if (path === keep || ageMs(path, now) < keepMs) {
       continue;
     }
@@ -29139,8 +29170,8 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
 }
 
 // src/setup.ts
-import { cpSync, existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync13, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname7, join as join13 } from "node:path";
+import { cpSync, existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync14, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname8, join as join14 } from "node:path";
 var ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
 var RUNTIME_AUTOLOAD = {
   name: "GdharnessRuntime",
@@ -29148,11 +29179,11 @@ var RUNTIME_AUTOLOAD = {
 };
 var VERSION_MARKER = ".gdharness-version";
 function installedAddonVersion(projectPath) {
-  const marker = join13(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  const marker = join14(projectPath, "addons", ADDONS[0], VERSION_MARKER);
   if (!existsSync8(marker)) {
     return null;
   }
-  const said = readFileSync13(marker, "utf8").trim();
+  const said = readFileSync14(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 
@@ -29468,7 +29499,7 @@ var TOOL_SPECS = [
         requires: []
       },
       refresh_classes: {
-        summary: 'rewrite .godot/global_script_class_cache.cfg from the class_name declarations on disk, and name under unseenByEditor any class the editor open on this project still cannot resolve: rewriting the file does not reach the list a running editor loaded, so "added: []" means the file was already right rather than that nothing is wrong',
+        summary: 'rewrite .godot/global_script_class_cache.cfg from the class_name declarations on disk, and name under unseenByEditor any class the editor open on this project still cannot resolve: rewriting the file does not reach the list a running editor loaded, so "added: []" means the file was already right rather than that nothing is wrong. A class the cache held after the last rebuild and had lost when this one began is named under lostSinceLastRebuild: the editor wrote the file without it in between, on a save or a scan, and will again until restarted',
         requires: []
       }
     }
@@ -29493,7 +29524,7 @@ var TOOL_SPECS = [
   },
   {
     name: "project_test",
-    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. Needs gdUnit4 under addons/gdUnit4.",
+    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. Needs gdUnit4 under addons/gdUnit4.",
     parameters: {
       projectPath: PROJECT_PATH,
       path: {
@@ -29710,7 +29741,7 @@ var TOOL_SPECS = [
   },
   {
     name: "script_diagnostics",
-    description: "Errors and warnings for a script from the editor's language server, and whether the script is clean. Needs the editor running. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares comes back under contradictedByTheFile, and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
+    description: "Errors and warnings for a script from the editor's language server, and whether the script is clean. Needs the editor running. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares comes back under contradictedByTheFile, and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. The one exception is named when it applies: an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
     parameters: {
       projectPath: PROJECT_PATH,
       scriptPath: SCRIPT_PATH
@@ -30309,7 +30340,7 @@ function buildToolDefinitions() {
 var UPDATE_NOTICE_EVERY = 500;
 var FEEDBACK_NOTICE_EVERY = 250;
 var run5 = promisify5(execFile5);
-var __dirname2 = dirname8(fileURLToPath2(import.meta.url));
+var __dirname2 = dirname9(fileURLToPath2(import.meta.url));
 var EDITOR_RESTART_TIMEOUT_MS = 90000;
 var HOLD_PING_MS = 2000;
 var SLOWEST_FRAME_RATE = 20;
@@ -30596,7 +30627,7 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync9(join14(projectPath, wanted))) {
+  if (wanted === "" || existsSync9(join15(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -30610,7 +30641,7 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync14(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync15(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function runtimeAddonAnnouncesEditors(projectPath) {
@@ -30618,13 +30649,13 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync14(join14(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
+    return readFileSync15(join15(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync14(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync15(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -30640,7 +30671,7 @@ function camelCased(params) {
 class GodotServer {
   mcp;
   locator = new GodotLocator;
-  operationsScript = join14(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join15(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -31071,8 +31102,15 @@ class GodotServer {
         const contained = this.containProjectFiles(asks);
         return contained.ok ? await this.handleViaBridge(editorSide, contained.value) : contained.response;
       }
-      const answered = await this.headless(headless, answerable);
-      return headless === "refresh_class_cache" && this.godotBridge.isConnected() ? await this.alsoSayWhatTheEditorCannotSee(answered, args) : answered;
+      if (headless !== "refresh_class_cache") {
+        return await this.headless(headless, answerable);
+      }
+      const project = this.project(answerable);
+      if (!project.ok) {
+        return project.response;
+      }
+      const answered = this.answer(await this.rebuildClassCache(project.value.path));
+      return this.godotBridge.isConnected() ? await this.alsoSayWhatTheEditorCannotSee(answered, args) : answered;
     }
     const { op: _op, ...arguments_ } = args;
     const bridge = async (command, extra = {}) => {
@@ -31298,7 +31336,7 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join14(path, "project.godot");
+    const file = join15(path, "project.godot");
     if (!existsSync9(file)) {
       return {
         ok: false,
@@ -31522,7 +31560,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync14(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync15(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -31583,18 +31621,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname8(output.absolutePath);
+    const folder = dirname9(output.absolutePath);
     try {
-      mkdirSync8(folder, { recursive: true });
+      mkdirSync9(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname8(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname9(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
-    const exportLogs = mkdtempSync2(join14(tmpdir4(), "gdharness-export-"));
+    const exportLogs = mkdtempSync2(join15(tmpdir4(), "gdharness-export-"));
     const exportArgs = [
       "--headless",
       "--log-file",
-      join14(exportLogs, "engine.log"),
+      join15(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -31652,7 +31690,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync9(join14(project.value.path, runner))) {
+    if (!existsSync9(join15(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"
       ]);
@@ -31661,7 +31699,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const classes = await this.operation("refresh_class_cache", {}, project.value.path);
+    const classes = await this.rebuildClassCache(project.value.path);
     if (!classes.ok) {
       return this.answer(classes);
     }
@@ -31687,7 +31725,7 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync2(join14(tmpdir4(), "gdharness-tests-"));
+    const userData = mkdtempSync2(join15(tmpdir4(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const hung = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -31703,14 +31741,14 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join14(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join15(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
       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(readFileSync14(join14(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync15(join15(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -31850,7 +31888,7 @@ class GodotServer {
         return null;
       }
       try {
-        return readFileSync14(contained.absolutePath, "utf8");
+        return readFileSync15(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -31878,7 +31916,8 @@ class GodotServer {
     }
     const stale = unloaded.filter((type) => type.inTheClassCache);
     if (stale.length > 0) {
-      notes.push(`${stale.map((type) => type.type).join(", ")} ${stale.length === 1 ? "is" : "are"} in the class cache and still unresolved here, which is the editor's loaded list being behind rather than anything on disk. A game launched now reads the cache and resolves ${stale.length === 1 ? "it" : "them"}, so the run and the diagnostics disagree. editor_rescan clears it, measured against a real editor with waiting the same length ruled out; editor_launch restart also does, and costs more.`);
+      const remedy = this.editorWritesAShortList(projectPath) ? "editor_rescan will not clear it here: this editor wrote the class cache from a list shorter than the file on its last scan and writes the same list on every scan, so editor_launch restart is what loads it." : "editor_rescan clears it, measured against a real editor with waiting the same length ruled out; editor_launch restart also does, and costs more.";
+      notes.push(`${stale.map((type) => type.type).join(", ")} ${stale.length === 1 ? "is" : "are"} in the class cache and still unresolved here, which is the editor's loaded list being behind rather than anything on disk. A game launched now reads the cache and resolves ${stale.length === 1 ? "it" : "them"}, so the run and the diagnostics disagree. ${remedy}`);
     }
     return {
       ...contradicted.length === 0 ? {} : { contradictedByTheFile: contradicted },
@@ -31886,13 +31925,24 @@ class GodotServer {
       ...notes.length === 0 ? {} : { staleAnalysis: notes.join(" ") }
     };
   }
+  editorWritesAShortList(projectPath) {
+    const recorded = readClassNote(projectPath)?.shortListEditorPid;
+    return recorded !== undefined && recorded === (this.godotBridge.getStatus().editorPid ?? null);
+  }
+  noteAShortListEditor(projectPath) {
+    const note = readClassNote(projectPath);
+    writeClassNote(projectPath, {
+      rebuiltWith: note?.rebuiltWith ?? [],
+      shortListEditorPid: this.godotBridge.getStatus().editorPid ?? null
+    });
+  }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
     if (!contained.ok || !existsSync9(contained.absolutePath)) {
       return null;
     }
     try {
-      return readFileSync14(contained.absolutePath, "utf8");
+      return readFileSync15(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -32121,7 +32171,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync14(join14(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync15(join15(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -32363,7 +32413,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync9(join14(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync9(join15(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
     }
     let asking = null;
@@ -33235,6 +33285,9 @@ class GodotServer {
     }
     const after = projectPath === "" || busy ? null : cachedClasses(projectPath);
     const lost = before === null || after === null ? [] : [...before.keys()].filter((name) => !after.has(name));
+    if (lost.length > 0) {
+      this.noteAShortListEditor(projectPath);
+    }
     const atMissingPaths = after === null ? [] : cachedAtMissingPaths(after, projectPath);
     const restored = lost.length > 0 || atMissingPaths.length > 0 ? await this.rebuildCacheAfterLoss(projectPath, lost) : [];
     const rebuilt = atMissingPaths.length > 0 ? cachedClasses(projectPath) : null;
@@ -33290,7 +33343,7 @@ class GodotServer {
     if (projectPath === "") {
       return [];
     }
-    const rebuilt = await this.operation("refresh_class_cache", {}, projectPath);
+    const rebuilt = await this.rebuildClassCache(projectPath);
     if (!rebuilt.ok) {
       this.logDebug(`Could not rebuild the class cache after a scan: ${rebuilt.message}`);
       return [];
@@ -33298,6 +33351,36 @@ class GodotServer {
     const now = cachedClasses(projectPath);
     return now === null ? [] : lost.filter((name) => now.has(name));
   }
+  async rebuildClassCache(projectPath) {
+    const before = cachedClasses(projectPath);
+    const noted = readClassNote(projectPath);
+    const rebuilt = await this.operation("refresh_class_cache", {}, projectPath);
+    if (!rebuilt.ok) {
+      return rebuilt;
+    }
+    const after = cachedClasses(projectPath);
+    if (after === null) {
+      return rebuilt;
+    }
+    const lost = noted === null || before === null ? [] : noted.rebuiltWith.filter((name) => !before.has(name) && after.has(name)).sort();
+    const seenLosing = lost.length > 0 && this.godotBridge.isConnected();
+    writeClassNote(projectPath, {
+      rebuiltWith: [...after.keys()].sort(),
+      ...seenLosing ? { shortListEditorPid: this.godotBridge.getStatus().editorPid ?? null } : noted?.shortListEditorPid === undefined ? {} : { shortListEditorPid: noted.shortListEditorPid }
+    });
+    if (!seenLosing) {
+      return rebuilt;
+    }
+    const them = lost.length === 1 ? "it" : "them";
+    return {
+      ...rebuilt,
+      payload: {
+        ...rebuilt.payload,
+        lostSinceLastRebuild: lost,
+        note: `The cache held ${lost.join(", ")} after the last rebuild and not when this one began, so the editor holding this project wrote it without ${them} in between: it holds a list shorter than the files and writes that list on every save and scan, and each rebuild puts ${them} back. editor_launch restart is what ends it.`
+      }
+    };
+  }
   async alsoSayWhatTheEditorCannotSee(answered, args) {
     const first = answered.content[0];
     if (answered.isError || first?.type !== "text" || typeof first.text !== "string") {
@@ -33308,15 +33391,18 @@ class GodotServer {
     if (checked.unseen.length === 0 && stillHeld.length === 0 && checked.unchecked === undefined) {
       return answered;
     }
-    const notes = [];
+    const payload = asParams(JSON.parse(first.text));
+    const said = readString(payload, "note");
+    const notes = said === undefined ? [] : [said];
     if (checked.unseen.length > 0) {
-      notes.push("The cache on disk is right now, and the editor holding this project is still not resolving these: rewriting the file does not reach the list it already loaded. editor_rescan does, on its own and with no change to the declaring script; editor_launch restart also does, and costs more.");
+      const projectPath = typeof args["projectPath"] === "string" ? args["projectPath"] : "";
+      notes.push(projectPath !== "" && this.editorWritesAShortList(projectPath) ? "The cache on disk is right now, and the editor holding this project is still not resolving these: rewriting the file does not reach the list it already loaded. editor_rescan will not reach it either on this editor, whose last scan wrote the cache from a list shorter than the file and would again; editor_launch restart is what loads them." : "The cache on disk is right now, and the editor holding this project is still not resolving these: rewriting the file does not reach the list it already loaded. editor_rescan does, on its own and with no change to the declaring script; editor_launch restart also does, and costs more.");
     }
     if (stillHeld.length > 0) {
       notes.push(`The editor is still holding ${stillHeld.join(", ")}, which this project no longer declares, and it will write that list back over the cache this call just corrected. The entry returns pointing at a script that is gone, and the next engine to walk get_global_class_list() dies on "File not found". A rescan does not clear this one: it picks up a class that has appeared and does not drop one that has gone. editor_launch restart does.`);
     }
     return this.jsonTextResponse({
-      ...asParams(JSON.parse(first.text)),
+      ...payload,
       unseenByEditor: checked.unseen.length > 0 ? checked.unseen : undefined,
       stillHeldByEditor: stillHeld.length > 0 ? stillHeld : undefined,
       classesUnchecked: checked.unchecked,
@@ -33441,8 +33527,8 @@ class GodotServer {
       ]);
     }
     const expectsScreenshot = command === "capture_screenshot" || command === "capture_viewport";
-    const screenshotDir = expectsScreenshot ? mkdtempSync2(join14(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join14(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? mkdtempSync2(join15(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
+    const screenshotPath = screenshotDir ? join15(screenshotDir, "capture.png") : null;
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs);
       if (!reply.ok) {
@@ -33466,7 +33552,7 @@ class GodotServer {
             type: "text",
             text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}`
           },
-          { type: "image", data: readFileSync14(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync15(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {