gdharness 1.1.8 → 1.1.10

package/build/cli.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-// @bun
 import { createRequire } from "node:module";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
@@ -272,6 +271,83 @@ var init_process_children = __esm(() => {
   run = promisify(execFile);
 });
 
+// src/bridge-announce.ts
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+function announcementPath(projectPath) {
+  return join(projectPath, ".godot", "gdharness-bridge.json");
+}
+function readAnnouncement(path) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    const said = parsed;
+    if (typeof said.port !== "number" || typeof said.pid !== "number") {
+      return null;
+    }
+    return said;
+  } catch {
+    return null;
+  }
+}
+function serverBehind(announcement, startedAt) {
+  if (announcement === null || typeof announcement.version !== "string" || startedAt === undefined) {
+    return null;
+  }
+  const announcedAt = Date.parse(announcement.startedAt);
+  if (Number.isNaN(announcedAt) || startedAt > announcedAt + 1000) {
+    return null;
+  }
+  return { version: announcement.version, pid: announcement.pid };
+}
+function serverServing(projectPath) {
+  const announcement = readAnnouncement(announcementPath(projectPath));
+  if (announcement === null) {
+    return null;
+  }
+  return serverBehind(announcement, startTimesOf([announcement.pid]).get(announcement.pid));
+}
+function announcementIsOurs(path) {
+  return readAnnouncement(path)?.pid === process.pid;
+}
+function announceBridge(projectPath, bridge) {
+  const path = announcementPath(projectPath);
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    const announcement = {
+      protocol: BRIDGE_ANNOUNCE_PROTOCOL,
+      host: bridge.host,
+      port: bridge.port,
+      pid: process.pid,
+      version: bridge.version,
+      startedAt: new Date().toISOString()
+    };
+    writeFileSync(path, `${JSON.stringify(announcement, null, 2)}
+`, "utf8");
+    return path;
+  } catch (error) {
+    console.error(`[SERVER] Could not announce the editor bridge at ${path}: ${errorMessage(error)}`);
+    return null;
+  }
+}
+function withdrawBridge(path) {
+  if (path === null || !announcementIsOurs(path)) {
+    return;
+  }
+  try {
+    rmSync(path, { force: true });
+  } catch (error) {
+    console.error(`[SERVER] Could not withdraw the editor bridge announcement: ${errorMessage(error)}`);
+  }
+}
+var BRIDGE_ANNOUNCE_PROTOCOL = 1;
+var init_bridge_announce = __esm(() => {
+  init_errors();
+  init_process_children();
+});
+
 // src/detection.ts
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
@@ -421,6 +497,84 @@ function environmentFor(options, variables = process.env) {
 }
 var OPENED_BY_A_SERVER = "GDHARNESS_OPENED_BY_A_SERVER", RESERVED_VARIABLE_PREFIX = "GDHARNESS_", SAVES_NOT_MOVED_NOTE = "On macOS the engine reads user:// off HOME and ignores the variables that move it elsewhere, measured on Godot 4.7.2, so this run wrote its saves where the player keeps theirs. A suite that saves a game has written into the same folder as the copy being played, and one that tidies up after itself may have removed real saves.";
 
+// src/godot-path.ts
+import { execFile as execFile2 } from "node:child_process";
+import { existsSync as existsSync2 } from "node:fs";
+import { normalize } from "node:path";
+import { promisify as promisify2 } from "node:util";
+
+class GodotLocator {
+  answered = new Map;
+  found = null;
+  async find() {
+    if (this.found !== null && await this.whyNot(this.found) === null) {
+      return { ok: true, path: this.found };
+    }
+    this.found = null;
+    const named = envValue("GODOT_PATH");
+    if (named !== undefined) {
+      const path = normalize(named);
+      const reason = await this.whyNot(path);
+      if (reason === null) {
+        this.found = path;
+        return { ok: true, path };
+      }
+      return { ok: false, named: path, reason };
+    }
+    for (const candidate of godotCandidates(process.platform, resolveHomeDirectory())) {
+      const path = normalize(candidate);
+      if (await this.whyNot(path) === null) {
+        this.found = path;
+        return { ok: true, path };
+      }
+    }
+    return { ok: false, named: null };
+  }
+  static refusal(located) {
+    if (located.named === null) {
+      return {
+        message: "No Godot executable found.",
+        advice: [
+          "Set GODOT_PATH to the Godot 4 executable",
+          "Or install Godot where it is usually found, such as /usr/bin/godot or C:\\Program Files\\Godot"
+        ]
+      };
+    }
+    return {
+      message: `GODOT_PATH is set to ${located.named}, which ${located.reason ?? "does not answer"}.`,
+      advice: [
+        "Point GODOT_PATH at a Godot 4 executable that answers --version",
+        "Or unset it, and the usual install locations are searched instead"
+      ]
+    };
+  }
+  async whyNot(path) {
+    const known = this.answered.get(path);
+    if (known !== undefined) {
+      return known;
+    }
+    let reason;
+    if (path !== "godot" && !existsSync2(path)) {
+      reason = "does not exist";
+    } else {
+      try {
+        await run2(path, ["--version"]);
+        reason = null;
+      } catch (error) {
+        reason = `does not answer --version: ${errorMessage(error)}`;
+      }
+    }
+    this.answered.set(path, reason);
+    return reason;
+  }
+}
+var run2;
+var init_godot_path = __esm(() => {
+  init_detection();
+  init_errors();
+  run2 = promisify2(execFile2);
+});
+
 // node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS(function(exports) {
   var ALIAS = Symbol.for("yaml.alias");
@@ -7502,19 +7656,21 @@ class GameLog {
         this.seen[severity] = this.entries.length;
       }
     }
-    const matching = this.entries.slice(floor).filter((entry) => {
-      if (!wanted.has(entry.severity)) {
-        return false;
-      }
-      if (needle === undefined) {
-        return true;
-      }
-      return [entry.text, ...entry.detail].some((line) => line.toLowerCase().includes(needle));
-    });
+    const matching = this.entries.slice(floor).filter((entry) => answersTo(entry, options.severity, options.contains));
     const omitted = Math.max(0, matching.length - options.limit);
     return { entries: matching.slice(omitted), omitted };
   }
 }
+function answersTo(entry, severity, contains) {
+  if (!ADMITTED[severity].has(entry.severity)) {
+    return false;
+  }
+  if (contains === undefined) {
+    return true;
+  }
+  const needle = contains.toLowerCase();
+  return [entry.text, ...entry.detail].some((line) => line.toLowerCase().includes(needle));
+}
 var HEADLINE, COLOUR_CODE, STREAMS, ADMITTED;
 var init_game_log = __esm(() => {
   HEADLINE = /^(USER )?(SCRIPT ERROR|SHADER ERROR|ERROR|WARNING):\s?(.*)$/;
@@ -7553,6 +7709,127 @@ var init_scratch = __esm(() => {
   SWEPT = { recursive: true, force: true, maxRetries: 20, retryDelay: 250 };
 });
 
+// src/headless.ts
+import { execFile as execFile3 } from "node:child_process";
+import { mkdtempSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join5 } from "node:path";
+import { promisify as promisify3 } from "node:util";
+function snakeCased(params) {
+  const result = emptyRecord();
+  for (const [key, value] of Object.entries(params)) {
+    const name = key.startsWith("_") ? key : key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+    result[name] = value;
+  }
+  return result;
+}
+function lastJsonObject(stdout) {
+  const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.startsWith("{"));
+  for (const line of lines.reverse()) {
+    try {
+      const parsed = JSON.parse(line);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {}
+  }
+  return null;
+}
+function problems(stderr) {
+  const log = new GameLog;
+  log.append("stderr", stderr);
+  log.finish();
+  return log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries;
+}
+function reason(stdout, stderr) {
+  const own = stderr.split(/\r?\n/).filter((line) => line.startsWith("[ERROR] ")).map((line) => line.slice("[ERROR] ".length));
+  if (own.length > 0) {
+    return own.join("; ");
+  }
+  const engine = problems(stderr).filter((entry) => entry.severity === "error").map((entry) => entry.text);
+  if (engine.length > 0) {
+    return engine.join("; ");
+  }
+  return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
+}
+async function runImport(godotPath, projectPath) {
+  const logDir = mkdtempSync(join5(tmpdir(), "gdharness-import-"));
+  try {
+    const { stderr } = await run3(godotPath, ["--headless", "--log-file", join5(logDir, "engine.log"), "--path", projectPath, "--import"], { signal: callSignal() });
+    return { ok: true, messages: problems(stderr) };
+  } catch (error) {
+    if (error instanceof Error && "stdout" in error && "stderr" in error) {
+      const failed = error;
+      return {
+        ok: false,
+        message: `the import pass failed (exit ${failed.code ?? "unknown"}): ${reason(failed.stdout, failed.stderr)}`,
+        messages: problems(failed.stderr)
+      };
+    }
+    return {
+      ok: false,
+      message: `the import pass could not be run: ${error instanceof Error ? error.message : String(error)}`,
+      messages: []
+    };
+  } finally {
+    discard(logDir);
+  }
+}
+async function runOperation(engine, operation, params, projectPath) {
+  const paramsDir = mkdtempSync(join5(tmpdir(), "gdharness-params-"));
+  const paramsFile = join5(paramsDir, `${operation}.json`);
+  writeFileSync3(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
+  const args = [
+    "--headless",
+    "--log-file",
+    join5(paramsDir, "engine.log"),
+    "--path",
+    projectPath,
+    "--script",
+    engine.script,
+    operation,
+    `@file:${paramsFile}`,
+    ...engine.debug ? ["--debug-godot"] : []
+  ];
+  let stdout;
+  let stderr;
+  try {
+    ({ stdout, stderr } = await run3(engine.godotPath, args, { signal: callSignal() }));
+  } catch (error) {
+    if (error instanceof Error && "stdout" in error && "stderr" in error) {
+      const failed = error;
+      return {
+        ok: false,
+        message: `${operation} failed (exit ${failed.code ?? "unknown"}): ${reason(failed.stdout, failed.stderr)}`,
+        messages: problems(failed.stderr)
+      };
+    }
+    return {
+      ok: false,
+      message: `${operation} could not be run: ${error instanceof Error ? error.message : String(error)}`,
+      messages: []
+    };
+  } finally {
+    discard(paramsDir);
+  }
+  const payload = lastJsonObject(stdout);
+  if (payload === null) {
+    return {
+      ok: false,
+      message: `${operation} produced no result: ${reason(stdout, stderr)}`,
+      messages: problems(stderr)
+    };
+  }
+  return { ok: true, payload, messages: problems(stderr) };
+}
+var run3;
+var init_headless = __esm(() => {
+  init_call_signal();
+  init_game_log();
+  init_scratch();
+  run3 = promisify3(execFile3);
+});
+
 // src/update-check.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
@@ -7797,8 +8074,132 @@ var init_server_version = __esm(() => {
   })();
 });
 
+// src/issues.ts
+import { createHash } from "node:crypto";
+import process4 from "node:process";
+function feedbackNotice() {
+  return JSON.stringify({
+    gdharness_feedback: {
+      what_to_do: "If this session has run into something gdharness cannot do, or a tool that should " + "exist and does not, tell the user what is missing and offer to open an enhancement " + "issue for them. Only if they say yes, and only for a real gap: a call you got wrong " + "is not one. If you cannot open an issue yourself, give them the link and what to " + "write in it.",
+      enhancement_url: ENHANCEMENT_URL
+    }
+  }, null, 2);
+}
+function runtime() {
+  const versions = process4.versions;
+  const bun = versions["bun"];
+  return bun === undefined ? `node ${process4.versions.node}` : `bun ${bun}`;
+}
+function defectSignature(where, message) {
+  const normalised = `${where}
+${message}`.toLowerCase().replaceAll("\\", "/").replaceAll(/(?:[a-z]:)?(?:\/+[\w.-]+){2,}/gu, "<path>").replaceAll(/\d+/gu, "0");
+  return createHash("sha256").update(normalised).digest("hex").slice(0, 8);
+}
+function facts(where, message, godotVersion) {
+  return [
+    ["Where", where],
+    ["Error", message],
+    ["Version", `gdharness ${SERVER_VERSION}`],
+    ["Runtime", `${runtime()}, ${process4.platform} ${process4.arch}`],
+    ["Godot", godotVersion ?? "not known at the point this failed"],
+    ["Signature", defectSignature(where, message)]
+  ];
+}
+function filledTemplate(where, message, godotVersion) {
+  return [
+    `**gdharness version**: ${SERVER_VERSION}`,
+    `**Godot version**: ${godotVersion ?? ""}`,
+    `**Bun version**: ${runtime()}`,
+    `**OS**: ${process4.platform} ${process4.arch}`,
+    "**MCP client**:",
+    "",
+    "## What you did",
+    "",
+    where,
+    "",
+    "## What you expected",
+    "",
+    "The call to answer, or to refuse with a reason.",
+    "",
+    "## What happened",
+    "",
+    "gdharness failed in a way it does not model.",
+    "",
+    "```text",
+    message,
+    "```",
+    "",
+    `Signature: \`${defectSignature(where, message)}\``,
+    "",
+    "If the real cause turned out to be the project, the environment or the call, say so here:",
+    "reaching you as a defect rather than as a refusal naming what would have worked is then the",
+    "thing to fix.",
+    "",
+    "## Anything that makes it reproducible",
+    ""
+  ].join(`
+`);
+}
+
+class DefectsSeen {
+  counts = new Map;
+  before(where, message) {
+    const signature = defectSignature(where, message);
+    const seen = this.counts.get(signature) ?? 0;
+    this.counts.set(signature, seen + 1);
+    return seen;
+  }
+}
+function defectReport(where, error, context = {}) {
+  const { godotVersion, seenBefore = 0 } = context;
+  const message = errorMessage(error);
+  const title = `Defect ${defectSignature(where, message)}: ${where}`;
+  const url = `${NEW_ISSUE}?template=bug_report.md&title=${encodeURIComponent(title)}` + `&body=${encodeURIComponent(filledTemplate(where, message, godotVersion))}`;
+  const width = Math.max(...facts(where, message, godotVersion).map(([label]) => (label ?? "").length));
+  return [
+    "gdharness failed in a way it does not model. Whatever went wrong underneath, it reached you",
+    "as a crash rather than as a refusal naming what would have worked, and that much is a defect",
+    "in gdharness however the rest of it turns out.",
+    "",
+    ...seenBefore === 0 ? [
+      "Send the call once more before anything else. Some of what reaches this line is a file",
+      "another process had open, or a connection that dropped, and those are gone by the next",
+      "attempt. If the same Signature comes back, it is not one of those, and repeating it",
+      "further only spends turns."
+    ] : [
+      `You have had this exact failure ${seenBefore === 1 ? "once" : `${seenBefore} times`} in this session already, so it is a`,
+      "state rather than a passing one, and sending the call again will not change it."
+    ],
+    "",
+    ...facts(where, message, godotVersion).map(([label, value]) => `  ${(label ?? "").padEnd(width)}  ${value ?? ""}`),
+    "",
+    "Do not open an issue on your own initiative. Tell the person whose machine this is what",
+    "broke, and ask whether you may report it to gdharness on their behalf. What the report",
+    "carries is the lines above and nothing else, and whether that goes into a public tracker",
+    "is theirs to decide.",
+    "",
+    "If they say yes, this link carries the report already filled in:",
+    url,
+    "",
+    "If they say yes and you have no way to open an issue yourself, give them that link and",
+    "those lines, and stay with them while they file it.",
+    "",
+    "Worth reporting either way. If you can see that what actually went wrong was the project,",
+    "the environment or the call, then this message is the defect: a failure gdharness knows",
+    "about is meant to arrive as a refusal naming what would have worked, not as this. Say that",
+    "in the report and it is the more useful of the two."
+  ].join(`
+`);
+}
+var NEW_ISSUE = "https://github.com/Aureliolo/gdharness/issues/new", ENHANCEMENT_URL;
+var init_issues = __esm(() => {
+  init_errors();
+  init_server_version();
+  ENHANCEMENT_URL = `${NEW_ISSUE}?template=feature_request.md`;
+});
+
 // src/class-cache.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync6, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync2 } from "node:fs";
 import { join as join7 } from "node:path";
 function declaredClasses(projectPath) {
   const declared = new Map;
@@ -7814,7 +8215,7 @@ function declaredClasses(projectPath) {
       if (entry.isDirectory()) {
         visit(path, `${prefix}${entry.name}/`);
       } else if (entry.isFile() && entry.name.endsWith(".gd")) {
-        const found = DECLARATION.exec(readFileSync6(path, "utf8"));
+        const found = DECLARATION.exec(readFileSync5(path, "utf8"));
         if (found?.[1]) {
           declared.set(found[1], `res://${prefix}${entry.name}`);
         }
@@ -7830,7 +8231,7 @@ function cachedClasses(projectPath) {
     return null;
   }
   const listed = new Map;
-  const text = readFileSync6(cache, "utf8");
+  const text = readFileSync5(cache, "utf8");
   for (const entry of text.matchAll(/"class":\s*&"([^"]+)"[\s\S]*?"path":\s*"([^"]+)"/g)) {
     listed.set(entry[1] ?? "", entry[2] ?? "");
   }
@@ -7982,127 +8383,6 @@ var init_class_cache = __esm(() => {
   DECLARATION = /^(?:@[a-z_]+(?:\([^)\n]*\))?\s+)*class_name\s+([A-Za-z_][A-Za-z0-9_]*)/m;
 });
 
-// src/headless.ts
-import { execFile as execFile4 } from "node:child_process";
-import { mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync5 } from "node:fs";
-import { tmpdir as tmpdir3 } from "node:os";
-import { join as join8 } from "node:path";
-import { promisify as promisify4 } from "node:util";
-function snakeCased2(params) {
-  const result = emptyRecord();
-  for (const [key, value] of Object.entries(params)) {
-    const name = key.startsWith("_") ? key : key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-    result[name] = value;
-  }
-  return result;
-}
-function lastJsonObject2(stdout) {
-  const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.startsWith("{"));
-  for (const line of lines.reverse()) {
-    try {
-      const parsed = JSON.parse(line);
-      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
-        return parsed;
-      }
-    } catch {}
-  }
-  return null;
-}
-function problems2(stderr) {
-  const log = new GameLog;
-  log.append("stderr", stderr);
-  log.finish();
-  return log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries;
-}
-function reason2(stdout, stderr) {
-  const own = stderr.split(/\r?\n/).filter((line) => line.startsWith("[ERROR] ")).map((line) => line.slice("[ERROR] ".length));
-  if (own.length > 0) {
-    return own.join("; ");
-  }
-  const engine = problems2(stderr).filter((entry) => entry.severity === "error").map((entry) => entry.text);
-  if (engine.length > 0) {
-    return engine.join("; ");
-  }
-  return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
-}
-async function runImport(godotPath, projectPath) {
-  const logDir = mkdtempSync2(join8(tmpdir3(), "gdharness-import-"));
-  try {
-    const { stderr } = await run4(godotPath, ["--headless", "--log-file", join8(logDir, "engine.log"), "--path", projectPath, "--import"], { signal: callSignal() });
-    return { ok: true, messages: problems2(stderr) };
-  } catch (error) {
-    if (error instanceof Error && "stdout" in error && "stderr" in error) {
-      const failed = error;
-      return {
-        ok: false,
-        message: `the import pass failed (exit ${failed.code ?? "unknown"}): ${reason2(failed.stdout, failed.stderr)}`,
-        messages: problems2(failed.stderr)
-      };
-    }
-    return {
-      ok: false,
-      message: `the import pass could not be run: ${error instanceof Error ? error.message : String(error)}`,
-      messages: []
-    };
-  } finally {
-    discard(logDir);
-  }
-}
-async function runOperation2(engine, operation, params, projectPath) {
-  const paramsDir = mkdtempSync2(join8(tmpdir3(), "gdharness-params-"));
-  const paramsFile = join8(paramsDir, `${operation}.json`);
-  writeFileSync5(paramsFile, JSON.stringify(snakeCased2(params)), "utf8");
-  const args = [
-    "--headless",
-    "--log-file",
-    join8(paramsDir, "engine.log"),
-    "--path",
-    projectPath,
-    "--script",
-    engine.script,
-    operation,
-    `@file:${paramsFile}`,
-    ...engine.debug ? ["--debug-godot"] : []
-  ];
-  let stdout;
-  let stderr;
-  try {
-    ({ stdout, stderr } = await run4(engine.godotPath, args, { signal: callSignal() }));
-  } catch (error) {
-    if (error instanceof Error && "stdout" in error && "stderr" in error) {
-      const failed = error;
-      return {
-        ok: false,
-        message: `${operation} failed (exit ${failed.code ?? "unknown"}): ${reason2(failed.stdout, failed.stderr)}`,
-        messages: problems2(failed.stderr)
-      };
-    }
-    return {
-      ok: false,
-      message: `${operation} could not be run: ${error instanceof Error ? error.message : String(error)}`,
-      messages: []
-    };
-  } finally {
-    discard(paramsDir);
-  }
-  const payload = lastJsonObject2(stdout);
-  if (payload === null) {
-    return {
-      ok: false,
-      message: `${operation} produced no result: ${reason2(stdout, stderr)}`,
-      messages: problems2(stderr)
-    };
-  }
-  return { ok: true, payload, messages: problems2(stderr) };
-}
-var run4;
-var init_headless = __esm(() => {
-  init_call_signal();
-  init_game_log();
-  init_scratch();
-  run4 = promisify4(execFile4);
-});
-
 // node_modules/zod/v4/core/util.js
 function getEnumValues(entries) {
   const numericValues = Object.values(entries).filter((v) => typeof v === "number");
@@ -15268,7 +15548,7 @@ var init_paths = __esm(() => {
 });
 
 // src/resources.ts
-import { readFileSync as readFileSync7 } from "node:fs";
+import { readFileSync as readFileSync6 } from "node:fs";
 import { extname, resolve as resolve2 } from "node:path";
 function ensureProjectPath(getProjectPath) {
   const projectPath = getProjectPath();
@@ -15434,7 +15714,7 @@ function readResourceText(uri, getProjectPath) {
   const parsedUri = parseGodotUri(uri);
   if (parsedUri.kind === "project-info") {
     const projectFilePath = resolveProjectFile(projectPath, "project.godot");
-    const rawProject = readFileSync7(projectFilePath, "utf-8");
+    const rawProject = readFileSync6(projectFilePath, "utf-8");
     const parsedProject = parseProjectGodot(rawProject);
     return {
       mimeType: "application/json",
@@ -15443,7 +15723,7 @@ function readResourceText(uri, getProjectPath) {
   }
   const filePath = resolveProjectFile(projectPath, parsedUri.resourcePath);
   ensureAllowedExtension(parsedUri.kind, filePath);
-  const text = readFileSync7(filePath, "utf-8");
+  const text = readFileSync6(filePath, "utf-8");
   return {
     mimeType: parsedUri.kind === "script" ? "text/x-gdscript" : "text/plain",
     text
@@ -15571,74 +15851,250 @@ function readParams(params, key) {
 }
 
 // src/setup.ts
-import { createHash as createHash3 } from "node:crypto";
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
 import {
-  cpSync as cpSync2,
-  existsSync as existsSync8,
-  mkdirSync as mkdirSync5,
-  readdirSync as readdirSync4,
-  readFileSync as readFileSync9,
-  rmSync as rmSync5,
-  statSync as statSync4,
-  writeFileSync as writeFileSync7
+  cpSync,
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync4,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync7,
+  rmdirSync,
+  rmSync as rmSync4,
+  statSync as statSync3,
+  writeFileSync as writeFileSync5
 } from "node:fs";
-import { dirname as dirname5, join as join10 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-function editorAddonDigest2(from = shippedAddonsDirectory2()) {
-  const hash = createHash3("sha256");
+import { dirname as dirname4, join as join8 } from "node:path";
+import { fileURLToPath } from "node:url";
+function editorAddonDigest(from = shippedAddonsDirectory()) {
+  const hash = createHash2("sha256");
   const walk = (directory, relative) => {
-    for (const name of readdirSync4(directory).sort()) {
-      if (name === VERSION_MARKER2 || name === DIGEST_MARKER2) {
+    for (const name of readdirSync3(directory).sort()) {
+      if (name === VERSION_MARKER || name === DIGEST_MARKER) {
         continue;
       }
-      const path = join10(directory, name);
+      const path = join8(directory, name);
       const inside = `${relative}/${name}`;
-      if (statSync4(path).isDirectory()) {
+      if (statSync3(path).isDirectory()) {
         walk(path, inside);
       } else {
         hash.update(`${inside}
 `);
-        hash.update(readFileSync9(path));
+        hash.update(readFileSync7(path));
         hash.update(`
 `);
       }
     }
   };
-  for (const name of EDITOR_PLUGINS2) {
-    walk(join10(from, name), name);
+  for (const name of EDITOR_PLUGINS) {
+    walk(join8(from, name), name);
   }
   return hash.digest("hex");
 }
 function shippedEditorDigest() {
   if (shippedDigest === undefined) {
     try {
-      shippedDigest = editorAddonDigest2();
+      shippedDigest = editorAddonDigest();
     } catch {
       shippedDigest = null;
     }
   }
   return shippedDigest ?? undefined;
 }
-function shippedAddonsDirectory2() {
-  return join10(dirname5(fileURLToPath2(import.meta.url)), "godot", "addons");
+function installedEditorDigest(projectPath) {
+  const marker = join8(projectPath, "addons", ADDONS[0], DIGEST_MARKER);
+  if (!existsSync7(marker)) {
+    return null;
+  }
+  const said = readFileSync7(marker, "utf8").trim();
+  return said === "" ? null : said;
+}
+function shippedAddonsDirectory() {
+  return join8(dirname4(fileURLToPath(import.meta.url)), "godot", "addons");
+}
+function shippedOperationsScript() {
+  return join8(dirname4(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
+}
+function installAddons(projectPath, from = shippedAddonsDirectory()) {
+  const installed = [];
+  for (const name of ADDONS) {
+    const source = join8(from, name);
+    if (!existsSync7(join8(source, name === "gdharness_runtime" ? "runtime_autoload.gd" : "plugin.cfg"))) {
+      throw new Error(`The package holds no ${name} addon at ${source}.`);
+    }
+    const target = join8(projectPath, "addons", name);
+    const replaced = existsSync7(target);
+    rmSync4(target, { recursive: true, force: true });
+    mkdirSync4(dirname4(target), { recursive: true });
+    cpSync(source, target, { recursive: true });
+    writeFileSync5(join8(target, VERSION_MARKER), `${SERVER_VERSION}
+`);
+    installed.push({ name, path: target, replaced });
+  }
+  writeFileSync5(join8(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
+`);
+  return installed;
 }
 function installedAddonVersion(projectPath) {
-  const marker = join10(projectPath, "addons", ADDONS2[0], VERSION_MARKER2);
-  if (!existsSync8(marker)) {
+  const marker = join8(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  if (!existsSync7(marker)) {
     return null;
   }
-  const said = readFileSync9(marker, "utf8").trim();
+  const said = readFileSync7(marker, "utf8").trim();
   return said === "" ? null : said;
 }
-var ADDONS2, EDITOR_PLUGINS2, RUNTIME_AUTOLOAD2, SCRIPT_RUNS_SETTING = "gdharness/runtime/serve_script_runs", BIND_ADDRESS_SETTING = "gdharness/runtime/bind_address", PORT_SETTING = "gdharness/runtime/port", VERSION_MARKER2 = ".gdharness-version", DIGEST_MARKER2 = ".gdharness-digest", shippedDigest;
+function removeAddons(projectPath) {
+  const removed = [];
+  for (const name of ADDONS) {
+    const target = join8(projectPath, "addons", name);
+    if (existsSync7(target)) {
+      rmSync4(target, { recursive: true, force: true });
+      removed.push(target);
+    }
+  }
+  const addons = join8(projectPath, "addons");
+  if (removed.length > 0 && existsSync7(addons) && readdirSync3(addons).length === 0) {
+    rmdirSync(addons);
+    removed.push(addons);
+  }
+  return removed;
+}
+async function disablePlugins(engine, projectPath, names) {
+  const outcomes = [];
+  for (const name of names) {
+    outcomes.push(await runOperation(engine, "disable_plugin", { pluginName: name }, projectPath));
+  }
+  return outcomes;
+}
+async function enablePlugins(engine, projectPath, names) {
+  const outcomes = [];
+  for (const name of names) {
+    outcomes.push(await runOperation(engine, "enable_plugin", { pluginName: name }, projectPath));
+  }
+  return outcomes;
+}
+function autoloadIsOurs(named) {
+  return named === null || named === `res://${RUNTIME_AUTOLOAD.path}`;
+}
+async function setRuntime(engine, projectPath, on) {
+  return on ? await runOperation(engine, "add_autoload", { name: RUNTIME_AUTOLOAD.name, path: `res://${RUNTIME_AUTOLOAD.path}`, enabled: true }, projectPath) : await runOperation(engine, "remove_autoload", { name: RUNTIME_AUTOLOAD.name }, projectPath);
+}
+function loaderAmong(projectPath, named) {
+  let byName = null;
+  for (const [entry, path] of named) {
+    if (entry === RUNTIME_AUTOLOAD.name || path === RUNTIME_AUTOLOAD.path) {
+      continue;
+    }
+    let source = null;
+    try {
+      source = readFileSync7(join8(projectPath, path), "utf8");
+    } catch {}
+    if (source?.includes(RUNTIME_AUTOLOAD.path)) {
+      return { name: entry, path, exists: true };
+    }
+    byName ??= path.toLowerCase().includes("gdharness") ? { name: entry, path, exists: source !== null } : null;
+  }
+  return byName;
+}
+function autoloadPaths(settings) {
+  const named = new Map;
+  for (const [name, value] of Object.entries(settings["autoload"] ?? {})) {
+    const said = typeof value === "string" ? value.replace(/^\*/, "") : "";
+    if (said.startsWith("res://")) {
+      named.set(name, said.slice("res://".length));
+    }
+  }
+  return named;
+}
+function trackedByGit(projectPath, wanted) {
+  if (wanted.length === 0) {
+    return new Set;
+  }
+  const asked = spawnSync2("git", ["ls-files", "-z", "--", ...wanted], {
+    cwd: projectPath,
+    encoding: "utf8"
+  });
+  if (asked.status !== 0) {
+    return null;
+  }
+  return new Set(asked.stdout.split("\x00").filter(Boolean));
+}
+function enabledPlugins(settings) {
+  const raw = settings["editor_plugins"]?.["enabled"];
+  if (typeof raw !== "string") {
+    return [];
+  }
+  return [...raw.matchAll(/res:\/\/addons\/([^/"]+)\/plugin\.cfg/g)].map((match) => match[1] ?? "").filter(Boolean);
+}
+function inspectProject(projectPath) {
+  const problems = [];
+  const addons = ADDONS.map((name) => {
+    const directory = join8(projectPath, "addons", name);
+    const marker = join8(directory, VERSION_MARKER);
+    const installed = existsSync7(directory);
+    const version = existsSync7(marker) ? readFileSync7(marker, "utf8").trim() : null;
+    const current = version === SERVER_VERSION;
+    if (!installed) {
+      problems.push(`addons/${name} is not installed; run gdharness setup`);
+    } else if (!current) {
+      problems.push(`addons/${name} is ${version ?? "of an unknown version"}, this gdharness is ${SERVER_VERSION}; run gdharness setup`);
+    }
+    return { name, installed, version, current };
+  });
+  const settings = parseProjectGodot(readFileSync7(join8(projectPath, "project.godot"), "utf8"));
+  const pluginsEnabled = enabledPlugins(settings);
+  for (const name of EDITOR_PLUGINS) {
+    if (!pluginsEnabled.includes(name)) {
+      problems.push(`the ${name} plugin is not enabled in project.godot; run gdharness setup`);
+    }
+  }
+  const autoload = settings["autoload"];
+  const registered = autoload === undefined ? undefined : readString(autoload, RUNTIME_AUTOLOAD.name);
+  const runtimeAutoloadPath = typeof registered === "string" ? registered.replace(/^\*/, "") : null;
+  const named = autoloadPaths(settings);
+  const runtimeLoaderAutoload = loaderAmong(projectPath, named);
+  const runtimeAutoload = runtimeAutoloadPath !== null || runtimeLoaderAutoload !== null;
+  const tracked = trackedByGit(projectPath, [...named.values()]);
+  const addonMissing = (path) => addons.some((addon) => !addon.installed && path.startsWith(`addons/${addon.name}/`));
+  for (const [name, path] of named) {
+    if (!existsSync7(join8(projectPath, path))) {
+      if (!addonMissing(path)) {
+        problems.push(`the ${name} autoload names res://${path}, which is not in this project, so it boots with a missing script; restore that file, or point the autoload at one that is here`);
+      }
+      continue;
+    }
+    if (tracked !== null && !tracked.has(path)) {
+      problems.push(`the ${name} autoload names res://${path}, which git does not carry, so a clone boots with a missing script; commit that file, or point the autoload at one the project tracks`);
+    }
+  }
+  const cached = cachedClasses(projectPath);
+  const staleClasses = cached === null ? [] : staleAgainst(cached, projectPath);
+  if (cached === null) {
+    problems.push("no .godot/global_script_class_cache.cfg: the engine knows no class_name; run project_import refresh_classes or open the editor");
+  } else if (staleClasses.length > 0) {
+    problems.push(`the class cache does not list ${staleClasses.join(", ")}; run project_import refresh_classes or gdharness classes`);
+  }
+  return {
+    projectPath,
+    addons,
+    pluginsEnabled,
+    runtimeAutoload,
+    runtimeAutoloadPath,
+    runtimeLoaderAutoload,
+    staleClasses,
+    classCacheExists: cached !== null,
+    problems
+  };
+}
+var ADDONS, EDITOR_PLUGINS, RUNTIME_AUTOLOAD, SCRIPT_RUNS_SETTING = "gdharness/runtime/serve_script_runs", BIND_ADDRESS_SETTING = "gdharness/runtime/bind_address", PORT_SETTING = "gdharness/runtime/port", VERSION_MARKER = ".gdharness-version", DIGEST_MARKER = ".gdharness-digest", shippedDigest;
 var init_setup = __esm(() => {
   init_class_cache();
   init_headless();
   init_resources();
   init_server_version();
-  ADDONS2 = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
-  EDITOR_PLUGINS2 = ["gdharness_editor", "auto_reload"];
-  RUNTIME_AUTOLOAD2 = {
+  ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
+  EDITOR_PLUGINS = ["gdharness_editor", "auto_reload"];
+  RUNTIME_AUTOLOAD = {
     name: "GdharnessRuntime",
     path: "addons/gdharness_runtime/runtime_autoload.gd"
   };
@@ -16088,6 +16544,10 @@ var init_tool_definitions = __esm(() => {
           type: "integer",
           minimum: 1,
           description: "How long the run may take before it is killed. Default 600000. A run killed at the limit answers timedOut and silentForMs, how long it had printed nothing; it is called hung only when that was half the limit, or thirty seconds of a longer one, and otherwise it was still running and wants a longer timeoutMs or a narrower path."
+        },
+        printed: {
+          type: "string",
+          description: "Also answer with every line the run printed that contains this, under printed, whether it passed or not: a suite that prints a marker beside the numbers it measured carries them back without failing an assertion to do it. Matched case aside, in the text and the backtrace, at most 200 lines, the newest kept; printedOmitted counts the rest."
         }
       },
       requires: ["projectPath"]
@@ -16737,14 +17197,19 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "runtime_input",
-      description: "Input to the running game: a whole click on a Control or a 3D node named by path, an item chosen out of a menu, typing into whatever has the focus, or a raw action, key, mouse button or mouse motion. All of it works headless, where the window is 64 by 64 and the GUI only takes what is inside it.",
+      description: "Input to the running game: a whole click on a Control or a 3D node named by path or on a control named by the words on it, an item chosen out of a menu, typing into whatever has the focus, or a raw action, key, mouse button or mouse motion. All of it works headless, where the window is 64 by 64 and the GUI only takes what is inside it.",
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         pid: RUNNING_PID,
         nodePath: {
           type: "string",
           ops: ["click", "choose"],
-          description: "click: the Control to click, at its centre, or the 3D node to click, where it is drawn. choose: the PopupMenu, or the OptionButton or MenuButton in front of one."
+          description: "click: the Control to click, at its centre, or the 3D node to click, where it is drawn; with says, where to look for the control instead, default the whole tree. choose: the PopupMenu, or the OptionButton or MenuButton in front of one."
+        },
+        says: {
+          type: "string",
+          ops: ["click"],
+          description: "click: the words on the control to click, matched the way runtime_inspect find matches says (a plain word is contained in the text, a pattern with * or ? is a glob over it), among the controls on screen, and pressed in the same frame it was found in, so a panel rebuilding between a find and a click cannot free it first. Words on a label inside a button press the button. Several matches are refused with each one listed, and index picks one."
         },
         action: {
           type: "string",
@@ -16781,8 +17246,8 @@ var init_tool_definitions = __esm(() => {
         },
         index: {
           type: "number",
-          ops: ["choose"],
-          description: "choose: the item to take, by where it is in the list, when text will not do."
+          ops: ["click", "choose"],
+          description: "click: which of several controls saying the words, counting from 0 in the order a refusal lists them. choose: the item to take, by where it is in the list, when text will not do."
         },
         shift: { type: "boolean", ops: ["key"], description: "key: hold Shift with it. Default false." },
         ctrl: { type: "boolean", ops: ["key"], description: "key: hold Ctrl with it. Default false." },
@@ -16821,8 +17286,8 @@ var init_tool_definitions = __esm(() => {
       requires: [],
       operations: {
         click: {
-          summary: "press and release on a Control, a frame apart, and answer with what was under the pointer and what became of the control: in_tree, removed or freed. A control out of sight inside a ScrollContainer is scrolled to first, and scrolled_into_view says whether the view moved. A 3D node is clicked where it is drawn, and landed then says the interface did not swallow the press",
-          requires: ["nodePath"]
+          summary: "press and release on a Control, a frame apart, and answer with what was under the pointer and what became of the control: in_tree, removed or freed. The control is named by nodePath, or by says with the words on it, found under nodePath when both are given, and the answer then says under found which match it was. A control out of sight inside a ScrollContainer is scrolled to first, and scrolled_into_view says whether the view moved. A 3D node is clicked where it is drawn, and landed then says the interface did not swallow the press",
+          requires: []
         },
         choose: {
           summary: "take an item out of a menu, by what it says or by where it is in the list. A menu's items are drawn rather than built, so there is nothing to click: the item takes the focus and Enter presses it, which is the engine's own path and needs no window. Answers with what was chosen and what the button in front of it shows now",
@@ -31702,10 +32167,10 @@ var init_stdio2 = __esm(() => {
 });
 
 // src/runtime-client.ts
-import { existsSync as existsSync10, readdirSync as readdirSync6, readFileSync as readFileSync11, statSync as statSync5, unlinkSync } from "node:fs";
+import { existsSync as existsSync9, readdirSync as readdirSync5, readFileSync as readFileSync9, statSync as statSync4, unlinkSync } from "node:fs";
 import { createConnection } from "node:net";
-import { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname8, join as join13, resolve as resolve3 } from "node:path";
+import { tmpdir as tmpdir3 } from "node:os";
+import { dirname as dirname7, join as join11, resolve as resolve3 } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 function runtimeDirectory(variables = process.env) {
   const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
@@ -31713,20 +32178,20 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join13(perUser ?? tmpdir4(), "gdharness");
+  return join11(perUser ?? tmpdir3(), "gdharness");
 }
 function runtimeDirectories(variables = process.env) {
   const candidates = [runtimeDirectory(variables)];
   const fallbacks = process.platform === "win32" ? [envValue("SystemRoot", variables) ?? envValue("windir", variables) ?? "C:\\Windows"] : ["/tmp", "/var/tmp"];
   for (const base of fallbacks) {
-    candidates.push(join13(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+    candidates.push(join11(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
   return [...new Set(candidates.map((path) => resolve3(path)))];
 }
 function errorReportOf(pid, directories = runtimeDirectories()) {
   for (const directory of directories) {
-    const path = join13(directory, `runtime-${pid}.log`);
-    if (existsSync10(path)) {
+    const path = join11(directory, `runtime-${pid}.log`);
+    if (existsSync9(path)) {
       return path;
     }
   }
@@ -31743,7 +32208,7 @@ function processAlive(pid) {
 function parseAnnouncement(file, pid) {
   let fields;
   try {
-    fields = asParams(JSON.parse(readFileSync11(file, "utf8")));
+    fields = asParams(JSON.parse(readFileSync9(file, "utf8")));
   } catch {
     return { kind: "rubbish" };
   }
@@ -31760,7 +32225,7 @@ function parseAnnouncement(file, pid) {
   };
   let announcedAt;
   try {
-    announcedAt = statSync5(file).mtimeMs;
+    announcedAt = statSync4(file).mtimeMs;
   } catch {}
   const when = announcedAt === undefined ? {} : { announcedAt };
   if (protocol !== RUNTIME_PROTOCOL) {
@@ -31801,7 +32266,7 @@ function discoverRuntimes(directories = runtimeDirectories()) {
 function wentAway(file, pid) {
   let project = "";
   try {
-    const fields = asParams(JSON.parse(readFileSync11(file, "utf8")));
+    const fields = asParams(JSON.parse(readFileSync9(file, "utf8")));
     project = readString(readParams(fields, "project") ?? {}, "path") ?? "";
   } catch {
     return;
@@ -31838,29 +32303,29 @@ function strangersAmong(candidates, now, startTimes = startTimesOf) {
   return new Set(candidates.filter((one) => verdicts.get(one.file)?.stranger === true).map((one) => one.file));
 }
 function announcedIn(directory) {
-  if (!existsSync10(directory)) {
+  if (!existsSync9(directory)) {
     return [];
   }
   const found = [];
   const candidates = [];
   const entries = [];
-  for (const entry of readdirSync6(directory)) {
+  for (const entry of readdirSync5(directory)) {
     const report = ERROR_REPORT_PATTERN.exec(entry);
     if (report) {
-      sweepErrorReport(join13(directory, entry), Number.parseInt(report[1] ?? "", 10));
+      sweepErrorReport(join11(directory, entry), Number.parseInt(report[1] ?? "", 10));
       continue;
     }
     const match = ANNOUNCEMENT_PATTERN.exec(entry);
     if (!match) {
       continue;
     }
-    const file = join13(directory, entry);
+    const file = join11(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
     const alive = processAlive(pid);
     entries.push({ file, pid, alive });
     if (alive) {
       try {
-        candidates.push({ file, pid, writtenAt: statSync5(file).mtimeMs });
+        candidates.push({ file, pid, writtenAt: statSync4(file).mtimeMs });
       } catch {}
     }
   }
@@ -31882,16 +32347,16 @@ function announcedIn(directory) {
     found.push(announced);
   }
   const held = new Set(entries.map((one) => one.file));
-  const here = join13(directory, ".");
+  const here = join11(directory, ".");
   for (const file of verdicts.keys()) {
-    if (dirname8(file) === here && !held.has(file)) {
+    if (dirname7(file) === here && !held.has(file)) {
       verdicts.delete(file);
     }
   }
   return found;
 }
 async function announcementEnded(pid, directories = runtimeDirectories()) {
-  const files = directories.map((directory) => join13(directory, `runtime-${pid}.json`)).filter((file) => existsSync10(file));
+  const files = directories.map((directory) => join11(directory, `runtime-${pid}.json`)).filter((file) => existsSync9(file));
   const first = files[0];
   if (first === undefined) {
     return;
@@ -31917,7 +32382,7 @@ function sweepErrorReport(path, pid, now = Date.now()) {
     return;
   }
   try {
-    if (now - statSync5(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
+    if (now - statSync4(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
       unlinkSync(path);
     }
   } catch {}
@@ -32190,14 +32655,14 @@ var init_runtime_client = __esm(() => {
 });
 
 // src/boot-note.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname9, join as join14 } from "node:path";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname8, join as join12 } from "node:path";
 function bootNotePath(projectPath) {
-  return join14(projectPath, ".godot", "gdharness-boot.json");
+  return join12(projectPath, ".godot", "gdharness-boot.json");
 }
 function readBootNote(projectPath) {
   try {
-    const noted = readNumber(asParams(JSON.parse(readFileSync12(bootNotePath(projectPath), "utf8"))), "announcedAfterMs");
+    const noted = readNumber(asParams(JSON.parse(readFileSync10(bootNotePath(projectPath), "utf8"))), "announcedAfterMs");
     return noted !== undefined && Number.isFinite(noted) && noted > 0 ? noted : null;
   } catch {
     return null;
@@ -32206,8 +32671,8 @@ function readBootNote(projectPath) {
 function writeBootNote(projectPath, announcedAfterMs) {
   try {
     const path = bootNotePath(projectPath);
-    mkdirSync7(dirname9(path), { recursive: true });
-    writeFileSync9(path, JSON.stringify({ announcedAfterMs: Math.round(announcedAfterMs), at: new Date().toISOString() }, null, 2), "utf8");
+    mkdirSync6(dirname8(path), { recursive: true });
+    writeFileSync7(path, JSON.stringify({ announcedAfterMs: Math.round(announcedAfterMs), at: new Date().toISOString() }, null, 2), "utf8");
   } catch {}
 }
 function halfAsLongAgain(lastBootMs) {
@@ -32225,10 +32690,10 @@ var init_boot_note = __esm(() => {
 });
 
 // src/breakpoint-note.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync13, rmSync as rmSync7, writeFileSync as writeFileSync10 } from "node:fs";
-import { dirname as dirname10, isAbsolute as isAbsolute2, join as join15, relative as relative2 } from "node:path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync11, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname9, isAbsolute as isAbsolute2, join as join13, relative as relative2 } from "node:path";
 function breakpointNotePath(projectPath) {
-  return join15(projectPath, ".godot", "gdharness-breakpoints.json");
+  return join13(projectPath, ".godot", "gdharness-breakpoints.json");
 }
 function writeBreakpointNote(projectPath, held) {
   const path = breakpointNotePath(projectPath);
@@ -32236,7 +32701,7 @@ function writeBreakpointNote(projectPath, held) {
   const inside = held.map((one) => ({ scriptPath: realPathOr(one.scriptPath), lines: one.lines })).filter((one) => one.lines.length > 0 && withinProject(root, one.scriptPath));
   try {
     if (inside.length === 0) {
-      rmSync7(path, { force: true });
+      rmSync6(path, { force: true });
       return;
     }
     const note = {
@@ -32245,8 +32710,8 @@ function writeBreakpointNote(projectPath, held) {
         lines: [...one.lines]
       }))
     };
-    mkdirSync8(dirname10(path), { recursive: true });
-    writeFileSync10(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync7(dirname9(path), { recursive: true });
+    writeFileSync8(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the breakpoints at ${path}: ${errorMessage(error)}`);
@@ -32254,7 +32719,7 @@ function writeBreakpointNote(projectPath, held) {
 }
 function readBreakpointNote(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync13(breakpointNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync11(breakpointNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.breakpoints)) {
       return [];
     }
@@ -32269,7 +32734,7 @@ function readBreakpointNote(projectPath) {
       }
       const lines = Array.isArray(listed) ? listed.filter((line) => Number.isInteger(line) && line > 0) : [];
       if (lines.length > 0) {
-        held.push({ scriptPath: realPathOr(join15(projectPath, script)), lines });
+        held.push({ scriptPath: realPathOr(join13(projectPath, script)), lines });
       }
     }
     return held;
@@ -32286,75 +32751,15 @@ var init_breakpoint_note = __esm(() => {
   init_paths();
 });
 
-// src/bridge-announce.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync14, rmSync as rmSync8, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname11, join as join16 } from "node:path";
-function announcementPath2(projectPath) {
-  return join16(projectPath, ".godot", "gdharness-bridge.json");
-}
-function readAnnouncement2(path) {
-  try {
-    const parsed = JSON.parse(readFileSync14(path, "utf8"));
-    if (typeof parsed !== "object" || parsed === null) {
-      return null;
-    }
-    const said = parsed;
-    if (typeof said.port !== "number" || typeof said.pid !== "number") {
-      return null;
-    }
-    return said;
-  } catch {
-    return null;
-  }
-}
-function announcementIsOurs(path) {
-  return readAnnouncement2(path)?.pid === process.pid;
-}
-function announceBridge(projectPath, bridge) {
-  const path = announcementPath2(projectPath);
-  try {
-    mkdirSync9(dirname11(path), { recursive: true });
-    const announcement = {
-      protocol: BRIDGE_ANNOUNCE_PROTOCOL,
-      host: bridge.host,
-      port: bridge.port,
-      pid: process.pid,
-      version: bridge.version,
-      startedAt: new Date().toISOString()
-    };
-    writeFileSync11(path, `${JSON.stringify(announcement, null, 2)}
-`, "utf8");
-    return path;
-  } catch (error) {
-    console.error(`[SERVER] Could not announce the editor bridge at ${path}: ${errorMessage(error)}`);
-    return null;
-  }
-}
-function withdrawBridge(path) {
-  if (path === null || !announcementIsOurs(path)) {
-    return;
-  }
-  try {
-    rmSync8(path, { force: true });
-  } catch (error) {
-    console.error(`[SERVER] Could not withdraw the editor bridge announcement: ${errorMessage(error)}`);
-  }
-}
-var BRIDGE_ANNOUNCE_PROTOCOL = 1;
-var init_bridge_announce = __esm(() => {
-  init_errors();
-  init_process_children();
-});
-
 // src/class-note.ts
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync15, writeFileSync as writeFileSync12 } from "node:fs";
-import { dirname as dirname12, join as join17 } from "node:path";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname10, join as join14 } from "node:path";
 function classNotePath(projectPath) {
-  return join17(projectPath, ".godot", "gdharness-classes.json");
+  return join14(projectPath, ".godot", "gdharness-classes.json");
 }
 function readClassNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync15(classNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync12(classNotePath(projectPath), "utf8")));
     const rebuiltWith = readArray(fields, "rebuiltWith");
     if (rebuiltWith === undefined || !rebuiltWith.every((name) => typeof name === "string")) {
       return null;
@@ -32371,24 +32776,24 @@ function readClassNote(projectPath) {
 function writeClassNote(projectPath, note) {
   try {
     const path = classNotePath(projectPath);
-    mkdirSync10(dirname12(path), { recursive: true });
-    writeFileSync12(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync8(dirname10(path), { recursive: true });
+    writeFileSync9(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch {}
 }
 var init_class_note = () => {};
 
 // src/config-pin.ts
-import { existsSync as existsSync11, readFileSync as readFileSync16 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync13 } from "node:fs";
+import { join as join15 } from "node:path";
 function versionsNamedInConfig(projectPath) {
-  const config = join18(projectPath, ".mcp.json");
-  if (!existsSync11(config)) {
+  const config = join15(projectPath, ".mcp.json");
+  if (!existsSync10(config)) {
     return [];
   }
   let text;
   try {
-    text = readFileSync16(config, "utf8");
+    text = readFileSync13(config, "utf8");
     JSON.parse(text);
   } catch {
     return [];
@@ -33145,25 +33550,25 @@ var init_desktop = () => {};
 // src/editor-log.ts
 import {
   closeSync,
-  existsSync as existsSync12,
-  mkdirSync as mkdirSync11,
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync9,
   openSync,
-  readFileSync as readFileSync17,
+  readFileSync as readFileSync14,
   readSync,
-  rmSync as rmSync9,
-  statSync as statSync6,
-  writeFileSync as writeFileSync13
+  rmSync as rmSync7,
+  statSync as statSync5,
+  writeFileSync as writeFileSync10
 } from "node:fs";
-import { dirname as dirname13, join as join19 } from "node:path";
+import { dirname as dirname11, join as join16 } from "node:path";
 function editorLogPath(projectPath) {
-  return join19(projectPath, ".godot", "gdharness-editor.log");
+  return join16(projectPath, ".godot", "gdharness-editor.log");
 }
 function editorLogNotePath(projectPath) {
-  return join19(projectPath, ".godot", "gdharness-editor.json");
+  return join16(projectPath, ".godot", "gdharness-editor.json");
 }
 function readEditorLogNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync17(editorLogNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync14(editorLogNotePath(projectPath), "utf8")));
     const pid = readNumber(fields, "pid");
     const startedAt = readString(fields, "startedAt");
     return pid !== undefined && Number.isInteger(pid) && pid > 0 && startedAt !== undefined ? { pid, startedAt } : null;
@@ -33174,16 +33579,16 @@ function readEditorLogNote(projectPath) {
 function clearEditorLog(projectPath) {
   try {
     const path = editorLogPath(projectPath);
-    mkdirSync11(dirname13(path), { recursive: true });
-    rmSync9(path, { force: true });
-    rmSync9(editorLogNotePath(projectPath), { force: true });
+    mkdirSync9(dirname11(path), { recursive: true });
+    rmSync7(path, { force: true });
+    rmSync7(editorLogNotePath(projectPath), { force: true });
   } catch {}
 }
 function writeEditorLogNote(projectPath, pid) {
   try {
     const path = editorLogNotePath(projectPath);
-    mkdirSync11(dirname13(path), { recursive: true });
-    writeFileSync13(path, JSON.stringify({ pid, startedAt: new Date().toISOString() }, null, 2), "utf8");
+    mkdirSync9(dirname11(path), { recursive: true });
+    writeFileSync10(path, JSON.stringify({ pid, startedAt: new Date().toISOString() }, null, 2), "utf8");
   } catch {}
 }
 function theConsoleWasNotCaptured(why, projectPath) {
@@ -33204,7 +33609,7 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
     return { kind: "older server", notedPid: noted?.pid ?? null };
   }
   const path = editorLogPath(projectPath);
-  if (!existsSync12(path)) {
+  if (!existsSync11(path)) {
     return { kind: "not written" };
   }
   const log = new GameLog;
@@ -33214,9 +33619,9 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
   return { log, path, ...of === undefined ? {} : { readBytes: text.length, of } };
 }
 function theFirstOf(path) {
-  const whole = statSync6(path).size;
+  const whole = statSync5(path).size;
   if (whole <= MOST_CONSOLE_BYTES) {
-    return { text: readFileSync17(path, "utf8") };
+    return { text: readFileSync14(path, "utf8") };
   }
   const handle = openSync(path, "r");
   try {
@@ -33258,7 +33663,7 @@ function shapeOf(text) {
   }
   return { shape, values };
 }
-function bursts(entries, before) {
+function bursts(entries, before, keep) {
   const shapes = new Map;
   const shaped = entries.map((entry) => shapeOf(entry.text));
   for (const [at, entry] of entries.entries()) {
@@ -33286,6 +33691,9 @@ function bursts(entries, before) {
     if (entry === undefined) {
       continue;
     }
+    if (keep !== undefined && !group.indices.some((at) => entries[at] !== undefined && keep(entries[at]))) {
+      continue;
+    }
     repeated.push({
       shape: key.slice(key.indexOf("\x00") + 1),
       count: group.indices.length,
@@ -36755,208 +37163,6 @@ var init_godot_bridge = __esm(() => {
   };
 });
 
-// src/godot-path.ts
-import { execFile as execFile5 } from "node:child_process";
-import { existsSync as existsSync13 } from "node:fs";
-import { normalize as normalize2 } from "node:path";
-import { promisify as promisify5 } from "node:util";
-
-class GodotLocator2 {
-  answered = new Map;
-  found = null;
-  async find() {
-    if (this.found !== null && await this.whyNot(this.found) === null) {
-      return { ok: true, path: this.found };
-    }
-    this.found = null;
-    const named = envValue("GODOT_PATH");
-    if (named !== undefined) {
-      const path = normalize2(named);
-      const reason = await this.whyNot(path);
-      if (reason === null) {
-        this.found = path;
-        return { ok: true, path };
-      }
-      return { ok: false, named: path, reason };
-    }
-    for (const candidate of godotCandidates(process.platform, resolveHomeDirectory())) {
-      const path = normalize2(candidate);
-      if (await this.whyNot(path) === null) {
-        this.found = path;
-        return { ok: true, path };
-      }
-    }
-    return { ok: false, named: null };
-  }
-  static refusal(located) {
-    if (located.named === null) {
-      return {
-        message: "No Godot executable found.",
-        advice: [
-          "Set GODOT_PATH to the Godot 4 executable",
-          "Or install Godot where it is usually found, such as /usr/bin/godot or C:\\Program Files\\Godot"
-        ]
-      };
-    }
-    return {
-      message: `GODOT_PATH is set to ${located.named}, which ${located.reason ?? "does not answer"}.`,
-      advice: [
-        "Point GODOT_PATH at a Godot 4 executable that answers --version",
-        "Or unset it, and the usual install locations are searched instead"
-      ]
-    };
-  }
-  async whyNot(path) {
-    const known = this.answered.get(path);
-    if (known !== undefined) {
-      return known;
-    }
-    let reason;
-    if (path !== "godot" && !existsSync13(path)) {
-      reason = "does not exist";
-    } else {
-      try {
-        await run5(path, ["--version"]);
-        reason = null;
-      } catch (error) {
-        reason = `does not answer --version: ${errorMessage(error)}`;
-      }
-    }
-    this.answered.set(path, reason);
-    return reason;
-  }
-}
-var run5;
-var init_godot_path = __esm(() => {
-  init_detection();
-  init_errors();
-  run5 = promisify5(execFile5);
-});
-
-// src/issues.ts
-import { createHash as createHash4 } from "node:crypto";
-import process7 from "node:process";
-function feedbackNotice() {
-  return JSON.stringify({
-    gdharness_feedback: {
-      what_to_do: "If this session has run into something gdharness cannot do, or a tool that should " + "exist and does not, tell the user what is missing and offer to open an enhancement " + "issue for them. Only if they say yes, and only for a real gap: a call you got wrong " + "is not one. If you cannot open an issue yourself, give them the link and what to " + "write in it.",
-      enhancement_url: ENHANCEMENT_URL2
-    }
-  }, null, 2);
-}
-function runtime2() {
-  const versions = process7.versions;
-  const bun = versions["bun"];
-  return bun === undefined ? `node ${process7.versions.node}` : `bun ${bun}`;
-}
-function defectSignature2(where, message) {
-  const normalised = `${where}
-${message}`.toLowerCase().replaceAll("\\", "/").replaceAll(/(?:[a-z]:)?(?:\/+[\w.-]+){2,}/gu, "<path>").replaceAll(/\d+/gu, "0");
-  return createHash4("sha256").update(normalised).digest("hex").slice(0, 8);
-}
-function facts2(where, message, godotVersion) {
-  return [
-    ["Where", where],
-    ["Error", message],
-    ["Version", `gdharness ${SERVER_VERSION}`],
-    ["Runtime", `${runtime2()}, ${process7.platform} ${process7.arch}`],
-    ["Godot", godotVersion ?? "not known at the point this failed"],
-    ["Signature", defectSignature2(where, message)]
-  ];
-}
-function filledTemplate2(where, message, godotVersion) {
-  return [
-    `**gdharness version**: ${SERVER_VERSION}`,
-    `**Godot version**: ${godotVersion ?? ""}`,
-    `**Bun version**: ${runtime2()}`,
-    `**OS**: ${process7.platform} ${process7.arch}`,
-    "**MCP client**:",
-    "",
-    "## What you did",
-    "",
-    where,
-    "",
-    "## What you expected",
-    "",
-    "The call to answer, or to refuse with a reason.",
-    "",
-    "## What happened",
-    "",
-    "gdharness failed in a way it does not model.",
-    "",
-    "```text",
-    message,
-    "```",
-    "",
-    `Signature: \`${defectSignature2(where, message)}\``,
-    "",
-    "If the real cause turned out to be the project, the environment or the call, say so here:",
-    "reaching you as a defect rather than as a refusal naming what would have worked is then the",
-    "thing to fix.",
-    "",
-    "## Anything that makes it reproducible",
-    ""
-  ].join(`
-`);
-}
-
-class DefectsSeen {
-  counts = new Map;
-  before(where, message) {
-    const signature = defectSignature2(where, message);
-    const seen = this.counts.get(signature) ?? 0;
-    this.counts.set(signature, seen + 1);
-    return seen;
-  }
-}
-function defectReport2(where, error, context = {}) {
-  const { godotVersion, seenBefore = 0 } = context;
-  const message = errorMessage(error);
-  const title = `Defect ${defectSignature2(where, message)}: ${where}`;
-  const url = `${NEW_ISSUE2}?template=bug_report.md&title=${encodeURIComponent(title)}` + `&body=${encodeURIComponent(filledTemplate2(where, message, godotVersion))}`;
-  const width = Math.max(...facts2(where, message, godotVersion).map(([label]) => (label ?? "").length));
-  return [
-    "gdharness failed in a way it does not model. Whatever went wrong underneath, it reached you",
-    "as a crash rather than as a refusal naming what would have worked, and that much is a defect",
-    "in gdharness however the rest of it turns out.",
-    "",
-    ...seenBefore === 0 ? [
-      "Send the call once more before anything else. Some of what reaches this line is a file",
-      "another process had open, or a connection that dropped, and those are gone by the next",
-      "attempt. If the same Signature comes back, it is not one of those, and repeating it",
-      "further only spends turns."
-    ] : [
-      `You have had this exact failure ${seenBefore === 1 ? "once" : `${seenBefore} times`} in this session already, so it is a`,
-      "state rather than a passing one, and sending the call again will not change it."
-    ],
-    "",
-    ...facts2(where, message, godotVersion).map(([label, value]) => `  ${(label ?? "").padEnd(width)}  ${value ?? ""}`),
-    "",
-    "Do not open an issue on your own initiative. Tell the person whose machine this is what",
-    "broke, and ask whether you may report it to gdharness on their behalf. What the report",
-    "carries is the lines above and nothing else, and whether that goes into a public tracker",
-    "is theirs to decide.",
-    "",
-    "If they say yes, this link carries the report already filled in:",
-    url,
-    "",
-    "If they say yes and you have no way to open an issue yourself, give them that link and",
-    "those lines, and stay with them while they file it.",
-    "",
-    "Worth reporting either way. If you can see that what actually went wrong was the project,",
-    "the environment or the call, then this message is the defect: a failure gdharness knows",
-    "about is meant to arrive as a refusal naming what would have worked, not as this. Say that",
-    "in the report and it is the more useful of the two."
-  ].join(`
-`);
-}
-var NEW_ISSUE2 = "https://github.com/Aureliolo/gdharness/issues/new", ENHANCEMENT_URL2;
-var init_issues = __esm(() => {
-  init_errors();
-  init_server_version();
-  ENHANCEMENT_URL2 = `${NEW_ISSUE2}?template=feature_request.md`;
-});
-
 // src/junit.ts
 function decoded(text) {
   return text.replace(/&(#x[0-9a-fA-F]+|#[0-9]+|[a-zA-Z]+);/g, (whole, entity) => {
@@ -37148,7 +37354,7 @@ function scriptErrorsPrinted(printed) {
   for (const line of printed.slice(start + 1)) {
     const at = /^\s*at (res:\/\/.+):(\d+)\s*$/.exec(line);
     if (at !== null && message !== null) {
-      found.push({ path: at[1] ?? "", line: Number(at[2]), message });
+      found.push({ path: at[1] ?? "", line: Number(at[2]) === 0 ? null : Number(at[2]), message });
       message = null;
     } else if (at === null && message === null && /^ {2}\S/.test(line)) {
       message = line.trim();
@@ -37156,7 +37362,7 @@ function scriptErrorsPrinted(printed) {
       break;
     }
   }
-  return found.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : a.line - b.line);
+  return found.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : (a.line ?? 0) - (b.line ?? 0));
 }
 function unspelled(text) {
   return text.replace(/<(?:LF|CR|TAB|BS|FF|VT|BEL|ESC|DEL|0x[0-9A-F]{2})>/g, (spelling) => spelling.startsWith("<0x") ? String.fromCharCode(Number.parseInt(spelling.slice(3, 5), 16)) : SPELLED[spelling] ?? spelling);
@@ -37298,8 +37504,8 @@ var init_junit = __esm(() => {
 import { realpathSync as realpathSync2 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname14, resolve as resolve4 } from "node:path";
-import { fileURLToPath as fileURLToPath4, pathToFileURL } from "node:url";
+import { dirname as dirname12, resolve as resolve4 } from "node:path";
+import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function diagnosticsKey(uri) {
   let decoded;
   try {
@@ -37311,7 +37517,7 @@ function diagnosticsKey(uri) {
     return decoded;
   }
   try {
-    return realpathSync2.native(fileURLToPath4(decoded)).toLowerCase();
+    return realpathSync2.native(fileURLToPath3(decoded)).toLowerCase();
   } catch {
     return decoded.toLowerCase();
   }
@@ -37426,7 +37632,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname14(resolve4(filePath));
+    const rootPath = this.rootPath ?? dirname12(resolve4(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params) {
@@ -37833,7 +38039,7 @@ var init_lsp_client = __esm(() => {
 
 // src/outside.ts
 import { spawn } from "node:child_process";
-import { fileURLToPath as fileURLToPath5 } from "node:url";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 function changesFrom(env, base) {
   const changes = {};
   if (env === undefined) {
@@ -37896,12 +38102,12 @@ async function launchOutsideTheTree(spec, runtime = process.execPath, keeper = K
 }
 var KEEPER_SCRIPT;
 var init_outside = __esm(() => {
-  KEEPER_SCRIPT = fileURLToPath5(new URL("./keeper.js", import.meta.url));
+  KEEPER_SCRIPT = fileURLToPath4(new URL("./keeper.js", import.meta.url));
 });
 
 // src/process-time.ts
-import { execFile as execFile6 } from "node:child_process";
-import { promisify as promisify6 } from "node:util";
+import { execFile as execFile4 } from "node:child_process";
+import { promisify as promisify4 } from "node:util";
 async function cpuSecondsOf(pid) {
   try {
     return process.platform === "win32" ? await askWindows2(pid) : await askPosix2(pid);
@@ -37910,12 +38116,12 @@ async function cpuSecondsOf(pid) {
   }
 }
 async function askWindows2(pid) {
-  const { stdout } = await run6("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `(Get-Process -Id ${pid}).CPU`], { timeout: ASK_TIMEOUT_MS2, windowsHide: true });
+  const { stdout } = await run4("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `(Get-Process -Id ${pid}).CPU`], { timeout: ASK_TIMEOUT_MS2, windowsHide: true });
   const seconds = Number(stdout.trim().replace(",", "."));
   return Number.isFinite(seconds) ? seconds : undefined;
 }
 async function askPosix2(pid) {
-  const { stdout } = await run6("ps", ["-o", "time=", "-p", String(pid)], { timeout: ASK_TIMEOUT_MS2 });
+  const { stdout } = await run4("ps", ["-o", "time=", "-p", String(pid)], { timeout: ASK_TIMEOUT_MS2 });
   return secondsFromClock(stdout.trim());
 }
 function secondsFromClock(printed) {
@@ -37933,19 +38139,19 @@ function secondsFromClock(printed) {
   const extra = days === null ? 0 : Number(days) * 86400;
   return Number.isFinite(extra) ? seconds + extra : undefined;
 }
-var run6, ASK_TIMEOUT_MS2 = 6000;
+var run4, ASK_TIMEOUT_MS2 = 6000;
 var init_process_time = __esm(() => {
-  run6 = promisify6(execFile6);
+  run4 = promisify4(execFile4);
 });
 
 // src/project-scan.ts
-import { existsSync as existsSync14, readdirSync as readdirSync7, readFileSync as readFileSync18 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync12, readdirSync as readdirSync6, readFileSync as readFileSync15 } from "node:fs";
+import { join as join17 } from "node:path";
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
 function steppedOver(directory) {
-  return existsSync14(join20(directory, ".gdignore"));
+  return existsSync12(join17(directory, ".gdignore"));
 }
 function projectStructure(projectPath) {
   const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
@@ -37953,12 +38159,12 @@ function projectStructure(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join20(directory, entry.name));
+        visit(join17(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (extension === "tscn") {
@@ -37982,20 +38188,20 @@ function scriptsWithoutUid(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join20(directory, entry.name), spelled);
+        visit(join17(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync14(join20(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync12(join17(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -38023,14 +38229,14 @@ function searchProject(projectPath, options) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
       if (full()) {
         return;
       }
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join20(directory, entry.name);
+      const entryPath = join17(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -38041,7 +38247,7 @@ function searchProject(projectPath, options) {
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync18(entryPath, "utf8").split(`
+      for (const [index, line] of readFileSync15(entryPath, "utf8").split(`
 `).entries()) {
         if (full()) {
           break;
@@ -38070,37 +38276,37 @@ var init_project_scan = __esm(() => {
 });
 
 // src/reimport.ts
-import { createHash as createHash5 } from "node:crypto";
-import { existsSync as existsSync15, readFileSync as readFileSync19, rmSync as rmSync10, statSync as statSync7, utimesSync, writeFileSync as writeFileSync14 } from "node:fs";
-import { basename as basename3, join as join21 } from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync13, readFileSync as readFileSync16, rmSync as rmSync8, statSync as statSync6, utimesSync, writeFileSync as writeFileSync11 } from "node:fs";
+import { basename as basename3, join as join18 } from "node:path";
 function forceNextImport(projectPath, resourcePath) {
   const relative = resourcePath.replace(/^res:\/\//, "");
-  const sidecar = join21(projectPath, `${relative}.import`);
-  if (!existsSync15(sidecar)) {
+  const sidecar = join18(projectPath, `${relative}.import`);
+  if (!existsSync13(sidecar)) {
     return;
   }
-  const { atime, mtimeMs } = statSync7(sidecar);
-  writeFileSync14(sidecar, readFileSync19(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
+  const { atime, mtimeMs } = statSync6(sidecar);
+  writeFileSync11(sidecar, readFileSync16(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
   utimesSync(sidecar, atime, new Date(mtimeMs + 2000));
-  rmSync10(importRecord(projectPath, resourcePath), { force: true });
+  rmSync8(importRecord(projectPath, resourcePath), { force: true });
 }
 function importRecord(projectPath, resourcePath) {
-  const digest = createHash5("md5").update(resourcePath).digest("hex");
-  return join21(projectPath, ".godot", "imported", `${basename3(resourcePath)}-${digest}.md5`);
+  const digest = createHash3("md5").update(resourcePath).digest("hex");
+  return join18(projectPath, ".godot", "imported", `${basename3(resourcePath)}-${digest}.md5`);
 }
 var init_reimport = () => {};
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync12, readFileSync as readFileSync20, rmSync as rmSync11, writeFileSync as writeFileSync15 } from "node:fs";
-import { dirname as dirname15, join as join22 } from "node:path";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync17, rmSync as rmSync9, writeFileSync as writeFileSync12 } from "node:fs";
+import { dirname as dirname13, join as join19 } from "node:path";
 function restartNotePath(projectPath) {
-  return join22(projectPath, ".godot", "gdharness-restart.json");
+  return join19(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync12(dirname15(path), { recursive: true });
-    writeFileSync15(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync10(dirname13(path), { recursive: true });
+    writeFileSync12(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
@@ -38108,7 +38314,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync20(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync17(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -38123,7 +38329,7 @@ function restartOwed(projectPath) {
 }
 function restartSettled(projectPath) {
   try {
-    rmSync11(restartNotePath(projectPath), { force: true });
+    rmSync9(restartNotePath(projectPath), { force: true });
   } catch (error) {
     console.error(`[SERVER] Could not clear the restart note: ${errorMessage(error)}`);
   }
@@ -38134,29 +38340,29 @@ var init_restart_note = __esm(() => {
 
 // src/run-record.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import {
-  mkdirSync as mkdirSync13,
+  mkdirSync as mkdirSync11,
   openSync as openSync2,
-  readdirSync as readdirSync8,
-  readFileSync as readFileSync21,
+  readdirSync as readdirSync7,
+  readFileSync as readFileSync18,
   realpathSync as realpathSync3,
-  rmSync as rmSync12,
-  statSync as statSync8,
-  writeFileSync as writeFileSync16
+  rmSync as rmSync10,
+  statSync as statSync7,
+  writeFileSync as writeFileSync13
 } from "node:fs";
-import { basename as basename4, dirname as dirname16, join as join23, resolve as resolve5 } from "node:path";
+import { basename as basename4, dirname as dirname14, join as join20, resolve as resolve5 } from "node:path";
 function runsDirectory() {
-  return join23(runtimeDirectory(), "runs");
+  return join20(runtimeDirectory(), "runs");
 }
 function realAsFarAsItExists(path) {
   const missing = [];
   let at = path;
   for (;; ) {
     try {
-      return join23(realpathSync3.native(at), ...missing);
+      return join20(realpathSync3.native(at), ...missing);
     } catch {
-      const parent = dirname16(at);
+      const parent = dirname14(at);
       if (parent === at) {
         return path;
       }
@@ -38168,26 +38374,26 @@ function realAsFarAsItExists(path) {
 function projectKey(projectPath) {
   const real = realAsFarAsItExists(resolve5(projectPath)).replace(/[\\/]+$/, "");
   const folded = process.platform === "win32" || process.platform === "darwin" ? real.toLowerCase() : real;
-  return createHash6("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
+  return createHash4("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join23(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join20(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 function openTranscript(startedAt) {
-  mkdirSync13(runsDirectory(), { recursive: true });
-  const path = join23(runsDirectory(), `run-${startedAt}.log`);
+  mkdirSync11(runsDirectory(), { recursive: true });
+  const path = join20(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync2(path, "a") };
 }
 function editorNotePath(projectPath, directory = runtimeDirectory()) {
-  return join23(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join20(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
-  mkdirSync13(runsDirectory(), { recursive: true });
-  writeFileSync16(editorNotePath(note.projectPath), JSON.stringify(note, null, 2), "utf8");
+  mkdirSync11(runsDirectory(), { recursive: true });
+  writeFileSync13(editorNotePath(note.projectPath), JSON.stringify(note, null, 2), "utf8");
 }
 function readEditorRunNote(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join23(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join20(directory, "runs", "editor-run.json"));
     if (note !== null && isSameDirectory(note.projectPath, projectPath)) {
       return note;
     }
@@ -38197,7 +38403,7 @@ function readEditorRunNote(projectPath) {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync21(path, "utf8"));
+    parsed = JSON.parse(readFileSync18(path, "utf8"));
   } catch {
     return null;
   }
@@ -38219,7 +38425,7 @@ function readRunRecord(projectPath) {
     if (own !== null) {
       return own;
     }
-    const shared = recordAt(join23(directory, "runs", SHARED_NOTE));
+    const shared = recordAt(join20(directory, "runs", SHARED_NOTE));
     if (shared !== null && shared.projectPath !== "" && isSameDirectory(shared.projectPath, projectPath)) {
       return shared;
     }
@@ -38231,13 +38437,13 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync8(join23(directory, "runs"));
+      entries = readdirSync7(join20(directory, "runs"));
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry === SHARED_NOTE || entry.startsWith("note-") && entry.endsWith(".json")) {
-        const record = recordAt(join23(directory, "runs", entry));
+        const record = recordAt(join20(directory, "runs", entry));
         if (record !== null) {
           found.push(record);
         }
@@ -38249,7 +38455,7 @@ function everyRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync21(path, "utf8"));
+    parsed = JSON.parse(readFileSync18(path, "utf8"));
   } catch {
     return null;
   }
@@ -38295,7 +38501,7 @@ function runningAs(pid) {
     const began = startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync21(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync18(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = execFileSync2("ps", ["-p", String(pid), "-o", "args="], {
@@ -38433,19 +38639,19 @@ function judgeAnnouncedGame(running, projectPath, announcedAt) {
 }
 function clearRunRecord(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const shared = join23(directory, "runs", SHARED_NOTE);
+    const shared = join20(directory, "runs", SHARED_NOTE);
     const sharedRecord = recordAt(shared);
     const ours = sharedRecord !== null && sharedRecord.projectPath !== "" && isSameDirectory(sharedRecord.projectPath, projectPath);
     for (const path of [runRecordPath(projectPath, directory), ...ours ? [shared] : []]) {
       try {
-        rmSync12(path, { force: true });
+        rmSync10(path, { force: true });
       } catch {}
     }
   }
 }
 function ageMs(path, now) {
   try {
-    return now - statSync8(path).mtimeMs;
+    return now - statSync7(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -38455,7 +38661,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
   const kept = new Set(everyRunRecord().map((record) => record.transcript));
   let entries;
   try {
-    entries = readdirSync8(directory);
+    entries = readdirSync7(directory);
   } catch {
     return;
   }
@@ -38463,12 +38669,12 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join23(directory, entry);
+    const path = join20(directory, entry);
     if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
     try {
-      rmSync12(path);
+      rmSync10(path);
     } catch {}
   }
 }
@@ -38480,29 +38686,29 @@ var init_run_record = __esm(() => {
 });
 
 // src/server.ts
-import { execFile as execFile7, spawn as spawn2 } from "node:child_process";
+import { execFile as execFile5, spawn as spawn2 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   appendFileSync,
   closeSync as closeSync2,
   constants,
   copyFileSync,
-  existsSync as existsSync16,
+  existsSync as existsSync14,
   fstatSync,
-  mkdirSync as mkdirSync14,
-  mkdtempSync as mkdtempSync3,
+  mkdirSync as mkdirSync12,
+  mkdtempSync as mkdtempSync2,
   openSync as openSync3,
-  readdirSync as readdirSync9,
-  readFileSync as readFileSync22,
+  readdirSync as readdirSync8,
+  readFileSync as readFileSync19,
   readSync as readSync2,
-  rmdirSync,
-  statSync as statSync9
+  rmdirSync as rmdirSync2,
+  statSync as statSync8
 } from "node:fs";
-import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename5, dirname as dirname17, extname as extname2, isAbsolute as isAbsolute3, join as join24, normalize as normalize3, relative as relative3 } from "node:path";
+import { tmpdir as tmpdir4 } from "node:os";
+import { basename as basename5, dirname as dirname15, extname as extname2, isAbsolute as isAbsolute3, join as join21, normalize as normalize2, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
-import { fileURLToPath as fileURLToPath6 } from "node:url";
-import { promisify as promisify7 } from "node:util";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
+import { promisify as promisify5 } from "node:util";
 function captureDestinationRefusal(outputPath, projects) {
   if (/^(res|user):\/\//.test(outputPath)) {
     return `outputPath ${outputPath} is a Godot path; a capture is saved outside the project, at an absolute path on this machine.`;
@@ -38513,16 +38719,16 @@ function captureDestinationRefusal(outputPath, projects) {
   if (extname2(outputPath).toLowerCase() !== ".png") {
     return `outputPath ${outputPath} does not end in .png, which is what a capture is.`;
   }
-  const directory = realPathOr(dirname17(outputPath));
-  if (!existsSync16(directory)) {
-    return `outputPath's directory ${dirname17(outputPath)} does not exist; a capture creates no directories.`;
+  const directory = realPathOr(dirname15(outputPath));
+  if (!existsSync14(directory)) {
+    return `outputPath's directory ${dirname15(outputPath)} does not exist; a capture creates no directories.`;
   }
-  const where = join24(directory, basename5(outputPath));
+  const where = join21(directory, basename5(outputPath));
   const inside = projects.find((project) => project !== "" && isWithinRoot(realPathOr(project), where));
   if (inside !== undefined) {
     return `outputPath ${outputPath} is inside the project at ${inside}; a capture is saved outside it, so it never becomes part of the game.`;
   }
-  if (existsSync16(where)) {
+  if (existsSync14(where)) {
     return `outputPath ${outputPath} already exists; a capture is not written over a file. Name a new one.`;
   }
   return null;
@@ -38887,15 +39093,24 @@ function changedSettings(before, after) {
   return [...names].filter((name) => JSON.stringify(before.get(name)) !== JSON.stringify(after.get(name))).sort();
 }
 function scriptErrorsNote(errors) {
-  const first = new Map;
+  const causes = new Map;
   for (const error of errors) {
-    if (!first.has(error.path)) {
-      first.set(error.path, error);
+    if (!error.message.includes(DEPENDED_FAILED) && !causes.has(error.path)) {
+      causes.set(error.path, error);
     }
   }
-  const scripts = [...first.values()].map((error) => `${error.path}:${error.line} ${error.message}${error.message.endsWith(".") ? "" : "."}`).join(" ");
-  const more = errors.length - first.size;
-  return `No tests ran: gdUnit4 could not load ${first.size === 1 ? "one script" : `${first.size} scripts`} while looking for suites, and it runs no suite at all when one fails to load. ${scripts}${more > 0 ? ` ${more === 1 ? "One more error" : `${more} more errors`} in ${first.size === 1 ? "that script" : "those scripts"} ${more === 1 ? "is" : "are"} under scriptErrors.` : ""}`;
+  const dependents = [...new Set(errors.map((error) => error.path))].filter((path) => !causes.has(path));
+  const scripts = causes.size + dependents.length;
+  const named = [...causes.values()].map((error) => `${error.line === null ? error.path : `${error.path}:${error.line}`} ${error.message}${/[.!?]\)?$/.test(error.message) ? "" : "."}`).join(" ");
+  const following = dependents.length === 0 ? "" : causes.size === 0 ? `${dependents.join(", ")} ${dependents.length === 1 ? "depends" : "depend"} on a script that did not compile, and gdUnit4 named none with an error of its own: script_diagnostics on one of them finds it.` : `${dependents.length === 1 ? "One more" : `${dependents.length} more`} failed only because a script ${dependents.length === 1 ? "it depends" : "they depend"} on did: ${dependents.join(", ")}.`;
+  const more = errors.filter((error) => !error.message.includes(DEPENDED_FAILED)).length - causes.size;
+  const rest = more > 0 ? `${more === 1 ? "One more error" : `${more} more errors`} in ${causes.size === 1 ? "that script" : "those scripts"} ${more === 1 ? "is" : "are"} under scriptErrors.` : "";
+  return [
+    `No tests ran: gdUnit4 could not load ${scripts === 1 ? "one script" : `${scripts} scripts`} while looking for suites, and it runs no suite at all when one fails to load.`,
+    named,
+    following,
+    rest
+  ].filter((part) => part !== "").join(" ");
 }
 function timedOutVerdict(timeoutMs, silentForMs) {
   const quiet = Math.round(silentForMs);
@@ -38952,13 +39167,13 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync16(join24(projectPath, wanted))) {
+  if (wanted === "" || existsSync14(join21(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
   let near = [];
   try {
-    near = readdirSync9(projectPath, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.toLowerCase() !== root).map((entry) => entry.name).filter((name) => name.toLowerCase().startsWith("test") || root.startsWith(name.toLowerCase()));
+    near = readdirSync8(projectPath, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.toLowerCase() !== root).map((entry) => entry.name).filter((name) => name.toLowerCase().startsWith("test") || root.startsWith(name.toLowerCase()));
   } catch {
     return "";
   }
@@ -38966,7 +39181,7 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync22(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync19(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function runtimeAddonAnnouncesEditors(projectPath) {
@@ -38974,13 +39189,13 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync22(join24(projectPath, RUNTIME_AUTOLOAD2.path), "utf8").includes('"editor_pid"');
+    return readFileSync19(join21(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync22(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync19(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -38998,8 +39213,8 @@ function needsItsOwnProcess(asked) {
 
 class GodotServer {
   mcp;
-  locator = new GodotLocator2;
-  operationsScript = join24(__dirname2, "godot", "operations", "godot_operations.gd");
+  locator = new GodotLocator;
+  operationsScript = join21(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -39058,7 +39273,7 @@ class GodotServer {
   async run() {
     const located = await this.locator.find();
     if (!located.ok) {
-      console.error(`[SERVER] ${GodotLocator2.refusal(located).message} Until that is fixed every tool that runs the engine will say so.`);
+      console.error(`[SERVER] ${GodotLocator.refusal(located).message} Until that is fixed every tool that runs the engine will say so.`);
     } else {
       console.error(`[SERVER] Using Godot at: ${located.path}`);
     }
@@ -39089,7 +39304,7 @@ class GodotServer {
       return;
     }
     const wanted = this.godotBridge.configuredPort;
-    const announced = readAnnouncement2(announcementPath2(this.ownProject));
+    const announced = readAnnouncement(announcementPath(this.ownProject));
     if (announced === null || announced.pid === process.pid || announced.port !== wanted || !alive(announced.pid)) {
       return;
     }
@@ -39175,7 +39390,7 @@ class GodotServer {
     if (this.ownProject === null) {
       return null;
     }
-    const announced = readAnnouncement2(announcementPath2(this.ownProject));
+    const announced = readAnnouncement(announcementPath(this.ownProject));
     if (announced === null || announced.pid === process.pid) {
       return null;
     }
@@ -39298,7 +39513,7 @@ class GodotServer {
         content: [
           {
             type: "text",
-            text: defectReport2(where, error, {
+            text: defectReport(where, error, {
               seenBefore,
               godotVersion: this.lastGodotVersion ?? undefined
             })
@@ -39640,11 +39855,16 @@ class GodotServer {
         return await this.handleRuntimeCommand(op === "screenshot" ? "capture_screenshot" : "capture_viewport", args);
       case "runtime_input":
         if (op === "click") {
+          if (readNonEmptyString(args, "nodePath") === undefined && readNonEmptyString(args, "says") === undefined) {
+            return this.createErrorResponse("runtime_input click needs nodePath, or says with the words on the control to click.");
+          }
           return await this.handleRuntimeCommand("click", {
             ...whichGame(args),
             path: readNonEmptyString(args, "nodePath") ?? "",
             button: readString(args, "button") ?? "left",
-            double: readBoolean(args, "doubleClick") ?? false
+            double: readBoolean(args, "doubleClick") ?? false,
+            ...readNonEmptyString(args, "says") === undefined ? {} : { says: readNonEmptyString(args, "says") },
+            ...args["index"] === undefined ? {} : { index: args["index"] }
           });
         }
         if (op === "choose") {
@@ -39703,7 +39923,7 @@ class GodotServer {
   async engine() {
     const located = await this.locator.find();
     if (!located.ok) {
-      const refusal = GodotLocator2.refusal(located);
+      const refusal = GodotLocator.refusal(located);
       return { ok: false, response: this.createErrorResponse(refusal.message, [...refusal.advice]) };
     }
     return { ok: true, value: located.path };
@@ -39713,8 +39933,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join24(path, "project.godot");
-    if (!existsSync16(file)) {
+    const file = join21(path, "project.godot");
+    if (!existsSync14(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -40212,7 +40432,7 @@ class GodotServer {
     }
     const scanned = await this.untilTheEditorsScanIsWritten(projectPath);
     this.logDebug(`Running ${operation} in ${projectPath}: ${JSON.stringify(params)}`);
-    const outcome = await runOperation2({ godotPath: engine.value, script: this.operationsScript, debug: GODOT_DEBUG_MODE_DEFAULT }, operation, params, projectPath);
+    const outcome = await runOperation({ godotPath: engine.value, script: this.operationsScript, debug: GODOT_DEBUG_MODE_DEFAULT }, operation, params, projectPath);
     return withScanWait(outcome, scanned);
   }
   answer(outcome) {
@@ -40242,7 +40462,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync22(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync19(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -40303,18 +40523,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname17(output.absolutePath);
+    const folder = dirname15(output.absolutePath);
     try {
-      mkdirSync14(folder, { recursive: true });
+      mkdirSync12(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname17(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname15(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
-    const exportLogs = mkdtempSync3(join24(tmpdir5(), "gdharness-export-"));
+    const exportLogs = mkdtempSync2(join21(tmpdir4(), "gdharness-export-"));
     const exportArgs = [
       "--headless",
       "--log-file",
-      join24(exportLogs, "engine.log"),
+      join21(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -40325,7 +40545,7 @@ class GodotServer {
     const log = new GameLog;
     let ending = { exitCode: 0, exitSignal: null, failure: null };
     try {
-      const { stdout, stderr } = await run7(engine.value, exportArgs, {
+      const { stdout, stderr } = await run5(engine.value, exportArgs, {
         timeout: 300000,
         maxBuffer: 64 * 1024 * 1024,
         signal: callSignal()
@@ -40346,7 +40566,7 @@ class GodotServer {
     log.finish();
     const problems = log.select({ severity: "warning", sinceLastCall: false, limit: 200 });
     const verdict = {
-      exported: ending.exitCode === 0 && log.count("error") === 0 && existsSync16(output.absolutePath),
+      exported: ending.exitCode === 0 && log.count("error") === 0 && existsSync14(output.absolutePath),
       preset,
       outputPath: output.relativePath,
       debug,
@@ -40382,7 +40602,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync16(join24(project.value.path, runner))) {
+    if (!existsSync14(join21(project.value.path, runner))) {
       return this.createErrorResponse(`gdUnit4 is not installed in this project: no ${runner}.`, [
         "Install gdUnit4 under addons/gdUnit4, from https://github.com/godot-gdunit-labs/gdUnit4"
       ]);
@@ -40418,7 +40638,7 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync3(join24(tmpdir5(), "gdharness-tests-"));
+    const userData = mkdtempSync2(join21(tmpdir4(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const console2 = [];
     let lastSaid = Date.now();
@@ -40445,21 +40665,21 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join24(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join21(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync16(reportsDir) ? readdirSync9(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync14(reportsDir) ? readdirSync8(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
       const newest = written.at(-1);
       if (newest !== undefined) {
-        report = parseJUnit(readFileSync22(join24(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync19(join21(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
     } finally {
       discard(reportsDir, userData);
       try {
-        rmdirSync(dirname17(reportsDir));
+        rmdirSync2(dirname15(reportsDir));
       } catch {}
     }
     const engineEntries = run.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries.map(aboveTheRunner);
@@ -40481,6 +40701,12 @@ class GodotServer {
     const brokenScripts = new Set(scriptErrors.map((error) => error.path)).size;
     const verdict = cutShort !== null ? cutShort.verdict : nothingRan ?? (brokenScripts > 0 ? `script errors in ${brokenScripts === 1 ? "one script" : `${brokenScripts} scripts`}, so no suite ran` : undefined) ?? (exitCode === null ? undefined : verdicts[exitCode]) ?? (run.exitSignal === null ? `exit ${exitCode ?? "unknown"}` : howItExited(run));
     const savesNote = savesStayPut() && nothingRan === null ? SAVES_NOT_MOVED_NOTE : undefined;
+    const marker = readNonEmptyString(args, "printed");
+    const echoed = marker === undefined ? undefined : run.log.select({ severity: "info", sinceLastCall: false, contains: marker, limit: 200 });
+    const printedLines = echoed === undefined ? {} : {
+      printed: echoed.entries.map((entry) => entry.text),
+      ...echoed.omitted > 0 ? { printedOmitted: echoed.omitted } : {}
+    };
     if (report === null) {
       const note = nothingRan !== null ? `No tests ran: ${verdict}.${elsewhereIn(project.value.path, asked)}` : scriptErrors.length > 0 ? scriptErrorsNote(scriptErrors) : `The test run wrote no report (${verdict}${reportProblem ? `; ${reportProblem}` : ""}).`;
       return {
@@ -40499,6 +40725,7 @@ class GodotServer {
               ...scriptErrors.length > 0 ? { scriptErrors } : {},
               arguments: cmdArgs,
               entries: forAnswer(printed.slice(0, 60).map(aboveTheRunner)),
+              ...printedLines,
               savesNote,
               ...scanned
             }, null, 2)
@@ -40535,6 +40762,7 @@ class GodotServer {
       warnings: warnings.length > 0 ? warnings : undefined,
       orphans: orphans.total > 0 ? orphans.total : undefined,
       notRun: notRun > 0 ? notRun : undefined,
+      ...printedLines,
       savesNote,
       ...scanned,
       note: verdict.startsWith("warnings") && warnings.length === 0 ? "gdUnit4 exits 101 for orphan nodes when nothing failed, and this run printed no count of them: orphan reporting may be off in the project settings." : notRun > 0 ? `This run stopped at the first failure in each suite it failed in, so ${notRun} case${notRun === 1 ? "" : "s"} never ran and count as neither passed nor failed. Leave failFast out to run every case.` : undefined,
@@ -40558,7 +40786,7 @@ class GodotServer {
   }
   async godotVersion(godotPath) {
     try {
-      const { stdout } = await run7(godotPath, ["--version"], { timeout: 1e4 });
+      const { stdout } = await run5(godotPath, ["--version"], { timeout: 1e4 });
       this.lastGodotVersion = stdout.trim();
       return this.lastGodotVersion;
     } catch (error) {
@@ -40602,11 +40830,11 @@ class GodotServer {
     const cached = cachedClasses(projectPath);
     const contradicted = cached === null ? [] : contradictedDiagnostics(messages, cached, (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
-      if (!contained.ok || !existsSync16(contained.absolutePath)) {
+      if (!contained.ok || !existsSync14(contained.absolutePath)) {
         return null;
       }
       try {
-        return readFileSync22(contained.absolutePath, "utf8");
+        return readFileSync19(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -40656,11 +40884,11 @@ class GodotServer {
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
-    if (!contained.ok || !existsSync16(contained.absolutePath)) {
+    if (!contained.ok || !existsSync14(contained.absolutePath)) {
       return null;
     }
     try {
-      return readFileSync22(contained.absolutePath, "utf8");
+      return readFileSync19(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -40906,7 +41134,7 @@ class GodotServer {
       godot: {
         path: located.ok ? located.path : null,
         version: located.ok ? await this.godotVersion(located.path) : null,
-        problem: located.ok ? undefined : GodotLocator2.refusal(located).message
+        problem: located.ok ? undefined : GodotLocator.refusal(located).message
       },
       game: {
         processActive: active,
@@ -40929,7 +41157,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync22(join24(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync19(join21(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -41182,7 +41410,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync16(join24(projectPath, RUNTIME_AUTOLOAD2.path))) {
+    if (!existsSync14(join21(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
     }
     let asking = null;
@@ -41245,7 +41473,7 @@ class GodotServer {
     }
     let announcedAt;
     try {
-      announcedAt = statSync9(endpoint.file).mtimeMs;
+      announcedAt = statSync8(endpoint.file).mtimeMs;
     } catch {
       return;
     }
@@ -41920,15 +42148,18 @@ class GodotServer {
         "editor_output with no op answers about the game a run is playing, which is a different log"
       ]);
     }
-    const severity = readString(args, "severity");
+    const asked = readString(args, "severity");
+    const severity = asked === "error" || asked === "warning" ? asked : "info";
+    const contains = readNonEmptyString(args, "contains");
     const selected = console2.log.select({
-      severity: severity === "error" || severity === "warning" ? severity : "info",
+      severity,
       sinceLastCall: false,
-      contains: readNonEmptyString(args, "contains"),
+      contains,
       limit: readPositiveNumber(args, "limit") ?? 200
     });
     const everything = console2.log.everything();
-    const grouped = bursts(everything, readNonNegativeNumber(args, "before") ?? 3);
+    const filtered = severity !== "info" || contains !== undefined;
+    const grouped = bursts(everything, readNonNegativeNumber(args, "before") ?? 3, filtered ? (entry) => answersTo(entry, severity, contains) : undefined);
     const shown = grouped.slice(0, MOST_GROUPS);
     return this.jsonTextResponse({
       editorPid: editorPid ?? undefined,
@@ -41996,7 +42227,7 @@ class GodotServer {
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync16(join24(run.projectPath, RUNTIME_AUTOLOAD2.path)),
+        couldAnnounce: run.projectPath !== null && existsSync14(join21(run.projectPath, RUNTIME_AUTOLOAD.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -42509,7 +42740,7 @@ class GodotServer {
   async ownRunOnItsWay(projectPath, budgetMs) {
     const run = this.currentRun();
     const project = projectPath ?? run?.projectPath ?? null;
-    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync16(join24(project, RUNTIME_AUTOLOAD2.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync14(join21(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -42518,7 +42749,7 @@ class GodotServer {
         return !run.announcedBefore.has(one.pid);
       }
       try {
-        return statSync9(one.file).mtimeMs >= run.startedAt;
+        return statSync8(one.file).mtimeMs >= run.startedAt;
       } catch {
         return false;
       }
@@ -42588,8 +42819,8 @@ class GodotServer {
         return this.createErrorResponse(refusal);
       }
     }
-    const screenshotDir = expectsScreenshot ? mkdtempSync3(join24(tmpdir5(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join24(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? mkdtempSync2(join21(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
+    const screenshotPath = screenshotDir ? join21(screenshotDir, "capture.png") : null;
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs, !expectsScreenshot);
       if (!reply.ok && reply.requestId !== undefined) {
@@ -42613,7 +42844,7 @@ class GodotServer {
       if (readString(payload, "type") !== "screenshot_file" || !returnedPath || !screenshotPath) {
         return this.createErrorResponse(`The game answered a capture with ${JSON.stringify(payload)}`);
       }
-      if (normalize3(returnedPath) !== normalize3(screenshotPath)) {
+      if (normalize2(returnedPath) !== normalize2(screenshotPath)) {
         return this.createErrorResponse(`Rejected screenshot file path outside the managed capture path: '${returnedPath}'`);
       }
       const dimensions = `${readNumber(payload, "width") ?? 0}x${readNumber(payload, "height") ?? 0} ${readString(payload, "format") ?? "unknown"}`;
@@ -42630,7 +42861,7 @@ class GodotServer {
             type: "text",
             text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}${saveTo === null ? "" : `. Saved to ${saveTo}`}`
           },
-          { type: "image", data: readFileSync22(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync19(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
@@ -42730,7 +42961,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run7, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, SCAN_WAIT_MS = 30000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, 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, run5, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, SCAN_WAIT_MS = 30000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, 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();
@@ -42770,8 +43001,8 @@ var init_server3 = __esm(() => {
   init_setup();
   init_tool_definitions();
   init_update_check();
-  run7 = promisify7(execFile7);
-  __dirname2 = dirname17(fileURLToPath6(import.meta.url));
+  run5 = promisify5(execFile5);
+  __dirname2 = dirname15(fileURLToPath5(import.meta.url));
   CONSOLE_WRAPPER = /_console(\.exe)?$/i;
   LONGEST_BOOT_NOTED_MS = 5 * 60000;
   VALUE_NAMES = {
@@ -42817,128 +43048,11 @@ var init_server3 = __esm(() => {
 });
 
 // src/cli.ts
-import { existsSync as existsSync17 } from "fs";
-import { join as join25, resolve as resolve6 } from "path";
-
-// src/bridge-announce.ts
+init_bridge_announce();
 init_errors();
-init_process_children();
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-function announcementPath(projectPath) {
-  return join(projectPath, ".godot", "gdharness-bridge.json");
-}
-function readAnnouncement(path) {
-  try {
-    const parsed = JSON.parse(readFileSync(path, "utf8"));
-    if (typeof parsed !== "object" || parsed === null) {
-      return null;
-    }
-    const said = parsed;
-    if (typeof said.port !== "number" || typeof said.pid !== "number") {
-      return null;
-    }
-    return said;
-  } catch {
-    return null;
-  }
-}
-function serverBehind(announcement, startedAt) {
-  if (announcement === null || typeof announcement.version !== "string" || startedAt === undefined) {
-    return null;
-  }
-  const announcedAt = Date.parse(announcement.startedAt);
-  if (Number.isNaN(announcedAt) || startedAt > announcedAt + 1000) {
-    return null;
-  }
-  return { version: announcement.version, pid: announcement.pid };
-}
-function serverServing(projectPath) {
-  const announcement = readAnnouncement(announcementPath(projectPath));
-  if (announcement === null) {
-    return null;
-  }
-  return serverBehind(announcement, startTimesOf([announcement.pid]).get(announcement.pid));
-}
-
-// src/errors.ts
-class Refusal2 extends Error {
-}
-
-// src/godot-path.ts
-init_detection();
-init_errors();
-import { execFile as execFile2 } from "node:child_process";
-import { existsSync as existsSync2 } from "node:fs";
-import { normalize } from "node:path";
-import { promisify as promisify2 } from "node:util";
-var run2 = promisify2(execFile2);
-
-class GodotLocator {
-  answered = new Map;
-  found = null;
-  async find() {
-    if (this.found !== null && await this.whyNot(this.found) === null) {
-      return { ok: true, path: this.found };
-    }
-    this.found = null;
-    const named = envValue("GODOT_PATH");
-    if (named !== undefined) {
-      const path = normalize(named);
-      const reason = await this.whyNot(path);
-      if (reason === null) {
-        this.found = path;
-        return { ok: true, path };
-      }
-      return { ok: false, named: path, reason };
-    }
-    for (const candidate of godotCandidates(process.platform, resolveHomeDirectory())) {
-      const path = normalize(candidate);
-      if (await this.whyNot(path) === null) {
-        this.found = path;
-        return { ok: true, path };
-      }
-    }
-    return { ok: false, named: null };
-  }
-  static refusal(located) {
-    if (located.named === null) {
-      return {
-        message: "No Godot executable found.",
-        advice: [
-          "Set GODOT_PATH to the Godot 4 executable",
-          "Or install Godot where it is usually found, such as /usr/bin/godot or C:\\Program Files\\Godot"
-        ]
-      };
-    }
-    return {
-      message: `GODOT_PATH is set to ${located.named}, which ${located.reason ?? "does not answer"}.`,
-      advice: [
-        "Point GODOT_PATH at a Godot 4 executable that answers --version",
-        "Or unset it, and the usual install locations are searched instead"
-      ]
-    };
-  }
-  async whyNot(path) {
-    const known = this.answered.get(path);
-    if (known !== undefined) {
-      return known;
-    }
-    let reason;
-    if (path !== "godot" && !existsSync2(path)) {
-      reason = "does not exist";
-    } else {
-      try {
-        await run2(path, ["--version"]);
-        reason = null;
-      } catch (error) {
-        reason = `does not answer --version: ${errorMessage(error)}`;
-      }
-    }
-    this.answered.set(path, reason);
-    return reason;
-  }
-}
+init_godot_path();
+import { existsSync as existsSync15 } from "node:fs";
+import { join as join22, resolve as resolve6 } from "node:path";
 
 // src/harnesses.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
@@ -43803,204 +43917,9 @@ function taken(harness, path, held, stripped) {
   return { harness, path, action: "removed" };
 }
 
-// src/headless.ts
-init_call_signal();
-init_game_log();
-init_scratch();
-import { execFile as execFile3 } from "node:child_process";
-import { mkdtempSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { tmpdir } from "node:os";
-import { join as join5 } from "node:path";
-import { promisify as promisify3 } from "node:util";
-var run3 = promisify3(execFile3);
-function snakeCased(params) {
-  const result = emptyRecord();
-  for (const [key, value] of Object.entries(params)) {
-    const name = key.startsWith("_") ? key : key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-    result[name] = value;
-  }
-  return result;
-}
-function lastJsonObject(stdout) {
-  const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.startsWith("{"));
-  for (const line of lines.reverse()) {
-    try {
-      const parsed = JSON.parse(line);
-      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
-        return parsed;
-      }
-    } catch {}
-  }
-  return null;
-}
-function problems(stderr) {
-  const log = new GameLog;
-  log.append("stderr", stderr);
-  log.finish();
-  return log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries;
-}
-function reason(stdout, stderr) {
-  const own = stderr.split(/\r?\n/).filter((line) => line.startsWith("[ERROR] ")).map((line) => line.slice("[ERROR] ".length));
-  if (own.length > 0) {
-    return own.join("; ");
-  }
-  const engine = problems(stderr).filter((entry) => entry.severity === "error").map((entry) => entry.text);
-  if (engine.length > 0) {
-    return engine.join("; ");
-  }
-  return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
-}
-async function runOperation(engine, operation, params, projectPath) {
-  const paramsDir = mkdtempSync(join5(tmpdir(), "gdharness-params-"));
-  const paramsFile = join5(paramsDir, `${operation}.json`);
-  writeFileSync3(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
-  const args = [
-    "--headless",
-    "--log-file",
-    join5(paramsDir, "engine.log"),
-    "--path",
-    projectPath,
-    "--script",
-    engine.script,
-    operation,
-    `@file:${paramsFile}`,
-    ...engine.debug ? ["--debug-godot"] : []
-  ];
-  let stdout;
-  let stderr;
-  try {
-    ({ stdout, stderr } = await run3(engine.godotPath, args, { signal: callSignal() }));
-  } catch (error) {
-    if (error instanceof Error && "stdout" in error && "stderr" in error) {
-      const failed = error;
-      return {
-        ok: false,
-        message: `${operation} failed (exit ${failed.code ?? "unknown"}): ${reason(failed.stdout, failed.stderr)}`,
-        messages: problems(failed.stderr)
-      };
-    }
-    return {
-      ok: false,
-      message: `${operation} could not be run: ${error instanceof Error ? error.message : String(error)}`,
-      messages: []
-    };
-  } finally {
-    discard(paramsDir);
-  }
-  const payload = lastJsonObject(stdout);
-  if (payload === null) {
-    return {
-      ok: false,
-      message: `${operation} produced no result: ${reason(stdout, stderr)}`,
-      messages: problems(stderr)
-    };
-  }
-  return { ok: true, payload, messages: problems(stderr) };
-}
-
-// src/issues.ts
-init_errors();
-init_server_version();
-import { createHash } from "node:crypto";
-import process4 from "node:process";
-var NEW_ISSUE = "https://github.com/Aureliolo/gdharness/issues/new";
-var ENHANCEMENT_URL = `${NEW_ISSUE}?template=feature_request.md`;
-function runtime() {
-  const versions = process4.versions;
-  const bun = versions["bun"];
-  return bun === undefined ? `node ${process4.versions.node}` : `bun ${bun}`;
-}
-function defectSignature(where, message) {
-  const normalised = `${where}
-${message}`.toLowerCase().replaceAll("\\", "/").replaceAll(/(?:[a-z]:)?(?:\/+[\w.-]+){2,}/gu, "<path>").replaceAll(/\d+/gu, "0");
-  return createHash("sha256").update(normalised).digest("hex").slice(0, 8);
-}
-function facts(where, message, godotVersion) {
-  return [
-    ["Where", where],
-    ["Error", message],
-    ["Version", `gdharness ${SERVER_VERSION}`],
-    ["Runtime", `${runtime()}, ${process4.platform} ${process4.arch}`],
-    ["Godot", godotVersion ?? "not known at the point this failed"],
-    ["Signature", defectSignature(where, message)]
-  ];
-}
-function filledTemplate(where, message, godotVersion) {
-  return [
-    `**gdharness version**: ${SERVER_VERSION}`,
-    `**Godot version**: ${godotVersion ?? ""}`,
-    `**Bun version**: ${runtime()}`,
-    `**OS**: ${process4.platform} ${process4.arch}`,
-    "**MCP client**:",
-    "",
-    "## What you did",
-    "",
-    where,
-    "",
-    "## What you expected",
-    "",
-    "The call to answer, or to refuse with a reason.",
-    "",
-    "## What happened",
-    "",
-    "gdharness failed in a way it does not model.",
-    "",
-    "```text",
-    message,
-    "```",
-    "",
-    `Signature: \`${defectSignature(where, message)}\``,
-    "",
-    "If the real cause turned out to be the project, the environment or the call, say so here:",
-    "reaching you as a defect rather than as a refusal naming what would have worked is then the",
-    "thing to fix.",
-    "",
-    "## Anything that makes it reproducible",
-    ""
-  ].join(`
-`);
-}
-function defectReport(where, error, context = {}) {
-  const { godotVersion, seenBefore = 0 } = context;
-  const message = errorMessage(error);
-  const title = `Defect ${defectSignature(where, message)}: ${where}`;
-  const url = `${NEW_ISSUE}?template=bug_report.md&title=${encodeURIComponent(title)}` + `&body=${encodeURIComponent(filledTemplate(where, message, godotVersion))}`;
-  const width = Math.max(...facts(where, message, godotVersion).map(([label]) => (label ?? "").length));
-  return [
-    "gdharness failed in a way it does not model. Whatever went wrong underneath, it reached you",
-    "as a crash rather than as a refusal naming what would have worked, and that much is a defect",
-    "in gdharness however the rest of it turns out.",
-    "",
-    ...seenBefore === 0 ? [
-      "Send the call once more before anything else. Some of what reaches this line is a file",
-      "another process had open, or a connection that dropped, and those are gone by the next",
-      "attempt. If the same Signature comes back, it is not one of those, and repeating it",
-      "further only spends turns."
-    ] : [
-      `You have had this exact failure ${seenBefore === 1 ? "once" : `${seenBefore} times`} in this session already, so it is a`,
-      "state rather than a passing one, and sending the call again will not change it."
-    ],
-    "",
-    ...facts(where, message, godotVersion).map(([label, value]) => `  ${(label ?? "").padEnd(width)}  ${value ?? ""}`),
-    "",
-    "Do not open an issue on your own initiative. Tell the person whose machine this is what",
-    "broke, and ask whether you may report it to gdharness on their behalf. What the report",
-    "carries is the lines above and nothing else, and whether that goes into a public tracker",
-    "is theirs to decide.",
-    "",
-    "If they say yes, this link carries the report already filled in:",
-    url,
-    "",
-    "If they say yes and you have no way to open an issue yourself, give them that link and",
-    "those lines, and stay with them while they file it.",
-    "",
-    "Worth reporting either way. If you can see that what actually went wrong was the project,",
-    "the environment or the call, then this message is the defect: a failure gdharness knows",
-    "about is meant to arrive as a refusal naming what would have worked, not as this. Say that",
-    "in the report and it is the more useful of the two."
-  ].join(`
-`);
-}
+// src/cli.ts
+init_headless();
+init_issues();
 
 // src/prompt.ts
 import process5 from "node:process";
@@ -44025,250 +43944,15 @@ class Ask {
   }
 }
 
-// src/server-version.ts
-init_update_check();
-import { readFileSync as readFileSync5 } from "node:fs";
-var DEBUG_MODE2 = process.env["DEBUG"] === "true";
-var GODOT_DEBUG_MODE_DEFAULT2 = process.env["GODOT_DEBUG"] === "true" || DEBUG_MODE2;
-var SERVER_VERSION2 = (() => {
-  try {
-    const pkg = JSON.parse(readFileSync5(new URL("../package.json", import.meta.url), "utf8"));
-    return typeof pkg.version === "string" ? pkg.version : "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-})();
-
-// src/setup.ts
-init_class_cache();
-init_headless();
-init_resources();
+// src/cli.ts
 init_server_version();
-import { spawnSync as spawnSync2 } from "node:child_process";
-import { createHash as createHash2 } from "node:crypto";
-import {
-  cpSync,
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync4,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync8,
-  rmSync as rmSync4,
-  statSync as statSync3,
-  writeFileSync as writeFileSync6
-} from "node:fs";
-import { dirname as dirname4, join as join9 } from "node:path";
-import { fileURLToPath } from "node:url";
-var ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
-var EDITOR_PLUGINS = ["gdharness_editor", "auto_reload"];
-var RUNTIME_AUTOLOAD = {
-  name: "GdharnessRuntime",
-  path: "addons/gdharness_runtime/runtime_autoload.gd"
-};
-var VERSION_MARKER = ".gdharness-version";
-var DIGEST_MARKER = ".gdharness-digest";
-function editorAddonDigest(from = shippedAddonsDirectory()) {
-  const hash = createHash2("sha256");
-  const walk = (directory, relative) => {
-    for (const name of readdirSync3(directory).sort()) {
-      if (name === VERSION_MARKER || name === DIGEST_MARKER) {
-        continue;
-      }
-      const path = join9(directory, name);
-      const inside = `${relative}/${name}`;
-      if (statSync3(path).isDirectory()) {
-        walk(path, inside);
-      } else {
-        hash.update(`${inside}
-`);
-        hash.update(readFileSync8(path));
-        hash.update(`
-`);
-      }
-    }
-  };
-  for (const name of EDITOR_PLUGINS) {
-    walk(join9(from, name), name);
-  }
-  return hash.digest("hex");
-}
-function installedEditorDigest(projectPath) {
-  const marker = join9(projectPath, "addons", ADDONS[0], DIGEST_MARKER);
-  if (!existsSync7(marker)) {
-    return null;
-  }
-  const said = readFileSync8(marker, "utf8").trim();
-  return said === "" ? null : said;
-}
-function shippedAddonsDirectory() {
-  return join9(dirname4(fileURLToPath(import.meta.url)), "godot", "addons");
-}
-function shippedOperationsScript() {
-  return join9(dirname4(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
-}
-function installAddons(projectPath, from = shippedAddonsDirectory()) {
-  const installed = [];
-  for (const name of ADDONS) {
-    const source = join9(from, name);
-    if (!existsSync7(join9(source, name === "gdharness_runtime" ? "runtime_autoload.gd" : "plugin.cfg"))) {
-      throw new Error(`The package holds no ${name} addon at ${source}.`);
-    }
-    const target = join9(projectPath, "addons", name);
-    const replaced = existsSync7(target);
-    rmSync4(target, { recursive: true, force: true });
-    mkdirSync4(dirname4(target), { recursive: true });
-    cpSync(source, target, { recursive: true });
-    writeFileSync6(join9(target, VERSION_MARKER), `${SERVER_VERSION}
-`);
-    installed.push({ name, path: target, replaced });
-  }
-  writeFileSync6(join9(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
-`);
-  return installed;
-}
-function removeAddons(projectPath) {
-  const removed = [];
-  for (const name of ADDONS) {
-    const target = join9(projectPath, "addons", name);
-    if (existsSync7(target)) {
-      rmSync4(target, { recursive: true, force: true });
-      removed.push(target);
-    }
-  }
-  return removed;
-}
-async function disablePlugins(engine, projectPath, names) {
-  const outcomes = [];
-  for (const name of names) {
-    outcomes.push(await runOperation2(engine, "disable_plugin", { pluginName: name }, projectPath));
-  }
-  return outcomes;
-}
-async function enablePlugins(engine, projectPath, names) {
-  const outcomes = [];
-  for (const name of names) {
-    outcomes.push(await runOperation2(engine, "enable_plugin", { pluginName: name }, projectPath));
-  }
-  return outcomes;
-}
-function autoloadIsOurs(named) {
-  return named === null || named === `res://${RUNTIME_AUTOLOAD.path}`;
-}
-async function setRuntime(engine, projectPath, on) {
-  return on ? await runOperation2(engine, "add_autoload", { name: RUNTIME_AUTOLOAD.name, path: `res://${RUNTIME_AUTOLOAD.path}`, enabled: true }, projectPath) : await runOperation2(engine, "remove_autoload", { name: RUNTIME_AUTOLOAD.name }, projectPath);
-}
-function loaderAmong(projectPath, named) {
-  let byName = null;
-  for (const [entry, path] of named) {
-    if (entry === RUNTIME_AUTOLOAD.name || path === RUNTIME_AUTOLOAD.path) {
-      continue;
-    }
-    let source = null;
-    try {
-      source = readFileSync8(join9(projectPath, path), "utf8");
-    } catch {}
-    if (source?.includes(RUNTIME_AUTOLOAD.path)) {
-      return { name: entry, path, exists: true };
-    }
-    byName ??= path.toLowerCase().includes("gdharness") ? { name: entry, path, exists: source !== null } : null;
-  }
-  return byName;
-}
-function autoloadPaths(settings) {
-  const named = new Map;
-  for (const [name, value] of Object.entries(settings["autoload"] ?? {})) {
-    const said = typeof value === "string" ? value.replace(/^\*/, "") : "";
-    if (said.startsWith("res://")) {
-      named.set(name, said.slice("res://".length));
-    }
-  }
-  return named;
-}
-function trackedByGit(projectPath, wanted) {
-  if (wanted.length === 0) {
-    return new Set;
-  }
-  const asked = spawnSync2("git", ["ls-files", "-z", "--", ...wanted], {
-    cwd: projectPath,
-    encoding: "utf8"
-  });
-  if (asked.status !== 0) {
-    return null;
-  }
-  return new Set(asked.stdout.split("\x00").filter(Boolean));
-}
-function enabledPlugins(settings) {
-  const raw = settings["editor_plugins"]?.["enabled"];
-  if (typeof raw !== "string") {
-    return [];
-  }
-  return [...raw.matchAll(/res:\/\/addons\/([^/"]+)\/plugin\.cfg/g)].map((match) => match[1] ?? "").filter(Boolean);
-}
-function inspectProject(projectPath) {
-  const problems = [];
-  const addons = ADDONS.map((name) => {
-    const directory = join9(projectPath, "addons", name);
-    const marker = join9(directory, VERSION_MARKER);
-    const installed = existsSync7(directory);
-    const version = existsSync7(marker) ? readFileSync8(marker, "utf8").trim() : null;
-    const current = version === SERVER_VERSION;
-    if (!installed) {
-      problems.push(`addons/${name} is not installed; run gdharness setup`);
-    } else if (!current) {
-      problems.push(`addons/${name} is ${version ?? "of an unknown version"}, this gdharness is ${SERVER_VERSION}; run gdharness setup`);
-    }
-    return { name, installed, version, current };
-  });
-  const settings = parseProjectGodot(readFileSync8(join9(projectPath, "project.godot"), "utf8"));
-  const pluginsEnabled = enabledPlugins(settings);
-  for (const name of EDITOR_PLUGINS) {
-    if (!pluginsEnabled.includes(name)) {
-      problems.push(`the ${name} plugin is not enabled in project.godot; run gdharness setup`);
-    }
-  }
-  const autoload = settings["autoload"];
-  const registered = autoload === undefined ? undefined : readString(autoload, RUNTIME_AUTOLOAD.name);
-  const runtimeAutoloadPath = typeof registered === "string" ? registered.replace(/^\*/, "") : null;
-  const named = autoloadPaths(settings);
-  const runtimeLoaderAutoload = loaderAmong(projectPath, named);
-  const runtimeAutoload = runtimeAutoloadPath !== null || runtimeLoaderAutoload !== null;
-  const tracked = trackedByGit(projectPath, [...named.values()]);
-  const addonMissing = (path) => addons.some((addon) => !addon.installed && path.startsWith(`addons/${addon.name}/`));
-  for (const [name, path] of named) {
-    if (!existsSync7(join9(projectPath, path))) {
-      if (!addonMissing(path)) {
-        problems.push(`the ${name} autoload names res://${path}, which is not in this project, so it boots with a missing script; restore that file, or point the autoload at one that is here`);
-      }
-      continue;
-    }
-    if (tracked !== null && !tracked.has(path)) {
-      problems.push(`the ${name} autoload names res://${path}, which git does not carry, so a clone boots with a missing script; commit that file, or point the autoload at one the project tracks`);
-    }
-  }
-  const cached = cachedClasses(projectPath);
-  const staleClasses = cached === null ? [] : staleAgainst(cached, projectPath);
-  if (cached === null) {
-    problems.push("no .godot/global_script_class_cache.cfg: the engine knows no class_name; run project_import refresh_classes or open the editor");
-  } else if (staleClasses.length > 0) {
-    problems.push(`the class cache does not list ${staleClasses.join(", ")}; run project_import refresh_classes or gdharness classes`);
-  }
-  return {
-    projectPath,
-    addons,
-    pluginsEnabled,
-    runtimeAutoload,
-    runtimeAutoloadPath,
-    runtimeLoaderAutoload,
-    staleClasses,
-    classCacheExists: cached !== null,
-    problems
-  };
-}
+init_setup();
 
 // src/skill.ts
 init_setup();
 init_tool_definitions();
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync5, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "node:fs";
-import { basename as basename2, dirname as dirname6, join as join11 } from "node:path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync4, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { basename as basename2, dirname as dirname5, join as join9 } from "node:path";
 
 // src/tool-reference.ts
 init_headless_operations();
@@ -44364,7 +44048,7 @@ function renderToolsMarkdown() {
 
 // src/skill.ts
 var SKILL_NAME = "gdharness";
-var SHARED_SKILLS = join11(".agents", "skills");
+var SHARED_SKILLS = join9(".agents", "skills");
 function skillMarkdown(version) {
   return `---
 name: ${SKILL_NAME}
@@ -44434,7 +44118,7 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | What a property reads right now, on a node whose path you already hold | \`runtime_inspect\` \`property\`, \`runtime_invoke\` |
 | What a property on an object a node holds reads | the same two, with colons: \`_game:clock:speed\` |
 | Which control holds the focus, or anything only a method answers | the same path with a step written as a call, \`get_viewport():gui_get_focus_owner\`, which calls a method taking no arguments and walks into what it returned |
-| Press a button | \`runtime_input click\`, which says what was under the pointer |
+| Press a button | \`runtime_input click\` with \`says\` and the words on it, which finds it and presses it in the same frame and says what was under the pointer. A \`find\` and then a click by the path it answered is two calls over a generated path, and a panel that rebuilds between them frees the button first; \`nodePath\` narrows where \`says\` looks, and several matches are refused with an \`index\` for each |
 | Press the next thing after a click that changed screen | \`runtime_wait until\` with \`says\` and a word the new screen shows (no \`nodePath\` needed: without one the whole game is searched), then the click. A click sent straight after a screen change lands on a control the new screen is about to free, answers \`landed: true\`, and does nothing; a frame count is a number nobody can pick correctly across a cold start and a warm one, and waiting for the words answered in about 130ms where twenty frames had not been enough |
 | Fill in a field | \`runtime_input click\` on it, then \`runtime_input text\` with \`replace\`; a submitted field has to be clicked again |
 | Click somebody standing in a 3D room | \`runtime_input click\` on the Node3D, which aims at what it draws |
@@ -44553,27 +44237,27 @@ whatever the engine said on stderr comes back under \`engine_messages\`.
 function skillFiles(version) {
   return new Map([
     ["SKILL.md", skillMarkdown(version)],
-    [join11("references", "tools.md"), renderToolsMarkdown()]
+    [join9("references", "tools.md"), renderToolsMarkdown()]
   ]);
 }
 function skillDirectories(harnesses, projectPath, exists) {
-  const directories = [join11(projectPath, SHARED_SKILLS, SKILL_NAME)];
+  const directories = [join9(projectPath, SHARED_SKILLS, SKILL_NAME)];
   for (const harness of harnesses) {
     if (harness.skills === undefined) {
       continue;
     }
-    const own = join11(projectPath, harness.skills.dir);
-    if ((!harness.skills.shared || exists(own)) && !directories.includes(join11(own, SKILL_NAME))) {
-      directories.push(join11(own, SKILL_NAME));
+    const own = join9(projectPath, harness.skills.dir);
+    if ((!harness.skills.shared || exists(own)) && !directories.includes(join9(own, SKILL_NAME))) {
+      directories.push(join9(own, SKILL_NAME));
     }
   }
   return directories;
 }
 function everySkillDirectory(projectPath, harnesses) {
-  const directories = new Set([join11(projectPath, SHARED_SKILLS, SKILL_NAME)]);
+  const directories = new Set([join9(projectPath, SHARED_SKILLS, SKILL_NAME)]);
   for (const harness of harnesses) {
     if (harness.skills !== undefined) {
-      directories.add(join11(projectPath, harness.skills.dir, SKILL_NAME));
+      directories.add(join9(projectPath, harness.skills.dir, SKILL_NAME));
     }
   }
   return [...directories];
@@ -44581,52 +44265,52 @@ function everySkillDirectory(projectPath, harnesses) {
 function removeSkill(directories, projectPath) {
   const removed = [];
   for (const directory of directories) {
-    if (existsSync9(directory)) {
-      rmSync6(directory, { recursive: true, force: true });
-      pruneEmpty(dirname6(directory), projectPath);
+    if (existsSync8(directory)) {
+      rmSync5(directory, { recursive: true, force: true });
+      pruneEmpty(dirname5(directory), projectPath);
       removed.push(directory);
     }
   }
   return removed;
 }
 function pruneEmpty(directory, projectPath) {
-  const shared = join11(projectPath, ".agents");
+  const shared = join9(projectPath, ".agents");
   let path = directory;
   while (path !== projectPath && (basename2(path) === "skills" || path === shared)) {
-    if (readdirSync5(path).length > 0) {
+    if (readdirSync4(path).length > 0) {
       return;
     }
-    rmSync6(path, { recursive: true, force: true });
-    path = dirname6(path);
+    rmSync5(path, { recursive: true, force: true });
+    path = dirname5(path);
   }
 }
 function writeSkill(directories, version) {
   const files = skillFiles(version);
   return directories.map((directory) => {
-    const replaced = existsSync9(directory);
-    rmSync6(directory, { recursive: true, force: true });
+    const replaced = existsSync8(directory);
+    rmSync5(directory, { recursive: true, force: true });
     for (const [name, contents] of files) {
-      const path = join11(directory, name);
-      mkdirSync6(dirname6(path), { recursive: true });
-      writeFileSync8(path, contents, "utf8");
+      const path = join9(directory, name);
+      mkdirSync5(dirname5(path), { recursive: true });
+      writeFileSync6(path, contents, "utf8");
     }
     return { path: directory, replaced };
   });
 }
 
 // src/version.ts
-import { readFileSync as readFileSync10 } from "node:fs";
-import { dirname as dirname7, join as join12 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { readFileSync as readFileSync8 } from "node:fs";
+import { dirname as dirname6, join as join10 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 function getLocalVersion() {
-  const currentDirectory = dirname7(fileURLToPath3(import.meta.url));
+  const currentDirectory = dirname6(fileURLToPath2(import.meta.url));
   const packageCandidates = [
-    join12(currentDirectory, "..", "package.json"),
-    join12(currentDirectory, "..", "..", "package.json")
+    join10(currentDirectory, "..", "package.json"),
+    join10(currentDirectory, "..", "..", "package.json")
   ];
   for (const packagePath of packageCandidates) {
     try {
-      const value = JSON.parse(readFileSync10(packagePath, "utf-8"));
+      const value = JSON.parse(readFileSync8(packagePath, "utf-8"));
       if (typeof value === "object" && value !== null && "name" in value && value.name === "gdharness" && "version" in value && typeof value.version === "string") {
         return value.version;
       }
@@ -44639,12 +44323,12 @@ function getLocalVersion() {
 var args = process.argv.slice(2);
 var command = args[0];
 
-class UsageError extends Refusal2 {
+class UsageError extends Refusal {
 }
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve6(named ?? ".");
-  if (!existsSync17(join25(projectPath, "project.godot"))) {
+  if (!existsSync15(join22(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -44652,18 +44336,18 @@ function projectArgument(at) {
 async function engine(projectPath) {
   const located = await new GodotLocator().find();
   if (located.ok) {
-    return { godotPath: located.path, script: shippedOperationsScript(), debug: GODOT_DEBUG_MODE_DEFAULT2 };
+    return { godotPath: located.path, script: shippedOperationsScript(), debug: GODOT_DEBUG_MODE_DEFAULT };
   }
   const recorded = located.named === null && projectPath !== undefined ? recordedEnginePath(projectPath) : null;
   if (recorded === null) {
     const refusal = GodotLocator.refusal(located);
     throw new UsageError(`${refusal.message} ${refusal.advice.join(". ")}.`);
   }
-  return { godotPath: recorded, script: shippedOperationsScript(), debug: GODOT_DEBUG_MODE_DEFAULT2 };
+  return { godotPath: recorded, script: shippedOperationsScript(), debug: GODOT_DEBUG_MODE_DEFAULT };
 }
 function said2(outcome, what) {
   if (!outcome.ok) {
-    throw new Refusal2(`${what}: ${outcome.message}`);
+    throw new Refusal(`${what}: ${outcome.message}`);
   }
   for (const entry of outcome.messages) {
     console.error(`  engine ${entry.severity}: ${entry.text}`);
@@ -44679,11 +44363,11 @@ async function registerRuntime(godot, projectPath) {
   }
   if (autoloadIsOurs(named)) {
     said2(await setRuntime(godot, projectPath, true), "registering the runtime autoload");
-    console.log(`${RUNTIME_AUTOLOAD.name} autoload registered at res://${RUNTIME_AUTOLOAD.path}`);
+    console.log(`${RUNTIME_AUTOLOAD.name} autoload ${named === null ? "registered" : "already registered"} at res://${RUNTIME_AUTOLOAD.path}`);
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync17(join25(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync15(join22(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
     console.log(`  that file is not in this project, so it boots with a missing script: restore it, or point the entry at res://${RUNTIME_AUTOLOAD.path}`);
   }
 }
@@ -44815,7 +44499,7 @@ async function setup() {
       console.log("no harness configured; name one yourself, and gdharness harnesses lists them all");
     }
     if (!args.includes("--no-skill")) {
-      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync17);
+      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync15);
       for (const written of writeSkill(directories, getLocalVersion())) {
         console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
       }
@@ -44909,7 +44593,7 @@ async function upgrade() {
       moved.push(took.from);
     }
   }
-  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync17), version)) {
+  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync15), version)) {
     console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
   }
   console.log(`
@@ -44941,7 +44625,7 @@ function doctorReport(projectPath) {
     process.exitCode = 1;
   }
 }
-async function runtime3() {
+async function runtime2() {
   const state = args[1];
   if (state !== "on" && state !== "off") {
     throw new UsageError("gdharness runtime takes on or off, then the project directory.");
@@ -45050,7 +44734,7 @@ async function main() {
       doctorReport(projectArgument(1));
       return;
     case "runtime":
-      await runtime3();
+      await runtime2();
       return;
     case "classes":
       await classes();
@@ -45079,7 +44763,7 @@ async function main() {
   }
 }
 await main().catch((error) => {
-  if (error instanceof Refusal2) {
+  if (error instanceof Refusal) {
     console.error("gdharness:", error.message);
     process.exit(error instanceof UsageError ? 2 : 1);
   }