gdharness 1.1.49 → 1.1.51

package/build/cli.js

@@ -17843,10 +17843,14 @@ 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, a method, property, constant, static function or enum member, 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. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And 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.",
+      description: "Errors and warnings for a script, or for several, from the editor's language server, and whether each 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, a method, property, constant, static function or enum member, 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. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And 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
+        scriptPath: {
+          type: ["string", "array"],
+          items: { type: "string" },
+          description: 'A script inside the project, a folder, or a list of either, such as "scripts/player.gd" or ["scripts/economy", "ui/shop.gd"]. A folder is its .gd files at any depth, skipping what the engine skips. One script is answered as it always was; several are answered together under scripts, each in that same shape, with clean, errors and warnings for all of them beside it, and a script that could not be read is named there with why while the rest are still asked about. At most 300 scripts a call.'
+        }
       },
       requires: ["projectPath", "scriptPath"]
     },
@@ -17893,7 +17897,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_launch",
-      description: "Opens the Godot editor on a project, or restarts the one already connected. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, visible unless hidden: true is passed again, once the old one has gone: it waits 90 seconds for that, or GDHARNESS_EDITOR_RESTART_TIMEOUT_MS, and an old editor still running after it is not replaced, since the new one would find its ports held. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart. An open is refused when the editor it would start could never reach this server: a project other than the one this server serves, whose editor dials that project's own server; a project without the gdharness editor addon installed and enabled; and a project whose editor a restart is already bringing back.",
+      description: "Opens the Godot editor on a project, or restarts the one already connected. open refuses while an editor of the project is already running and has not reached this server, naming its pid, rather than putting a second on the project. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, visible unless hidden: true is passed again, once the old one has gone: it waits 90 seconds for that, or GDHARNESS_EDITOR_RESTART_TIMEOUT_MS, and an old editor still running after it is not replaced, since the new one would find its ports held. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart. An open is refused when the editor it would start could never reach this server: a project other than the one this server serves, whose editor dials that project's own server; a project without the gdharness editor addon installed and enabled; and a project whose editor a restart is already bringing back.",
       parameters: {
         projectPath: { ...PROJECT_PATH, ops: ["open"] },
         hidden: {
@@ -18048,7 +18052,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_status",
-      description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it; null when there is none. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs gdharness upgrade, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. Every runtime_* answer from such a game carries addonIsStale and staleNote too. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs. An engine run that loads the editor addon to do one job and quit, such as a gate's godot --headless --import, an export or a script, is not taken as the editor: a process that greets without a server's mark has its command line read first, and while that is read identifying is true and connected false; one started with such an option is turned away, and turnedAway names the last one, its pid and the option. Every other call made while an editor is arriving, before its greeting or while it is looked up, waits up to ten seconds for it to settle rather than acting on connected as it reads in that window.",
+      description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it; null when there is none. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs gdharness upgrade, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. Every runtime_* answer from such a game carries addonIsStale and staleNote too. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. Any editor of this project running and not yet connected, whoever opened it, makes it true as well and is named under editorsNotYetConnected with its pid and start time, so a restart a reconnect interrupted after its launch is not read as nothing being there. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs. An engine run that loads the editor addon to do one job and quit, such as a gate's godot --headless --import, an export or a script, is not taken as the editor: a process that greets without a server's mark has its command line read first, and while that is read identifying is true and connected false; one started with such an option is turned away, and turnedAway names the last one, its pid and the option. Every other call made while an editor is arriving, before its greeting or while it is looked up, waits up to ten seconds for it to settle rather than acting on connected as it reads in that window.",
       parameters: {},
       requires: []
     },
@@ -39488,7 +39492,7 @@ class GodotLSPClient {
       const diagnosticsPromise = new Promise((resolveDiagnostics, rejectDiagnostics) => {
         const timer = setTimeout(() => {
           this.diagnosticsWaiters.delete(key);
-          rejectDiagnostics(new Error(`Godot published no diagnostics for ${key} within ${DIAGNOSTICS_TIMEOUT_MS}ms. ` + "The language server may not be running, or may not have this file in its workspace."));
+          rejectDiagnostics(new NoDiagnosticsPublished(`Godot published no diagnostics for ${key} within ${DIAGNOSTICS_TIMEOUT_MS}ms. ` + "The language server may not be running, or may not have this file in its workspace."));
         }, DIAGNOSTICS_TIMEOUT_MS);
         this.diagnosticsWaiters.set(key, {
           resolve: resolveDiagnostics,
@@ -39718,11 +39722,12 @@ async function handleLSPTool(client, toolName, args) {
     return asToolResponse({
       error: normalizeLSPError(error, client.port),
       ...error instanceof AnotherProjectsServer ? { serves: error.serves } : {},
-      ...error instanceof ArgumentRefusal ? { refusedArguments: true } : {}
+      ...error instanceof ArgumentRefusal ? { refusedArguments: true } : {},
+      ...error instanceof NoDiagnosticsPublished ? { aboutThisFile: true } : {}
     });
   }
 }
-var DEFAULT_LSP_PORT = 6005, DIAGNOSTICS_TIMEOUT_MS = 5000, REQUEST_TIMEOUT_MS2 = 1e4, REFERENCES_TIMEOUT_MS = 180000, LSPTimeout, ArgumentRefusal, AnotherProjectsServer;
+var DEFAULT_LSP_PORT = 6005, DIAGNOSTICS_TIMEOUT_MS = 5000, REQUEST_TIMEOUT_MS2 = 1e4, REFERENCES_TIMEOUT_MS = 180000, LSPTimeout, ArgumentRefusal, NoDiagnosticsPublished, AnotherProjectsServer;
 var init_lsp_client = __esm(() => {
   init_answer_json();
   init_errors();
@@ -39740,6 +39745,8 @@ var init_lsp_client = __esm(() => {
   };
   ArgumentRefusal = class ArgumentRefusal extends Refusal {
   };
+  NoDiagnosticsPublished = class NoDiagnosticsPublished extends Error {
+  };
   AnotherProjectsServer = class AnotherProjectsServer extends Refusal {
     serves;
     constructor(port, serves, asked) {
@@ -42084,6 +42091,16 @@ function endedPreviousRun(ended) {
 function previousRunLeft(ended) {
   return (ended?.ending === "refused" || ended?.ending === "lingering") && ended.pid !== null ? ended.pid : undefined;
 }
+function editorsOfProjectIn(tree, projectPath) {
+  const found = [];
+  for (const [pid, listed] of tree) {
+    const read = readCommandLine(listed.command);
+    if (read.editor && read.oneShot === null && read.projectPath !== null && /godot/i.test(read.executable) && !CONSOLE_WRAPPER.test(read.executable) && isSameDirectory(read.projectPath, projectPath)) {
+      found.push(pid);
+    }
+  }
+  return found.sort((a, b) => a - b);
+}
 function engineNamesOf(executable) {
   return CONSOLE_WRAPPER.test(executable) ? [executable, executable.replace(CONSOLE_WRAPPER, "$1")] : [executable];
 }
@@ -42568,6 +42585,82 @@ function testPathsIn(projectPath, given) {
     value: unique.filter((path) => !unique.some((other) => other !== path && within(path, other))).map((path) => `res://${path}`)
   };
 }
+function scriptsToDiagnose(projectPath, given) {
+  const listed = Array.isArray(given);
+  if (!listed) {
+    const one = typeof given === "string" ? resolveWithinProject(projectPath, given) : null;
+    if (one === null || !one.ok || !isDirectory(one.absolutePath)) {
+      return { ok: true, value: null };
+    }
+  }
+  const entries = listed ? given : [given];
+  if (entries.length === 0) {
+    return {
+      ok: false,
+      reason: "scriptPath is an empty list: name a script, a folder, or a list of either."
+    };
+  }
+  const found = [];
+  const empty = [];
+  for (const [index, entry] of entries.entries()) {
+    if (typeof entry !== "string" || entry.trim() === "") {
+      return {
+        ok: false,
+        reason: `scriptPath${listed ? `[${index}]` : ""} is ${typeof entry === "string" ? "empty" : describeValue(entry)}, not a script or a folder in the project.`
+      };
+    }
+    const location = resolveWithinProject(projectPath, entry);
+    if (!location.ok) {
+      return { ok: false, reason: location.reason };
+    }
+    const relative = location.relativePath.replace(/\/+$/, "");
+    if (!isDirectory(location.absolutePath)) {
+      found.push(relative);
+      continue;
+    }
+    const inside = scriptsUnder(location.absolutePath, relative);
+    if (inside.length === 0) {
+      empty.push(entry);
+    }
+    found.push(...inside);
+  }
+  const unique = [...new Set(found)];
+  if (unique.length === 0) {
+    return { ok: false, reason: `No .gd script is under ${empty.join(" or ")}.` };
+  }
+  if (unique.length > MOST_DIAGNOSED) {
+    return {
+      ok: false,
+      reason: `scriptPath names ${unique.length} scripts, and one call asks about at most ${MOST_DIAGNOSED}, each a round trip through the language server: name narrower folders, or call again for the rest.`
+    };
+  }
+  return { ok: true, value: unique };
+}
+function isDirectory(path) {
+  try {
+    return statSync9(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function scriptsUnder(directory, prefix) {
+  if (existsSync20(join26(directory, ".gdignore"))) {
+    return [];
+  }
+  const found = [];
+  for (const entry of readdirSync10(directory, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : 1)) {
+    if (entry.name.startsWith(".")) {
+      continue;
+    }
+    const path = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+    if (entry.isDirectory()) {
+      found.push(...scriptsUnder(join26(directory, entry.name), path));
+    } else if (entry.isFile() && entry.name.endsWith(".gd")) {
+      found.push(path);
+    }
+  }
+  return found;
+}
 function hasMainScene(projectFile) {
   const scene = parseProjectGodot(readFileSync22(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
@@ -44396,39 +44489,88 @@ class GodotServer {
     }
   }
   async handleScriptDiagnostics(args) {
+    const project = this.project(args);
+    const scripts = project.ok ? scriptsToDiagnose(project.value.path, args["scriptPath"]) : null;
+    if (scripts !== null && !scripts.ok) {
+      return this.createErrorResponse(scripts.reason);
+    }
+    if (scripts?.value == null) {
+      const one = await this.diagnosticsOf(args);
+      return "refusal" in one ? one.refusal : this.jsonTextResponse(this.markedIfStale(one.answer));
+    }
+    const progress = callProgress();
+    const answers = [];
+    let errors = 0;
+    let warnings = 0;
+    let unread = 0;
+    for (const [at, scriptPath] of scripts.value.entries()) {
+      progress?.(at + 1, `${at + 1} of ${scripts.value.length}: ${scriptPath}`);
+      const one = await this.diagnosticsOf({ ...args, scriptPath });
+      if ("refusal" in one) {
+        if (!one.perScript) {
+          return one.refusal;
+        }
+        unread += 1;
+        answers.push({ scriptPath, error: one.refusal.content[0]?.text ?? "not read" });
+        continue;
+      }
+      errors += Number(one.answer["errors"]);
+      warnings += Number(one.answer["warnings"]);
+      answers.push(one.answer);
+    }
+    return this.jsonTextResponse(this.markedIfStale({
+      clean: errors === 0 && unread === 0,
+      scriptsChecked: answers.length,
+      errors,
+      warnings,
+      ...unread > 0 ? { scriptsNotRead: unread } : {},
+      scripts: answers
+    }));
+  }
+  markedIfStale(answer) {
+    return markIfStale(answer, this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest(), this.editorCodeOnDisk());
+  }
+  async diagnosticsOf(args) {
     const answer = await this.handleLSP("lsp_get_diagnostics", args);
     const payload = asParams(JSON.parse(answer.content[0]?.text ?? "{}"));
     if (payload["error"] !== undefined) {
       const reason = typeof payload["error"] === "string" ? payload["error"] : JSON.stringify(payload["error"]);
       if (payload["refusedArguments"] === true) {
-        return this.createErrorResponse(reason);
+        return { refusal: this.createErrorResponse(reason), perScript: true };
       }
       if (typeof payload["serves"] === "string") {
-        return this.createErrorResponse(`Diagnostics unavailable: ${reason}`, [
-          "editor_status names the editor on the bridge and the port it says it serves",
-          "editor_launch opens this project's own editor, on a language server port of its own",
-          "GDHARNESS_LSP_PORT points this server at the right one"
-        ]);
+        return {
+          refusal: this.createErrorResponse(`Diagnostics unavailable: ${reason}`, [
+            "editor_status names the editor on the bridge and the port it says it serves",
+            "editor_launch opens this project's own editor, on a language server port of its own",
+            "GDHARNESS_LSP_PORT points this server at the right one"
+          ]),
+          perScript: false
+        };
       }
-      return this.createErrorResponse(`Diagnostics unavailable: ${reason}`, [
-        `Ensure the Godot editor is running with its language server enabled, on port ${this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT)}`,
-        "GDHARNESS_LSP_PORT points this server at another one"
-      ]);
+      return {
+        refusal: this.createErrorResponse(`Diagnostics unavailable: ${reason}`, [
+          `Ensure the Godot editor is running with its language server enabled, on port ${this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT)}`,
+          "GDHARNESS_LSP_PORT points this server at another one"
+        ]),
+        perScript: payload["aboutThisFile"] === true
+      };
     }
     const diagnostics = readArray(payload, "diagnostics") ?? [];
     const errors = diagnostics.filter((entry) => {
       const severity = asParams(entry)["severity"];
       return severity === 1 || severity === "error" || severity === "ERROR";
     }).length;
-    const disagrees = this.whereTheFileDisagrees(diagnostics, args);
-    return this.jsonTextResponse(markIfStale({
-      scriptPath: readString(args, "scriptPath"),
-      clean: errors === 0,
-      errors,
-      warnings: diagnostics.length - errors,
-      diagnostics,
-      ...disagrees
-    }, this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()));
+    return {
+      answer: {
+        scriptPath: readString(args, "scriptPath"),
+        clean: errors === 0,
+        errors,
+        warnings: diagnostics.length - errors,
+        diagnostics,
+        ...this.whereTheFileDisagrees(diagnostics, args)
+      }
+    };
   }
   whereTheFileDisagrees(diagnostics, args) {
     const messages = diagnostics.map((entry) => asParams(entry)["message"]).filter((message) => typeof message === "string");
@@ -44646,14 +44788,16 @@ class GodotServer {
     const greeted = hasSaidWhoItIs(status);
     const stale = greeted && editorIsStale(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest());
     const unfinished = this.restartLeftUnfinished(status.connected);
+    const arriving = status.connected || this.ownProject === null ? [] : await this.editorsNotYetConnected(this.ownProject) ?? [];
     return {
       ...status,
       serverVersion: SERVER_VERSION,
       addonIsStale: greeted ? stale : undefined,
       greeting: status.connected && !greeted ? "The editor has connected and has not yet said who it is: its project, pid, addon version and ports arrive with its greeting a moment after the socket opens, later while it imports. Ask again for them." : undefined,
       bridgeAvailable: this.bridgeStartupError === null,
-      mayYetConnect: status.connected ? undefined : unfinished !== null ? unfinished.underway : anEditorIsStillComing(status.listeningSince, launchedIsUp),
-      restartInterrupted: unfinished === null || unfinished.underway ? undefined : {
+      mayYetConnect: status.connected ? undefined : arriving.length > 0 ? true : unfinished !== null ? unfinished.underway : anEditorIsStillComing(status.listeningSince, launchedIsUp),
+      editorsNotYetConnected: arriving.length > 0 ? arriving : undefined,
+      restartInterrupted: unfinished === null || unfinished.underway || arriving.length > 0 ? undefined : {
         quitEditorPid: unfinished.note.editorPid,
         quitAt: unfinished.note.quitAt,
         byServerPid: unfinished.note.byPid,
@@ -44950,6 +45094,14 @@ class GodotServer {
     if (refused !== null) {
       return refused;
     }
+    const arriving = await this.editorsNotYetConnected(project.value.path);
+    if (arriving !== undefined && arriving.length > 0) {
+      const named = arriving.map((one) => `pid ${one.pid}${one.startedAt === null ? "" : `, started ${one.startedAt}`}`).join("; ");
+      return this.createErrorResponse(`An editor of this project is already running (${named}) and has not reached this server yet: an editor dials in once it is up, later while it imports, so opening another would put two editors on one project and one language server port.`, [
+        "editor_status names it under editorsNotYetConnected and says when it has connected",
+        `If it never connects it is not reaching this server: end ${arriving.length === 1 ? "that pid" : "those pids"} and open again`
+      ]);
+    }
     const engine = await this.engine();
     if (!engine.ok) {
       return engine.response;
@@ -44974,6 +45126,19 @@ class GodotServer {
       settingsNote: before === null ? "project.godot could not be read before this editor was opened, so nothing here will be able to say what the import saved away. Opening a project rewrites the file and drops any key sitting at its own default." : before.size === 0 ? undefined : "Opening a project imports it and saves project.godot, and Godot drops any key sitting at its own default. editor_status names anything lost under settingsDropped once this editor has connected."
     });
   }
+  async editorsNotYetConnected(projectPath) {
+    const tree = await processTree();
+    if (tree === undefined) {
+      return;
+    }
+    const connected = this.godotBridge.isConnected() ? this.godotBridge.getStatus().editorPid : undefined;
+    const pids = editorsOfProjectIn(tree, projectPath).filter((pid) => pid !== connected);
+    const started = await startTimesOf(pids);
+    return pids.map((pid) => {
+      const at = started.get(pid) ?? tree.get(pid)?.startedAt;
+      return { pid, startedAt: at === undefined ? null : new Date(at).toISOString() };
+    });
+  }
   anEditorThatCannotConnect(projectPath) {
     if (this.ownProject !== null && !isSameDirectory(this.ownProject, projectPath)) {
       return this.createErrorResponse(`This server serves ${this.ownProject}, and an editor of ${projectPath} would dial that project's own server rather than this one.`, [
@@ -47238,7 +47403,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run4, __dirname2, GREETING_WAIT_MS = 1e4, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, KEEPER_ANSWER_MS = 15000, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, SCAN_WAIT_MS = 30000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run4, __dirname2, GREETING_WAIT_MS = 1e4, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, KEEPER_ANSWER_MS = 15000, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, SCAN_WAIT_MS = 30000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", MOST_DIAGNOSED = 300;
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();

package/build/index.js

@@ -29729,6 +29729,9 @@ class LSPTimeout extends Error {
 class ArgumentRefusal extends Refusal {
 }
 
+class NoDiagnosticsPublished extends Error {
+}
+
 class AnotherProjectsServer extends Refusal {
   serves;
   constructor(port, serves, asked) {
@@ -30116,7 +30119,7 @@ class GodotLSPClient {
       const diagnosticsPromise = new Promise((resolveDiagnostics, rejectDiagnostics) => {
         const timer = setTimeout(() => {
           this.diagnosticsWaiters.delete(key);
-          rejectDiagnostics(new Error(`Godot published no diagnostics for ${key} within ${DIAGNOSTICS_TIMEOUT_MS}ms. ` + "The language server may not be running, or may not have this file in its workspace."));
+          rejectDiagnostics(new NoDiagnosticsPublished(`Godot published no diagnostics for ${key} within ${DIAGNOSTICS_TIMEOUT_MS}ms. ` + "The language server may not be running, or may not have this file in its workspace."));
         }, DIAGNOSTICS_TIMEOUT_MS);
         this.diagnosticsWaiters.set(key, {
           resolve: resolveDiagnostics,
@@ -30346,7 +30349,8 @@ async function handleLSPTool(client, toolName, args) {
     return asToolResponse({
       error: normalizeLSPError(error, client.port),
       ...error instanceof AnotherProjectsServer ? { serves: error.serves } : {},
-      ...error instanceof ArgumentRefusal ? { refusedArguments: true } : {}
+      ...error instanceof ArgumentRefusal ? { refusedArguments: true } : {},
+      ...error instanceof NoDiagnosticsPublished ? { aboutThisFile: true } : {}
     });
   }
 }
@@ -33520,10 +33524,14 @@ 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, a method, property, constant, static function or enum member, 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. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And 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.",
+    description: "Errors and warnings for a script, or for several, from the editor's language server, and whether each 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, a method, property, constant, static function or enum member, 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. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And 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
+      scriptPath: {
+        type: ["string", "array"],
+        items: { type: "string" },
+        description: 'A script inside the project, a folder, or a list of either, such as "scripts/player.gd" or ["scripts/economy", "ui/shop.gd"]. A folder is its .gd files at any depth, skipping what the engine skips. One script is answered as it always was; several are answered together under scripts, each in that same shape, with clean, errors and warnings for all of them beside it, and a script that could not be read is named there with why while the rest are still asked about. At most 300 scripts a call.'
+      }
     },
     requires: ["projectPath", "scriptPath"]
   },
@@ -33570,7 +33578,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_launch",
-    description: "Opens the Godot editor on a project, or restarts the one already connected. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, visible unless hidden: true is passed again, once the old one has gone: it waits 90 seconds for that, or GDHARNESS_EDITOR_RESTART_TIMEOUT_MS, and an old editor still running after it is not replaced, since the new one would find its ports held. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart. An open is refused when the editor it would start could never reach this server: a project other than the one this server serves, whose editor dials that project's own server; a project without the gdharness editor addon installed and enabled; and a project whose editor a restart is already bringing back.",
+    description: "Opens the Godot editor on a project, or restarts the one already connected. open refuses while an editor of the project is already running and has not reached this server, naming its pid, rather than putting a second on the project. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, visible unless hidden: true is passed again, once the old one has gone: it waits 90 seconds for that, or GDHARNESS_EDITOR_RESTART_TIMEOUT_MS, and an old editor still running after it is not replaced, since the new one would find its ports held. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart. An open is refused when the editor it would start could never reach this server: a project other than the one this server serves, whose editor dials that project's own server; a project without the gdharness editor addon installed and enabled; and a project whose editor a restart is already bringing back.",
     parameters: {
       projectPath: { ...PROJECT_PATH, ops: ["open"] },
       hidden: {
@@ -33725,7 +33733,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_status",
-    description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it; null when there is none. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs gdharness upgrade, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. Every runtime_* answer from such a game carries addonIsStale and staleNote too. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs. An engine run that loads the editor addon to do one job and quit, such as a gate's godot --headless --import, an export or a script, is not taken as the editor: a process that greets without a server's mark has its command line read first, and while that is read identifying is true and connected false; one started with such an option is turned away, and turnedAway names the last one, its pid and the option. Every other call made while an editor is arriving, before its greeting or while it is looked up, waits up to ten seconds for it to settle rather than acting on connected as it reads in that window.",
+    description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it; null when there is none. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs gdharness upgrade, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. Every runtime_* answer from such a game carries addonIsStale and staleNote too. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. Any editor of this project running and not yet connected, whoever opened it, makes it true as well and is named under editorsNotYetConnected with its pid and start time, so a restart a reconnect interrupted after its launch is not read as nothing being there. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs. An engine run that loads the editor addon to do one job and quit, such as a gate's godot --headless --import, an export or a script, is not taken as the editor: a process that greets without a server's mark has its command line read first, and while that is read identifying is true and connected false; one started with such an option is turned away, and turnedAway names the last one, its pid and the option. Every other call made while an editor is arriving, before its greeting or while it is looked up, waits up to ten seconds for it to settle rather than acting on connected as it reads in that window.",
     parameters: {},
     requires: []
   },
@@ -34509,6 +34517,16 @@ function previousRunLeft(ended) {
   return (ended?.ending === "refused" || ended?.ending === "lingering") && ended.pid !== null ? ended.pid : undefined;
 }
 var CONSOLE_WRAPPER = /_console(\.exe)?$/i;
+function editorsOfProjectIn(tree, projectPath) {
+  const found = [];
+  for (const [pid, listed] of tree) {
+    const read = readCommandLine(listed.command);
+    if (read.editor && read.oneShot === null && read.projectPath !== null && /godot/i.test(read.executable) && !CONSOLE_WRAPPER.test(read.executable) && isSameDirectory(read.projectPath, projectPath)) {
+      found.push(pid);
+    }
+  }
+  return found.sort((a, b) => a - b);
+}
 function engineNamesOf(executable) {
   return CONSOLE_WRAPPER.test(executable) ? [executable, executable.replace(CONSOLE_WRAPPER, "$1")] : [executable];
 }
@@ -35054,6 +35072,83 @@ function testPathsIn(projectPath, given) {
     value: unique.filter((path) => !unique.some((other) => other !== path && within(path, other))).map((path) => `res://${path}`)
   };
 }
+var MOST_DIAGNOSED = 300;
+function scriptsToDiagnose(projectPath, given) {
+  const listed = Array.isArray(given);
+  if (!listed) {
+    const one = typeof given === "string" ? resolveWithinProject(projectPath, given) : null;
+    if (one === null || !one.ok || !isDirectory(one.absolutePath)) {
+      return { ok: true, value: null };
+    }
+  }
+  const entries = listed ? given : [given];
+  if (entries.length === 0) {
+    return {
+      ok: false,
+      reason: "scriptPath is an empty list: name a script, a folder, or a list of either."
+    };
+  }
+  const found = [];
+  const empty = [];
+  for (const [index, entry] of entries.entries()) {
+    if (typeof entry !== "string" || entry.trim() === "") {
+      return {
+        ok: false,
+        reason: `scriptPath${listed ? `[${index}]` : ""} is ${typeof entry === "string" ? "empty" : describeValue(entry)}, not a script or a folder in the project.`
+      };
+    }
+    const location = resolveWithinProject(projectPath, entry);
+    if (!location.ok) {
+      return { ok: false, reason: location.reason };
+    }
+    const relative = location.relativePath.replace(/\/+$/, "");
+    if (!isDirectory(location.absolutePath)) {
+      found.push(relative);
+      continue;
+    }
+    const inside = scriptsUnder(location.absolutePath, relative);
+    if (inside.length === 0) {
+      empty.push(entry);
+    }
+    found.push(...inside);
+  }
+  const unique = [...new Set(found)];
+  if (unique.length === 0) {
+    return { ok: false, reason: `No .gd script is under ${empty.join(" or ")}.` };
+  }
+  if (unique.length > MOST_DIAGNOSED) {
+    return {
+      ok: false,
+      reason: `scriptPath names ${unique.length} scripts, and one call asks about at most ${MOST_DIAGNOSED}, each a round trip through the language server: name narrower folders, or call again for the rest.`
+    };
+  }
+  return { ok: true, value: unique };
+}
+function isDirectory(path) {
+  try {
+    return statSync8(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function scriptsUnder(directory, prefix) {
+  if (existsSync17(join22(directory, ".gdignore"))) {
+    return [];
+  }
+  const found = [];
+  for (const entry of readdirSync9(directory, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : 1)) {
+    if (entry.name.startsWith(".")) {
+      continue;
+    }
+    const path = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+    if (entry.isDirectory()) {
+      found.push(...scriptsUnder(join22(directory, entry.name), path));
+    } else if (entry.isFile() && entry.name.endsWith(".gd")) {
+      found.push(path);
+    }
+  }
+  return found;
+}
 function hasMainScene(projectFile) {
   const scene = parseProjectGodot(readFileSync20(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
@@ -36882,39 +36977,88 @@ class GodotServer {
     }
   }
   async handleScriptDiagnostics(args) {
+    const project = this.project(args);
+    const scripts = project.ok ? scriptsToDiagnose(project.value.path, args["scriptPath"]) : null;
+    if (scripts !== null && !scripts.ok) {
+      return this.createErrorResponse(scripts.reason);
+    }
+    if (scripts?.value == null) {
+      const one = await this.diagnosticsOf(args);
+      return "refusal" in one ? one.refusal : this.jsonTextResponse(this.markedIfStale(one.answer));
+    }
+    const progress = callProgress();
+    const answers = [];
+    let errors = 0;
+    let warnings = 0;
+    let unread = 0;
+    for (const [at, scriptPath] of scripts.value.entries()) {
+      progress?.(at + 1, `${at + 1} of ${scripts.value.length}: ${scriptPath}`);
+      const one = await this.diagnosticsOf({ ...args, scriptPath });
+      if ("refusal" in one) {
+        if (!one.perScript) {
+          return one.refusal;
+        }
+        unread += 1;
+        answers.push({ scriptPath, error: one.refusal.content[0]?.text ?? "not read" });
+        continue;
+      }
+      errors += Number(one.answer["errors"]);
+      warnings += Number(one.answer["warnings"]);
+      answers.push(one.answer);
+    }
+    return this.jsonTextResponse(this.markedIfStale({
+      clean: errors === 0 && unread === 0,
+      scriptsChecked: answers.length,
+      errors,
+      warnings,
+      ...unread > 0 ? { scriptsNotRead: unread } : {},
+      scripts: answers
+    }));
+  }
+  markedIfStale(answer) {
+    return markIfStale(answer, this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest(), this.editorCodeOnDisk());
+  }
+  async diagnosticsOf(args) {
     const answer = await this.handleLSP("lsp_get_diagnostics", args);
     const payload = asParams(JSON.parse(answer.content[0]?.text ?? "{}"));
     if (payload["error"] !== undefined) {
       const reason = typeof payload["error"] === "string" ? payload["error"] : JSON.stringify(payload["error"]);
       if (payload["refusedArguments"] === true) {
-        return this.createErrorResponse(reason);
+        return { refusal: this.createErrorResponse(reason), perScript: true };
       }
       if (typeof payload["serves"] === "string") {
-        return this.createErrorResponse(`Diagnostics unavailable: ${reason}`, [
-          "editor_status names the editor on the bridge and the port it says it serves",
-          "editor_launch opens this project's own editor, on a language server port of its own",
-          "GDHARNESS_LSP_PORT points this server at the right one"
-        ]);
+        return {
+          refusal: this.createErrorResponse(`Diagnostics unavailable: ${reason}`, [
+            "editor_status names the editor on the bridge and the port it says it serves",
+            "editor_launch opens this project's own editor, on a language server port of its own",
+            "GDHARNESS_LSP_PORT points this server at the right one"
+          ]),
+          perScript: false
+        };
       }
-      return this.createErrorResponse(`Diagnostics unavailable: ${reason}`, [
-        `Ensure the Godot editor is running with its language server enabled, on port ${this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT)}`,
-        "GDHARNESS_LSP_PORT points this server at another one"
-      ]);
+      return {
+        refusal: this.createErrorResponse(`Diagnostics unavailable: ${reason}`, [
+          `Ensure the Godot editor is running with its language server enabled, on port ${this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT)}`,
+          "GDHARNESS_LSP_PORT points this server at another one"
+        ]),
+        perScript: payload["aboutThisFile"] === true
+      };
     }
     const diagnostics = readArray(payload, "diagnostics") ?? [];
     const errors = diagnostics.filter((entry) => {
       const severity = asParams(entry)["severity"];
       return severity === 1 || severity === "error" || severity === "ERROR";
     }).length;
-    const disagrees = this.whereTheFileDisagrees(diagnostics, args);
-    return this.jsonTextResponse(markIfStale({
-      scriptPath: readString(args, "scriptPath"),
-      clean: errors === 0,
-      errors,
-      warnings: diagnostics.length - errors,
-      diagnostics,
-      ...disagrees
-    }, this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()));
+    return {
+      answer: {
+        scriptPath: readString(args, "scriptPath"),
+        clean: errors === 0,
+        errors,
+        warnings: diagnostics.length - errors,
+        diagnostics,
+        ...this.whereTheFileDisagrees(diagnostics, args)
+      }
+    };
   }
   whereTheFileDisagrees(diagnostics, args) {
     const messages = diagnostics.map((entry) => asParams(entry)["message"]).filter((message) => typeof message === "string");
@@ -37132,14 +37276,16 @@ class GodotServer {
     const greeted = hasSaidWhoItIs(status);
     const stale = greeted && editorIsStale(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest());
     const unfinished = this.restartLeftUnfinished(status.connected);
+    const arriving = status.connected || this.ownProject === null ? [] : await this.editorsNotYetConnected(this.ownProject) ?? [];
     return {
       ...status,
       serverVersion: SERVER_VERSION,
       addonIsStale: greeted ? stale : undefined,
       greeting: status.connected && !greeted ? "The editor has connected and has not yet said who it is: its project, pid, addon version and ports arrive with its greeting a moment after the socket opens, later while it imports. Ask again for them." : undefined,
       bridgeAvailable: this.bridgeStartupError === null,
-      mayYetConnect: status.connected ? undefined : unfinished !== null ? unfinished.underway : anEditorIsStillComing(status.listeningSince, launchedIsUp),
-      restartInterrupted: unfinished === null || unfinished.underway ? undefined : {
+      mayYetConnect: status.connected ? undefined : arriving.length > 0 ? true : unfinished !== null ? unfinished.underway : anEditorIsStillComing(status.listeningSince, launchedIsUp),
+      editorsNotYetConnected: arriving.length > 0 ? arriving : undefined,
+      restartInterrupted: unfinished === null || unfinished.underway || arriving.length > 0 ? undefined : {
         quitEditorPid: unfinished.note.editorPid,
         quitAt: unfinished.note.quitAt,
         byServerPid: unfinished.note.byPid,
@@ -37436,6 +37582,14 @@ class GodotServer {
     if (refused !== null) {
       return refused;
     }
+    const arriving = await this.editorsNotYetConnected(project.value.path);
+    if (arriving !== undefined && arriving.length > 0) {
+      const named = arriving.map((one) => `pid ${one.pid}${one.startedAt === null ? "" : `, started ${one.startedAt}`}`).join("; ");
+      return this.createErrorResponse(`An editor of this project is already running (${named}) and has not reached this server yet: an editor dials in once it is up, later while it imports, so opening another would put two editors on one project and one language server port.`, [
+        "editor_status names it under editorsNotYetConnected and says when it has connected",
+        `If it never connects it is not reaching this server: end ${arriving.length === 1 ? "that pid" : "those pids"} and open again`
+      ]);
+    }
     const engine = await this.engine();
     if (!engine.ok) {
       return engine.response;
@@ -37460,6 +37614,19 @@ class GodotServer {
       settingsNote: before === null ? "project.godot could not be read before this editor was opened, so nothing here will be able to say what the import saved away. Opening a project rewrites the file and drops any key sitting at its own default." : before.size === 0 ? undefined : "Opening a project imports it and saves project.godot, and Godot drops any key sitting at its own default. editor_status names anything lost under settingsDropped once this editor has connected."
     });
   }
+  async editorsNotYetConnected(projectPath) {
+    const tree = await processTree();
+    if (tree === undefined) {
+      return;
+    }
+    const connected = this.godotBridge.isConnected() ? this.godotBridge.getStatus().editorPid : undefined;
+    const pids = editorsOfProjectIn(tree, projectPath).filter((pid) => pid !== connected);
+    const started = await startTimesOf(pids);
+    return pids.map((pid) => {
+      const at = started.get(pid) ?? tree.get(pid)?.startedAt;
+      return { pid, startedAt: at === undefined ? null : new Date(at).toISOString() };
+    });
+  }
   anEditorThatCannotConnect(projectPath) {
     if (this.ownProject !== null && !isSameDirectory(this.ownProject, projectPath)) {
       return this.createErrorResponse(`This server serves ${this.ownProject}, and an editor of ${projectPath} would dial that project's own server rather than this one.`, [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.1.49",
+  "version": "1.1.51",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",