gdharness 1.0.6 → 1.0.8

package/build/cli.js

@@ -15694,7 +15694,7 @@ var init_tool_definitions = __esm(() => {
           requires: []
         },
         refresh_classes: {
-          summary: 'rewrite .godot/global_script_class_cache.cfg from the class_name declarations on disk, and name under unseenByEditor any class the editor open on this project still cannot resolve: rewriting the file does not reach the list a running editor loaded, so "added: []" means the file was already right rather than that nothing is wrong',
+          summary: 'rewrite .godot/global_script_class_cache.cfg from the class_name declarations on disk, and name under unseenByEditor any class the editor open on this project still cannot resolve: rewriting the file does not reach the list a running editor loaded, so "added: []" means the file was already right rather than that nothing is wrong. A class the cache held after the last rebuild and had lost when this one began is named under lostSinceLastRebuild: the editor wrote the file without it in between, on a save or a scan, and will again until restarted',
           requires: []
         }
       }
@@ -15719,7 +15719,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "project_test",
-      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. Needs gdUnit4 under addons/gdUnit4.",
+      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. Needs gdUnit4 under addons/gdUnit4.",
       parameters: {
         projectPath: PROJECT_PATH,
         path: {
@@ -15936,7 +15936,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "script_diagnostics",
-      description: "Errors and warnings for a script from the editor's language server, and whether the script is clean. Needs the editor running. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares comes back under contradictedByTheFile, and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
+      description: "Errors and warnings for a script from the editor's language server, and whether the script is clean. Needs the editor running. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares comes back under contradictedByTheFile, and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. The one exception is named when it applies: an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
       parameters: {
         projectPath: PROJECT_PATH,
         scriptPath: SCRIPT_PATH
@@ -31993,17 +31993,49 @@ var init_bridge_announce = __esm(() => {
   init_errors();
 });
 
+// src/class-note.ts
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname11, join as join16 } from "node:path";
+function classNotePath(projectPath) {
+  return join16(projectPath, ".godot", "gdharness-classes.json");
+}
+function readClassNote(projectPath) {
+  try {
+    const fields = asParams(JSON.parse(readFileSync14(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);
+    mkdirSync9(dirname11(path), { recursive: true });
+    writeFileSync11(path, `${JSON.stringify(note, null, 2)}
+`, "utf8");
+  } catch {}
+}
+var init_class_note = () => {};
+
 // src/config-pin.ts
-import { existsSync as existsSync11, readFileSync as readFileSync14 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync15 } from "node:fs";
+import { join as join17 } from "node:path";
 function versionsNamedInConfig(projectPath) {
-  const config = join16(projectPath, ".mcp.json");
+  const config = join17(projectPath, ".mcp.json");
   if (!existsSync11(config)) {
     return [];
   }
   let text;
   try {
-    text = readFileSync14(config, "utf8");
+    text = readFileSync15(config, "utf8");
     JSON.parse(text);
   } catch {
     return [];
@@ -36564,7 +36596,7 @@ var init_junit = __esm(() => {
 import { realpathSync as realpathSync2 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname11, resolve as resolve4 } from "node:path";
+import { dirname as dirname12, resolve as resolve4 } from "node:path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function diagnosticsKey(uri) {
   let decoded;
@@ -36692,7 +36724,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname11(resolve4(filePath));
+    const rootPath = this.rootPath ?? dirname12(resolve4(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params) {
@@ -37137,13 +37169,13 @@ var init_process_time = __esm(() => {
 });
 
 // src/project-scan.ts
-import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync15 } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync16 } from "node:fs";
+import { join as join18 } from "node:path";
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
 function steppedOver(directory) {
-  return existsSync13(join17(directory, ".gdignore"));
+  return existsSync13(join18(directory, ".gdignore"));
 }
 function projectStructure(projectPath) {
   const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
@@ -37156,7 +37188,7 @@ function projectStructure(projectPath) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join17(directory, entry.name));
+        visit(join18(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (extension === "tscn") {
@@ -37186,14 +37218,14 @@ function scriptsWithoutUid(projectPath) {
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join17(directory, entry.name), spelled);
+        visit(join18(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync13(join17(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync13(join18(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -37228,7 +37260,7 @@ function searchProject(projectPath, options) {
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join17(directory, entry.name);
+      const entryPath = join18(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -37239,7 +37271,7 @@ function searchProject(projectPath, options) {
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync15(entryPath, "utf8").split(`
+      for (const [index, line] of readFileSync16(entryPath, "utf8").split(`
 `).entries()) {
         if (full()) {
           break;
@@ -37268,16 +37300,16 @@ var init_project_scan = __esm(() => {
 });
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync16, rmSync as rmSync8, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname12, join as join18 } from "node:path";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync17, rmSync as rmSync8, writeFileSync as writeFileSync12 } from "node:fs";
+import { dirname as dirname13, join as join19 } from "node:path";
 function restartNotePath(projectPath) {
-  return join18(projectPath, ".godot", "gdharness-restart.json");
+  return join19(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync9(dirname12(path), { recursive: true });
-    writeFileSync11(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync10(dirname13(path), { recursive: true });
+    writeFileSync12(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
@@ -37285,7 +37317,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync16(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync17(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -37311,36 +37343,36 @@ var init_restart_note = __esm(() => {
 
 // src/run-record.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { mkdirSync as mkdirSync10, openSync, readdirSync as readdirSync6, readFileSync as readFileSync17, rmSync as rmSync9, statSync as statSync4, writeFileSync as writeFileSync12 } from "node:fs";
-import { basename as basename3, join as join19 } from "node:path";
+import { mkdirSync as mkdirSync11, openSync, readdirSync as readdirSync6, readFileSync as readFileSync18, rmSync as rmSync9, statSync as statSync4, writeFileSync as writeFileSync13 } from "node:fs";
+import { basename as basename3, join as join20 } from "node:path";
 function runsDirectory() {
-  return join19(runtimeDirectory(), "runs");
+  return join20(runtimeDirectory(), "runs");
 }
 function recordPath() {
-  return join19(runsDirectory(), "run.json");
+  return join20(runsDirectory(), "run.json");
 }
 function recordPaths() {
-  return runtimeDirectories().map((directory) => join19(directory, "runs", "run.json"));
+  return runtimeDirectories().map((directory) => join20(directory, "runs", "run.json"));
 }
 function openTranscript(startedAt) {
-  mkdirSync10(runsDirectory(), { recursive: true });
-  const path = join19(runsDirectory(), `run-${startedAt}.log`);
+  mkdirSync11(runsDirectory(), { recursive: true });
+  const path = join20(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync(path, "a") };
 }
 function writeRunRecord(record) {
-  mkdirSync10(runsDirectory(), { recursive: true });
-  writeFileSync12(recordPath(), JSON.stringify(record, null, 2), "utf8");
+  mkdirSync11(runsDirectory(), { recursive: true });
+  writeFileSync13(recordPath(), JSON.stringify(record, null, 2), "utf8");
 }
 function editorNotePath() {
-  return join19(runsDirectory(), "editor-run.json");
+  return join20(runsDirectory(), "editor-run.json");
 }
 function writeEditorRunNote(note) {
-  mkdirSync10(runsDirectory(), { recursive: true });
-  writeFileSync12(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
+  mkdirSync11(runsDirectory(), { recursive: true });
+  writeFileSync13(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
 }
 function readEditorRunNote() {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(join19(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(join20(directory, "runs", "editor-run.json"));
     if (note !== null) {
       return note;
     }
@@ -37350,7 +37382,7 @@ function readEditorRunNote() {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync17(path, "utf8"));
+    parsed = JSON.parse(readFileSync18(path, "utf8"));
   } catch {
     return null;
   }
@@ -37373,7 +37405,7 @@ function recordRunEnded(pid, exitCode) {
     return;
   }
   try {
-    writeFileSync12(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
+    writeFileSync13(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
   } catch {}
 }
 function readRunRecord() {
@@ -37388,7 +37420,7 @@ function readRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync17(path, "utf8"));
+    parsed = JSON.parse(readFileSync18(path, "utf8"));
   } catch {
     return null;
   }
@@ -37433,7 +37465,7 @@ function runningAs(pid) {
     const began = startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync17(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync18(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = execFileSync2("ps", ["-p", String(pid), "-o", "args="], {
@@ -37584,7 +37616,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join19(directory, entry);
+    const path = join20(directory, entry);
     if (path === keep || ageMs(path, now) < keepMs) {
       continue;
     }
@@ -37607,16 +37639,16 @@ import {
   closeSync,
   existsSync as existsSync14,
   fstatSync,
-  mkdirSync as mkdirSync11,
+  mkdirSync as mkdirSync12,
   mkdtempSync as mkdtempSync3,
   openSync as openSync2,
   readdirSync as readdirSync7,
-  readFileSync as readFileSync18,
+  readFileSync as readFileSync19,
   readSync,
   statSync as statSync5
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename4, dirname as dirname13, join as join20, normalize as normalize3, relative as relative3 } from "node:path";
+import { basename as basename4, dirname as dirname14, join as join21, normalize as normalize3, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { promisify as promisify7 } from "node:util";
@@ -37858,7 +37890,7 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync14(join20(projectPath, wanted))) {
+  if (wanted === "" || existsSync14(join21(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -37872,7 +37904,7 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync18(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync19(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function runtimeAddonAnnouncesEditors(projectPath) {
@@ -37880,13 +37912,13 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync18(join20(projectPath, RUNTIME_AUTOLOAD2.path), "utf8").includes('"editor_pid"');
+    return readFileSync19(join21(projectPath, RUNTIME_AUTOLOAD2.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync18(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync19(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -37902,7 +37934,7 @@ function camelCased(params) {
 class GodotServer {
   mcp;
   locator = new GodotLocator2;
-  operationsScript = join20(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join21(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -38333,8 +38365,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 = {}) => {
@@ -38560,7 +38599,7 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join20(path, "project.godot");
+    const file = join21(path, "project.godot");
     if (!existsSync14(file)) {
       return {
         ok: false,
@@ -38784,7 +38823,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync18(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync19(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -38845,18 +38884,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname13(output.absolutePath);
+    const folder = dirname14(output.absolutePath);
     try {
-      mkdirSync11(folder, { recursive: true });
+      mkdirSync12(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname13(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname14(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
-    const exportLogs = mkdtempSync3(join20(tmpdir5(), "gdharness-export-"));
+    const exportLogs = mkdtempSync3(join21(tmpdir5(), "gdharness-export-"));
     const exportArgs = [
       "--headless",
       "--log-file",
-      join20(exportLogs, "engine.log"),
+      join21(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -38914,7 +38953,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync14(join20(project.value.path, runner))) {
+    if (!existsSync14(join21(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"
       ]);
@@ -38923,7 +38962,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);
     }
@@ -38949,7 +38988,7 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync3(join20(tmpdir5(), "gdharness-tests-"));
+    const userData = mkdtempSync3(join21(tmpdir5(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const hung = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -38965,14 +39004,14 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join20(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join21(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
       const written = existsSync14(reportsDir) ? readdirSync7(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(readFileSync18(join20(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync19(join21(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -39112,7 +39151,7 @@ class GodotServer {
         return null;
       }
       try {
-        return readFileSync18(contained.absolutePath, "utf8");
+        return readFileSync19(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -39140,7 +39179,8 @@ class GodotServer {
     }
     const stale = unloaded.filter((type) => type.inTheClassCache);
     if (stale.length > 0) {
-      notes.push(`${stale.map((type) => type.type).join(", ")} ${stale.length === 1 ? "is" : "are"} in the class cache and still unresolved here, which is the editor's loaded list being behind rather than anything on disk. A game launched now reads the cache and resolves ${stale.length === 1 ? "it" : "them"}, so the run and the diagnostics disagree. editor_rescan clears it, measured against a real editor with waiting the same length ruled out; editor_launch restart also does, and costs more.`);
+      const remedy = this.editorWritesAShortList(projectPath) ? "editor_rescan will not clear it here: this editor wrote the class cache from a list shorter than the file on its last scan and writes the same list on every scan, so editor_launch restart is what loads it." : "editor_rescan clears it, measured against a real editor with waiting the same length ruled out; editor_launch restart also does, and costs more.";
+      notes.push(`${stale.map((type) => type.type).join(", ")} ${stale.length === 1 ? "is" : "are"} in the class cache and still unresolved here, which is the editor's loaded list being behind rather than anything on disk. A game launched now reads the cache and resolves ${stale.length === 1 ? "it" : "them"}, so the run and the diagnostics disagree. ${remedy}`);
     }
     return {
       ...contradicted.length === 0 ? {} : { contradictedByTheFile: contradicted },
@@ -39148,13 +39188,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 || !existsSync14(contained.absolutePath)) {
       return null;
     }
     try {
-      return readFileSync18(contained.absolutePath, "utf8");
+      return readFileSync19(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -39383,7 +39434,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync18(join20(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync19(join21(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -39625,7 +39676,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync14(join20(projectPath, RUNTIME_AUTOLOAD2.path))) {
+    if (!existsSync14(join21(projectPath, RUNTIME_AUTOLOAD2.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
     }
     let asking = null;
@@ -40497,6 +40548,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;
@@ -40552,7 +40606,7 @@ class GodotServer {
     if (projectPath === "") {
       return [];
     }
-    const rebuilt = await this.operation("refresh_class_cache", {}, projectPath);
+    const rebuilt = await this.rebuildClassCache(projectPath);
     if (!rebuilt.ok) {
       this.logDebug(`Could not rebuild the class cache after a scan: ${rebuilt.message}`);
       return [];
@@ -40560,6 +40614,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") {
@@ -40570,15 +40654,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,
@@ -40703,8 +40790,8 @@ class GodotServer {
       ]);
     }
     const expectsScreenshot = command === "capture_screenshot" || command === "capture_viewport";
-    const screenshotDir = expectsScreenshot ? mkdtempSync3(join20(tmpdir5(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join20(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? mkdtempSync3(join21(tmpdir5(), "gdharness-runtime-screenshot-")) : null;
+    const screenshotPath = screenshotDir ? join21(screenshotDir, "capture.png") : null;
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs);
       if (!reply.ok) {
@@ -40728,7 +40815,7 @@ class GodotServer {
             type: "text",
             text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}`
           },
-          { type: "image", data: readFileSync18(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync19(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
@@ -40804,6 +40891,7 @@ var init_server3 = __esm(() => {
   init_breakpoint_note();
   init_bridge_announce();
   init_class_cache();
+  init_class_note();
   init_config_pin();
   init_dap_client();
   init_errors();
@@ -40830,7 +40918,7 @@ var init_server3 = __esm(() => {
   init_tool_definitions();
   init_update_check();
   run7 = promisify7(execFile7);
-  __dirname2 = dirname13(fileURLToPath4(import.meta.url));
+  __dirname2 = dirname14(fileURLToPath4(import.meta.url));
   CONSOLE_WRAPPER = /_console(\.exe)?$/i;
   LONGEST_BOOT_NOTED_MS = 5 * 60000;
   VALUE_NAMES = {
@@ -40871,7 +40959,7 @@ var init_server3 = __esm(() => {
 
 // src/cli.ts
 import { existsSync as existsSync15 } from "fs";
-import { join as join21, resolve as resolve5 } from "path";
+import { join as join22, resolve as resolve5 } from "path";
 
 // src/errors.ts
 class Refusal extends Error {
@@ -42576,7 +42664,7 @@ class UsageError extends Refusal {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve5(named ?? ".");
-  if (!existsSync15(join21(projectPath, "project.godot"))) {
+  if (!existsSync15(join22(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -42615,7 +42703,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync15(join21(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync15(join22(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
     console.log(`  that file is not in this project, so it boots with a missing script: restore it, or point the entry at res://${RUNTIME_AUTOLOAD.path}`);
   }
 }