gdharness 1.1.50 → 1.1.52

package/build/cli.js

@@ -8544,7 +8544,8 @@ function sameCodeNote(addonVersion, serverVersion, addonDigest, shippedDigest) {
   if (addonVersion === undefined || addonVersion === serverVersion || addonDigest === undefined || addonDigest === "" || addonDigest !== shippedDigest) {
     return;
   }
-  return `The editor loaded the ${addonVersion} addons, which are the same code this ${serverVersion} server ships, so nothing needs restarting; addonVersion changes at the next editor start.`;
+  const same = `The editor loaded the ${addonVersion} addons, which are the same code this ${serverVersion} server ships, so nothing needs restarting`;
+  return isNewer(addonVersion, serverVersion) ? `${same}. This server is the older of the two, which a reconnect in your harness settles once the project pins ${addonVersion}.` : `${same}; addonVersion is the version the editor loaded when it started.`;
 }
 function addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest, onDisk) {
   if (!editorIsStale(addonVersion, serverVersion, addonDigest, shippedDigest)) {
@@ -17826,8 +17827,16 @@ var init_tool_definitions = __esm(() => {
           type: "boolean",
           description: "structure: also list what the script inherits, walking extends through the project's other scripts. Each such member carries inherited_from, the file declaring it, and the answer gains inherits_from, the chain that was walked. A name the script overrides is listed at both its lines rather than once. A native base is not walked, since it declares nothing in a file: editor_classes info answers for those. Default false."
         },
-        line: { type: "integer", minimum: 0, description: "completion, hover: zero-based line." },
-        character: { type: "integer", minimum: 0, description: "completion, hover: zero-based column." }
+        line: {
+          type: "integer",
+          minimum: 1,
+          description: "completion, hover: the line, counted from 1 as the editor shows it."
+        },
+        character: {
+          type: "integer",
+          minimum: 1,
+          description: "completion, hover: the column, counted from 1 as the editor shows it, with a tab counted as one. symbols gives each name at the line and column hover is asked at."
+        }
       },
       requires: ["projectPath", "scriptPath"],
       operations: {
@@ -17835,7 +17844,10 @@ var init_tool_definitions = __esm(() => {
           summary: "functions, variables, signals, class_name and extends, read from the file",
           requires: []
         },
-        symbols: { summary: "document symbols from the language server", requires: [] },
+        symbols: {
+          summary: "document symbols from the language server, each with its kind, the line and column of its name, and the lastLine of its declaration",
+          requires: []
+        },
         completion: { summary: "completions at a position", requires: ["line", "character"] },
         hover: { summary: "hover text at a position", requires: ["line", "character"] }
       },
@@ -17843,13 +17855,13 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "script_diagnostics",
-      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.",
+      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. Each diagnostic carries its severity (error or warning), its message, and where it is as the editor shows it: line and column counted from 1, and endLine and endColumn just past its end. 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: {
           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.'
+          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, with clean, errors and warnings for all of them: a script with nothing to report is named in nothingReported, and every other is answered under scripts in that same shape, including a script that could not be read, named with why while the rest are still asked about. Any number of scripts is one call, which reports progress as it goes.'
         }
       },
       requires: ["projectPath", "scriptPath"]
@@ -17897,7 +17909,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: {
@@ -18052,7 +18064,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: []
     },
@@ -39112,6 +39124,10 @@ import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
 import { dirname as dirname14, join as join20, resolve as resolve5 } from "node:path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
+function initializeTimeoutMs() {
+  const override = Number.parseInt(envValue("GDHARNESS_LSP_INITIALIZE_TIMEOUT_MS") ?? "", 10);
+  return Number.isInteger(override) && override > 0 ? override : 180000;
+}
 function diagnosticsKey(uri) {
   let decoded;
   try {
@@ -39145,7 +39161,11 @@ class GodotLSPClient {
   documentVersions = new Map;
   documentTurns = new Map;
   timeouts;
-  constructor(port = portFromEnv("GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT), host = "127.0.0.1", timeouts = { requestMs: REQUEST_TIMEOUT_MS2, referencesMs: REFERENCES_TIMEOUT_MS }) {
+  constructor(port = portFromEnv("GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT), host = "127.0.0.1", timeouts = {
+    requestMs: REQUEST_TIMEOUT_MS2,
+    referencesMs: REFERENCES_TIMEOUT_MS,
+    initializeMs: initializeTimeoutMs()
+  }) {
     this.port = port;
     this.host = host;
     this.timeouts = timeouts;
@@ -39455,7 +39475,7 @@ class GodotLSPClient {
           name: resolvedRootPath
         }
       ]
-    });
+    }, this.timeouts.initializeMs);
     const served = this.servedWorkspace;
     if (served !== null && !isSameDirectory(served, resolvedRootPath)) {
       throw new AnotherProjectsServer(this.port, served, resolvedRootPath);
@@ -39641,10 +39661,78 @@ function normalizeLSPError(error, port) {
     if (error.message.includes("ECONNREFUSED") || error.message.includes("Failed to connect to Godot LSP") || error.message.includes("socket closed")) {
       return `Godot LSP is unavailable on port ${port}. Start the Godot editor and enable Language Server in Editor Settings, or set GDHARNESS_LSP_PORT to the port it serves.`;
     }
+    if (error instanceof LSPTimeout && error.method === "initialize") {
+      return `The language server on port ${port} took the connection and did not answer initialize within ${String(error.seconds)}s. Godot reads every script in the project before it answers the first initialize after its editor starts, and goes on reading after this call stops waiting, so call again once the editor has settled.`;
+    }
     return error.message;
   }
   return String(error);
 }
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function named(value, names) {
+  return typeof value === "number" && Number.isInteger(value) ? names[value - 1] ?? value : value;
+}
+function shownPosition(position) {
+  const { line, character } = asRecord(position);
+  return typeof line === "number" && typeof character === "number" ? { line: line + 1, column: character + 1 } : null;
+}
+function shownRange(range) {
+  const start = shownPosition(asRecord(range)["start"]);
+  const end = shownPosition(asRecord(range)["end"]);
+  return {
+    ...start === null ? {} : { line: start.line, column: start.column },
+    ...end === null ? {} : { endLine: end.line, endColumn: end.column }
+  };
+}
+function shownDiagnostic(entry) {
+  const { range, severity, message, code } = asRecord(entry);
+  return {
+    ...shownRange(range),
+    severity: named(severity, SEVERITIES),
+    message,
+    ...code === undefined || code === null || code === 0 || code === "" ? {} : { code }
+  };
+}
+function shownSymbol(entry) {
+  const symbol = asRecord(entry);
+  const whole = asRecord(symbol["range"] ?? asRecord(symbol["location"])["range"]);
+  const at = shownPosition(asRecord(symbol["selectionRange"] ?? whole)["start"]);
+  const last = shownPosition(whole["end"]);
+  const children = Array.isArray(symbol["children"]) ? symbol["children"] : [];
+  const { documentation, native_class: nativeClass, deprecated, detail } = symbol;
+  return {
+    name: symbol["name"],
+    kind: named(symbol["kind"], SYMBOL_KINDS),
+    ...typeof detail === "string" && detail !== "" ? { detail } : {},
+    ...at === null ? {} : { line: at.line, column: at.column },
+    ...last === null ? {} : { lastLine: last.line },
+    ...typeof documentation === "string" && documentation !== "" ? { documentation } : {},
+    ...typeof nativeClass === "string" && nativeClass !== "" ? { nativeClass } : {},
+    ...deprecated === true ? { deprecated } : {},
+    ...children.length > 0 ? { children: children.map(shownSymbol) } : {}
+  };
+}
+function shownCompletion(entry) {
+  const { data: _request, kind, ...rest } = asRecord(entry);
+  return { ...rest, kind: named(kind, COMPLETION_KINDS) };
+}
+function shownHover(hover) {
+  if (hover === null || typeof hover !== "object") {
+    return hover;
+  }
+  const { range, ...rest } = asRecord(hover);
+  return { ...rest, ...shownRange(range) };
+}
+function protocolPosition(args) {
+  const line = args["line"];
+  const character = args["character"];
+  if (typeof line !== "number" || typeof character !== "number" || !Number.isInteger(line) || !Number.isInteger(character) || line < 1 || character < 1) {
+    throw new ArgumentRefusal(`line and character are counted from 1, as the editor shows them; got line ${String(line)} and character ${String(character)}.`);
+  }
+  return { line: line - 1, character: character - 1 };
+}
 async function resolveLSPPaths(projectPathValue, scriptPathValue) {
   const requestedProjectPath = resolve5(projectPathValue);
   let projectPath;
@@ -39691,29 +39779,21 @@ async function handleLSPTool(client, toolName, args) {
     switch (toolName) {
       case "lsp_get_diagnostics": {
         const diagnostics = await client.getDiagnostics(scriptPath, content);
-        return asToolResponse({ diagnostics });
+        return asToolResponse({ diagnostics: diagnostics.map(shownDiagnostic) });
       }
       case "lsp_get_completions": {
-        const line = Number(parsedArgs["line"]);
-        const character = Number(parsedArgs["character"]);
-        if (!Number.isFinite(line) || !Number.isFinite(character)) {
-          throw new ArgumentRefusal("Arguments line and character must be numbers.");
-        }
+        const { line, character } = protocolPosition(parsedArgs);
         const completions = await client.getCompletions(scriptPath, content, line, character);
-        return asToolResponse({ completions });
+        return asToolResponse({ completions: completions.map(shownCompletion) });
       }
       case "lsp_get_hover": {
-        const line = Number(parsedArgs["line"]);
-        const character = Number(parsedArgs["character"]);
-        if (!Number.isFinite(line) || !Number.isFinite(character)) {
-          throw new ArgumentRefusal("Arguments line and character must be numbers.");
-        }
+        const { line, character } = protocolPosition(parsedArgs);
         const hover = await client.getHover(scriptPath, content, line, character);
-        return asToolResponse({ hover });
+        return asToolResponse({ hover: shownHover(hover) });
       }
       case "lsp_get_symbols": {
         const symbols = await client.getDocumentSymbols(scriptPath, content);
-        return asToolResponse({ symbols });
+        return asToolResponse({ symbols: symbols.map(shownSymbol) });
       }
       default:
         return asToolResponse({ error: `Unknown LSP tool: ${toolName}` });
@@ -39723,11 +39803,12 @@ async function handleLSPTool(client, toolName, args) {
       error: normalizeLSPError(error, client.port),
       ...error instanceof AnotherProjectsServer ? { serves: error.serves } : {},
       ...error instanceof ArgumentRefusal ? { refusedArguments: true } : {},
-      ...error instanceof NoDiagnosticsPublished ? { aboutThisFile: true } : {}
+      ...error instanceof NoDiagnosticsPublished ? { aboutThisFile: true } : {},
+      ...error instanceof LSPTimeout && error.method === "initialize" ? { stillReading: true } : {}
     });
   }
 }
-var DEFAULT_LSP_PORT = 6005, DIAGNOSTICS_TIMEOUT_MS = 5000, REQUEST_TIMEOUT_MS2 = 1e4, REFERENCES_TIMEOUT_MS = 180000, LSPTimeout, ArgumentRefusal, NoDiagnosticsPublished, AnotherProjectsServer;
+var DEFAULT_LSP_PORT = 6005, DIAGNOSTICS_TIMEOUT_MS = 5000, REQUEST_TIMEOUT_MS2 = 1e4, REFERENCES_TIMEOUT_MS = 180000, LSPTimeout, ArgumentRefusal, NoDiagnosticsPublished, AnotherProjectsServer, SEVERITIES, SYMBOL_KINDS, COMPLETION_KINDS;
 var init_lsp_client = __esm(() => {
   init_answer_json();
   init_errors();
@@ -39754,6 +39835,62 @@ var init_lsp_client = __esm(() => {
       this.serves = serves;
     }
   };
+  SEVERITIES = ["error", "warning", "information", "hint"];
+  SYMBOL_KINDS = [
+    "file",
+    "module",
+    "namespace",
+    "package",
+    "class",
+    "method",
+    "property",
+    "field",
+    "constructor",
+    "enum",
+    "interface",
+    "function",
+    "variable",
+    "constant",
+    "string",
+    "number",
+    "boolean",
+    "array",
+    "object",
+    "key",
+    "null",
+    "enum member",
+    "struct",
+    "event",
+    "operator",
+    "type parameter"
+  ];
+  COMPLETION_KINDS = [
+    "text",
+    "method",
+    "function",
+    "constructor",
+    "field",
+    "variable",
+    "class",
+    "interface",
+    "module",
+    "property",
+    "unit",
+    "value",
+    "enum",
+    "keyword",
+    "snippet",
+    "color",
+    "file",
+    "reference",
+    "folder",
+    "enum member",
+    "constant",
+    "struct",
+    "event",
+    "operator",
+    "type parameter"
+  ];
 });
 
 // src/outside.ts
@@ -42091,6 +42228,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];
 }
@@ -42618,12 +42765,6 @@ function scriptsToDiagnose(projectPath, given) {
   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) {
@@ -44489,11 +44630,16 @@ class GodotServer {
       return "refusal" in one ? one.refusal : this.jsonTextResponse(this.markedIfStale(one.answer));
     }
     const progress = callProgress();
-    const answers = [];
+    const cancelled = callSignal();
+    const reported = [];
+    const nothingReported = [];
     let errors = 0;
     let warnings = 0;
     let unread = 0;
     for (const [at, scriptPath] of scripts.value.entries()) {
+      if (cancelled?.aborted === true) {
+        return this.createErrorResponse(`Cancelled after ${at} of ${scripts.value.length} scripts.`);
+      }
       progress?.(at + 1, `${at + 1} of ${scripts.value.length}: ${scriptPath}`);
       const one = await this.diagnosticsOf({ ...args, scriptPath });
       if ("refusal" in one) {
@@ -44501,20 +44647,25 @@ class GodotServer {
           return one.refusal;
         }
         unread += 1;
-        answers.push({ scriptPath, error: one.refusal.content[0]?.text ?? "not read" });
+        reported.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);
+      if (readArray(one.answer, "diagnostics")?.length === 0) {
+        nothingReported.push(scriptPath);
+      } else {
+        reported.push(one.answer);
+      }
     }
     return this.jsonTextResponse(this.markedIfStale({
       clean: errors === 0 && unread === 0,
-      scriptsChecked: answers.length,
+      scriptsChecked: scripts.value.length,
       errors,
       warnings,
       ...unread > 0 ? { scriptsNotRead: unread } : {},
-      scripts: answers
+      scripts: reported,
+      nothingReported
     }));
   }
   markedIfStale(answer) {
@@ -44528,6 +44679,9 @@ class GodotServer {
       if (payload["refusedArguments"] === true) {
         return { refusal: this.createErrorResponse(reason), perScript: true };
       }
+      if (payload["stillReading"] === true) {
+        return { refusal: this.createErrorResponse(`Diagnostics unavailable: ${reason}`), perScript: false };
+      }
       if (typeof payload["serves"] === "string") {
         return {
           refusal: this.createErrorResponse(`Diagnostics unavailable: ${reason}`, [
@@ -44547,10 +44701,7 @@ class GodotServer {
       };
     }
     const diagnostics = readArray(payload, "diagnostics") ?? [];
-    const errors = diagnostics.filter((entry) => {
-      const severity = asParams(entry)["severity"];
-      return severity === 1 || severity === "error" || severity === "ERROR";
-    }).length;
+    const errors = diagnostics.filter((entry) => asParams(entry)["severity"] === "error").length;
     return {
       answer: {
         scriptPath: readString(args, "scriptPath"),
@@ -44778,14 +44929,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,
@@ -45082,6 +45235,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;
@@ -45106,6 +45267,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.`, [
@@ -47370,7 +47544,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/", MOST_DIAGNOSED = 300;
+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 init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();

package/build/index.js

@@ -10069,7 +10069,8 @@ function sameCodeNote(addonVersion, serverVersion, addonDigest, shippedDigest) {
   if (addonVersion === undefined || addonVersion === serverVersion || addonDigest === undefined || addonDigest === "" || addonDigest !== shippedDigest) {
     return;
   }
-  return `The editor loaded the ${addonVersion} addons, which are the same code this ${serverVersion} server ships, so nothing needs restarting; addonVersion changes at the next editor start.`;
+  const same = `The editor loaded the ${addonVersion} addons, which are the same code this ${serverVersion} server ships, so nothing needs restarting`;
+  return isNewer(addonVersion, serverVersion) ? `${same}. This server is the older of the two, which a reconnect in your harness settles once the project pins ${addonVersion}.` : `${same}; addonVersion is the version the editor loaded when it started.`;
 }
 function addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest, onDisk) {
   if (!editorIsStale(addonVersion, serverVersion, addonDigest, shippedDigest)) {
@@ -29715,6 +29716,10 @@ var DEFAULT_LSP_PORT = 6005;
 var DIAGNOSTICS_TIMEOUT_MS = 5000;
 var REQUEST_TIMEOUT_MS2 = 1e4;
 var REFERENCES_TIMEOUT_MS = 180000;
+function initializeTimeoutMs() {
+  const override = Number.parseInt(envValue("GDHARNESS_LSP_INITIALIZE_TIMEOUT_MS") ?? "", 10);
+  return Number.isInteger(override) && override > 0 ? override : 180000;
+}
 
 class LSPTimeout extends Error {
   method;
@@ -29772,7 +29777,11 @@ class GodotLSPClient {
   documentVersions = new Map;
   documentTurns = new Map;
   timeouts;
-  constructor(port = portFromEnv("GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT), host = "127.0.0.1", timeouts = { requestMs: REQUEST_TIMEOUT_MS2, referencesMs: REFERENCES_TIMEOUT_MS }) {
+  constructor(port = portFromEnv("GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT), host = "127.0.0.1", timeouts = {
+    requestMs: REQUEST_TIMEOUT_MS2,
+    referencesMs: REFERENCES_TIMEOUT_MS,
+    initializeMs: initializeTimeoutMs()
+  }) {
     this.port = port;
     this.host = host;
     this.timeouts = timeouts;
@@ -30082,7 +30091,7 @@ class GodotLSPClient {
           name: resolvedRootPath
         }
       ]
-    });
+    }, this.timeouts.initializeMs);
     const served = this.servedWorkspace;
     if (served !== null && !isSameDirectory(served, resolvedRootPath)) {
       throw new AnotherProjectsServer(this.port, served, resolvedRootPath);
@@ -30268,10 +30277,134 @@ function normalizeLSPError(error, port) {
     if (error.message.includes("ECONNREFUSED") || error.message.includes("Failed to connect to Godot LSP") || error.message.includes("socket closed")) {
       return `Godot LSP is unavailable on port ${port}. Start the Godot editor and enable Language Server in Editor Settings, or set GDHARNESS_LSP_PORT to the port it serves.`;
     }
+    if (error instanceof LSPTimeout && error.method === "initialize") {
+      return `The language server on port ${port} took the connection and did not answer initialize within ${String(error.seconds)}s. Godot reads every script in the project before it answers the first initialize after its editor starts, and goes on reading after this call stops waiting, so call again once the editor has settled.`;
+    }
     return error.message;
   }
   return String(error);
 }
+var SEVERITIES = ["error", "warning", "information", "hint"];
+var SYMBOL_KINDS = [
+  "file",
+  "module",
+  "namespace",
+  "package",
+  "class",
+  "method",
+  "property",
+  "field",
+  "constructor",
+  "enum",
+  "interface",
+  "function",
+  "variable",
+  "constant",
+  "string",
+  "number",
+  "boolean",
+  "array",
+  "object",
+  "key",
+  "null",
+  "enum member",
+  "struct",
+  "event",
+  "operator",
+  "type parameter"
+];
+var COMPLETION_KINDS = [
+  "text",
+  "method",
+  "function",
+  "constructor",
+  "field",
+  "variable",
+  "class",
+  "interface",
+  "module",
+  "property",
+  "unit",
+  "value",
+  "enum",
+  "keyword",
+  "snippet",
+  "color",
+  "file",
+  "reference",
+  "folder",
+  "enum member",
+  "constant",
+  "struct",
+  "event",
+  "operator",
+  "type parameter"
+];
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function named(value, names) {
+  return typeof value === "number" && Number.isInteger(value) ? names[value - 1] ?? value : value;
+}
+function shownPosition(position) {
+  const { line, character } = asRecord(position);
+  return typeof line === "number" && typeof character === "number" ? { line: line + 1, column: character + 1 } : null;
+}
+function shownRange(range) {
+  const start = shownPosition(asRecord(range)["start"]);
+  const end = shownPosition(asRecord(range)["end"]);
+  return {
+    ...start === null ? {} : { line: start.line, column: start.column },
+    ...end === null ? {} : { endLine: end.line, endColumn: end.column }
+  };
+}
+function shownDiagnostic(entry) {
+  const { range, severity, message, code } = asRecord(entry);
+  return {
+    ...shownRange(range),
+    severity: named(severity, SEVERITIES),
+    message,
+    ...code === undefined || code === null || code === 0 || code === "" ? {} : { code }
+  };
+}
+function shownSymbol(entry) {
+  const symbol = asRecord(entry);
+  const whole = asRecord(symbol["range"] ?? asRecord(symbol["location"])["range"]);
+  const at = shownPosition(asRecord(symbol["selectionRange"] ?? whole)["start"]);
+  const last = shownPosition(whole["end"]);
+  const children = Array.isArray(symbol["children"]) ? symbol["children"] : [];
+  const { documentation, native_class: nativeClass, deprecated, detail } = symbol;
+  return {
+    name: symbol["name"],
+    kind: named(symbol["kind"], SYMBOL_KINDS),
+    ...typeof detail === "string" && detail !== "" ? { detail } : {},
+    ...at === null ? {} : { line: at.line, column: at.column },
+    ...last === null ? {} : { lastLine: last.line },
+    ...typeof documentation === "string" && documentation !== "" ? { documentation } : {},
+    ...typeof nativeClass === "string" && nativeClass !== "" ? { nativeClass } : {},
+    ...deprecated === true ? { deprecated } : {},
+    ...children.length > 0 ? { children: children.map(shownSymbol) } : {}
+  };
+}
+function shownCompletion(entry) {
+  const { data: _request, kind, ...rest } = asRecord(entry);
+  return { ...rest, kind: named(kind, COMPLETION_KINDS) };
+}
+function shownHover(hover) {
+  if (hover === null || typeof hover !== "object") {
+    return hover;
+  }
+  const { range, ...rest } = asRecord(hover);
+  return { ...rest, ...shownRange(range) };
+}
+function protocolPosition(args) {
+  const line = args["line"];
+  const character = args["character"];
+  if (typeof line !== "number" || typeof character !== "number" || !Number.isInteger(line) || !Number.isInteger(character) || line < 1 || character < 1) {
+    throw new ArgumentRefusal(`line and character are counted from 1, as the editor shows them; got line ${String(line)} and character ${String(character)}.`);
+  }
+  return { line: line - 1, character: character - 1 };
+}
 async function resolveLSPPaths(projectPathValue, scriptPathValue) {
   const requestedProjectPath = resolve3(projectPathValue);
   let projectPath;
@@ -30318,29 +30451,21 @@ async function handleLSPTool(client, toolName, args) {
     switch (toolName) {
       case "lsp_get_diagnostics": {
         const diagnostics = await client.getDiagnostics(scriptPath, content);
-        return asToolResponse({ diagnostics });
+        return asToolResponse({ diagnostics: diagnostics.map(shownDiagnostic) });
       }
       case "lsp_get_completions": {
-        const line = Number(parsedArgs["line"]);
-        const character = Number(parsedArgs["character"]);
-        if (!Number.isFinite(line) || !Number.isFinite(character)) {
-          throw new ArgumentRefusal("Arguments line and character must be numbers.");
-        }
+        const { line, character } = protocolPosition(parsedArgs);
         const completions = await client.getCompletions(scriptPath, content, line, character);
-        return asToolResponse({ completions });
+        return asToolResponse({ completions: completions.map(shownCompletion) });
       }
       case "lsp_get_hover": {
-        const line = Number(parsedArgs["line"]);
-        const character = Number(parsedArgs["character"]);
-        if (!Number.isFinite(line) || !Number.isFinite(character)) {
-          throw new ArgumentRefusal("Arguments line and character must be numbers.");
-        }
+        const { line, character } = protocolPosition(parsedArgs);
         const hover = await client.getHover(scriptPath, content, line, character);
-        return asToolResponse({ hover });
+        return asToolResponse({ hover: shownHover(hover) });
       }
       case "lsp_get_symbols": {
         const symbols = await client.getDocumentSymbols(scriptPath, content);
-        return asToolResponse({ symbols });
+        return asToolResponse({ symbols: symbols.map(shownSymbol) });
       }
       default:
         return asToolResponse({ error: `Unknown LSP tool: ${toolName}` });
@@ -30350,7 +30475,8 @@ async function handleLSPTool(client, toolName, args) {
       error: normalizeLSPError(error, client.port),
       ...error instanceof AnotherProjectsServer ? { serves: error.serves } : {},
       ...error instanceof ArgumentRefusal ? { refusedArguments: true } : {},
-      ...error instanceof NoDiagnosticsPublished ? { aboutThisFile: true } : {}
+      ...error instanceof NoDiagnosticsPublished ? { aboutThisFile: true } : {},
+      ...error instanceof LSPTimeout && error.method === "initialize" ? { stillReading: true } : {}
     });
   }
 }
@@ -33507,8 +33633,16 @@ var TOOL_SPECS = [
         type: "boolean",
         description: "structure: also list what the script inherits, walking extends through the project's other scripts. Each such member carries inherited_from, the file declaring it, and the answer gains inherits_from, the chain that was walked. A name the script overrides is listed at both its lines rather than once. A native base is not walked, since it declares nothing in a file: editor_classes info answers for those. Default false."
       },
-      line: { type: "integer", minimum: 0, description: "completion, hover: zero-based line." },
-      character: { type: "integer", minimum: 0, description: "completion, hover: zero-based column." }
+      line: {
+        type: "integer",
+        minimum: 1,
+        description: "completion, hover: the line, counted from 1 as the editor shows it."
+      },
+      character: {
+        type: "integer",
+        minimum: 1,
+        description: "completion, hover: the column, counted from 1 as the editor shows it, with a tab counted as one. symbols gives each name at the line and column hover is asked at."
+      }
     },
     requires: ["projectPath", "scriptPath"],
     operations: {
@@ -33516,7 +33650,10 @@ var TOOL_SPECS = [
         summary: "functions, variables, signals, class_name and extends, read from the file",
         requires: []
       },
-      symbols: { summary: "document symbols from the language server", requires: [] },
+      symbols: {
+        summary: "document symbols from the language server, each with its kind, the line and column of its name, and the lastLine of its declaration",
+        requires: []
+      },
       completion: { summary: "completions at a position", requires: ["line", "character"] },
       hover: { summary: "hover text at a position", requires: ["line", "character"] }
     },
@@ -33524,13 +33661,13 @@ var TOOL_SPECS = [
   },
   {
     name: "script_diagnostics",
-    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.",
+    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. Each diagnostic carries its severity (error or warning), its message, and where it is as the editor shows it: line and column counted from 1, and endLine and endColumn just past its end. 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: {
         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.'
+        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, with clean, errors and warnings for all of them: a script with nothing to report is named in nothingReported, and every other is answered under scripts in that same shape, including a script that could not be read, named with why while the rest are still asked about. Any number of scripts is one call, which reports progress as it goes.'
       }
     },
     requires: ["projectPath", "scriptPath"]
@@ -33578,7 +33715,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: {
@@ -33733,7 +33870,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: []
   },
@@ -34517,6 +34654,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];
 }
@@ -35062,7 +35209,6 @@ 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) {
@@ -35106,12 +35252,6 @@ function scriptsToDiagnose(projectPath, given) {
   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) {
@@ -36977,11 +37117,16 @@ class GodotServer {
       return "refusal" in one ? one.refusal : this.jsonTextResponse(this.markedIfStale(one.answer));
     }
     const progress = callProgress();
-    const answers = [];
+    const cancelled = callSignal();
+    const reported = [];
+    const nothingReported = [];
     let errors = 0;
     let warnings = 0;
     let unread = 0;
     for (const [at, scriptPath] of scripts.value.entries()) {
+      if (cancelled?.aborted === true) {
+        return this.createErrorResponse(`Cancelled after ${at} of ${scripts.value.length} scripts.`);
+      }
       progress?.(at + 1, `${at + 1} of ${scripts.value.length}: ${scriptPath}`);
       const one = await this.diagnosticsOf({ ...args, scriptPath });
       if ("refusal" in one) {
@@ -36989,20 +37134,25 @@ class GodotServer {
           return one.refusal;
         }
         unread += 1;
-        answers.push({ scriptPath, error: one.refusal.content[0]?.text ?? "not read" });
+        reported.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);
+      if (readArray(one.answer, "diagnostics")?.length === 0) {
+        nothingReported.push(scriptPath);
+      } else {
+        reported.push(one.answer);
+      }
     }
     return this.jsonTextResponse(this.markedIfStale({
       clean: errors === 0 && unread === 0,
-      scriptsChecked: answers.length,
+      scriptsChecked: scripts.value.length,
       errors,
       warnings,
       ...unread > 0 ? { scriptsNotRead: unread } : {},
-      scripts: answers
+      scripts: reported,
+      nothingReported
     }));
   }
   markedIfStale(answer) {
@@ -37016,6 +37166,9 @@ class GodotServer {
       if (payload["refusedArguments"] === true) {
         return { refusal: this.createErrorResponse(reason), perScript: true };
       }
+      if (payload["stillReading"] === true) {
+        return { refusal: this.createErrorResponse(`Diagnostics unavailable: ${reason}`), perScript: false };
+      }
       if (typeof payload["serves"] === "string") {
         return {
           refusal: this.createErrorResponse(`Diagnostics unavailable: ${reason}`, [
@@ -37035,10 +37188,7 @@ class GodotServer {
       };
     }
     const diagnostics = readArray(payload, "diagnostics") ?? [];
-    const errors = diagnostics.filter((entry) => {
-      const severity = asParams(entry)["severity"];
-      return severity === 1 || severity === "error" || severity === "ERROR";
-    }).length;
+    const errors = diagnostics.filter((entry) => asParams(entry)["severity"] === "error").length;
     return {
       answer: {
         scriptPath: readString(args, "scriptPath"),
@@ -37266,14 +37416,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,
@@ -37570,6 +37722,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;
@@ -37594,6 +37754,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.50",
+  "version": "1.1.52",
   "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",