gdharness 0.9.4 → 0.9.6

package/build/cli.js

@@ -15382,7 +15382,10 @@ var init_tool_definitions = __esm(() => {
       parameters: {
         projectPath: PROJECT_PATH,
         preset: { type: "string", description: "Preset name from export_presets.cfg." },
-        outputPath: { type: "string", description: "Where the export is written, inside the project." },
+        outputPath: {
+          type: "string",
+          description: `Where the export is written, inside the project. The directory is created if it is not there: Godot's command-line exporter refuses a missing one with "The given export path doesn't exist", which reads as a wrong path in the preset.`
+        },
         debug: { type: "boolean", description: "run: a debug export. Default false." }
       },
       requires: ["projectPath"],
@@ -15393,7 +15396,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "project_test",
-      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. Needs gdUnit4 under addons/gdUnit4.",
+      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. Needs gdUnit4 under addons/gdUnit4.",
       parameters: {
         projectPath: PROJECT_PATH,
         path: {
@@ -15668,7 +15671,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_run",
-      description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way.",
+      description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way.",
       parameters: {
         projectPath: PROJECT_PATH,
         scene: { type: "string", description: "A scene to run instead of the main scene." },
@@ -15791,7 +15794,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["find"],
-          description: "find: part of what the node has written on it, case-insensitively, which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match."
+          description: "find: part of what the node has written on it, case-insensitively, which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern."
         },
         limit: {
           type: "number",
@@ -35141,7 +35144,14 @@ function parseJUnit(xml) {
     suites
   };
 }
-var MalformedReportError, ENTITIES, ATTRIBUTE;
+function whyNoReport(printed, asked) {
+  const missing = printed.map((line) => NO_SUCH_PATH.exec(line)).find((found) => found !== null);
+  if (missing !== undefined) {
+    return `nothing at ${missing[1] ?? asked}`;
+  }
+  return printed.some((line) => NOTHING_RAN.test(line)) ? `no test cases found at ${asked}` : null;
+}
+var MalformedReportError, ENTITIES, ATTRIBUTE, NOTHING_RAN, NO_SUCH_PATH;
 var init_junit = __esm(() => {
   MalformedReportError = class MalformedReportError extends Error {
     constructor(message) {
@@ -35151,6 +35161,8 @@ var init_junit = __esm(() => {
   };
   ENTITIES = { lt: "<", gt: ">", amp: "&", quot: '"', apos: "'" };
   ATTRIBUTE = /\s*([^\s=/>]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/y;
+  NOTHING_RAN = /no test cases found/i;
+  NO_SUCH_PATH = /given directory or file does not exists:\s*(\S+)/i;
 });
 
 // src/lsp_client.ts
@@ -35993,7 +36005,7 @@ var init_setup = __esm(() => {
 
 // src/server.ts
 import { execFile as execFile5, spawn } from "node:child_process";
-import { existsSync as existsSync12, mkdtempSync as mkdtempSync3, readdirSync as readdirSync6, readFileSync as readFileSync13, realpathSync as realpathSync2, rmSync as rmSync8 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync3, readdirSync as readdirSync6, readFileSync as readFileSync13, realpathSync as realpathSync2, rmSync as rmSync8 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
 import { basename as basename2, dirname as dirname9, join as join15, normalize as normalize3 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
@@ -36084,6 +36096,21 @@ function aboveTheRunner(entry) {
     detail: [...entry.detail.slice(0, runner), `[and ${cut} frames inside ${RUNNER_DIRECTORY}]`]
   };
 }
+function elsewhereIn(projectPath, asked) {
+  const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
+  if (wanted === "" || existsSync12(join15(projectPath, wanted))) {
+    return "";
+  }
+  const root = (wanted.split("/")[0] ?? "").toLowerCase();
+  let near = [];
+  try {
+    near = readdirSync6(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 "";
+  }
+  const there = near.map((name) => `res://${name}`).join(" and ");
+  return near.length === 0 ? "" : ` The project does have ${there}.`;
+}
 function hasMainScene(projectFile) {
   const scene = parseProjectGodot(readFileSync13(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
@@ -36911,6 +36938,12 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
+    const folder = dirname9(output.absolutePath);
+    try {
+      mkdirSync7(folder, { recursive: true });
+    } catch (error) {
+      return this.createErrorResponse(`Cannot create ${dirname9(output.relativePath)} to export into: ${errorMessage(error)}`);
+    }
     const debug = readBoolean(args, "debug") ?? false;
     const exportArgs = [
       "--headless",
@@ -36984,6 +37017,7 @@ class GodotServer {
     }
     const reports = "res://.godot/gdharness-reports";
     const ignored = readStringArray(args, "ignore") ?? [];
+    const asked = readString(contained.value, "path") ?? "res://test";
     const cmdArgs = [
       "--headless",
       "--path",
@@ -36993,7 +37027,7 @@ class GodotServer {
       "--ignoreHeadlessMode",
       ...readBoolean(args, "failFast") === true ? [] : ["-c"],
       "-a",
-      readString(contained.value, "path") ?? "res://test",
+      asked,
       ...ignored.flatMap((entry) => ["-i", entry]),
       "-rd",
       reports,
@@ -37043,21 +37077,25 @@ class GodotServer {
       105: "script errors"
     };
     const exitCode = run.exitCode;
-    const verdict = hung ? `hung: killed after ${timeoutMs} ms` : verdicts[exitCode ?? -1] ?? `exit ${exitCode ?? "unknown"}`;
+    const printed = run.log.select({ severity: "info", sinceLastCall: false, limit: 200 }).entries;
+    const said = printed.map((entry) => entry.text);
+    const nothingRan = hung ? null : whyNoReport(said, asked);
+    const verdict = hung ? `hung: killed after ${timeoutMs} ms` : nothingRan ?? verdicts[exitCode ?? -1] ?? `exit ${exitCode ?? "unknown"}`;
     if (report === null) {
+      const note = nothingRan === null ? `The test run wrote no report (${verdict}${reportProblem ? `; ${reportProblem}` : ""}).` : `No tests ran: ${verdict}.${elsewhereIn(project.value.path, asked)}`;
       return {
         content: [
-          {
-            type: "text",
-            text: `The test run wrote no report (${verdict}${reportProblem ? `; ${reportProblem}` : ""}).`
-          },
+          { type: "text", text: note },
           {
             type: "text",
             text: JSON.stringify({
+              passed: false,
+              verdict,
+              tests: 0,
               exitCode,
               hung,
               arguments: cmdArgs,
-              entries: run.log.select({ severity: "info", sinceLastCall: false, limit: 60 }).entries
+              entries: printed.slice(0, 60)
             }, null, 2)
           }
         ],
@@ -38607,6 +38645,16 @@ function disconnect(harness, projectPath) {
 `, "utf8");
   return { harness, path, action: "removed" };
 }
+function harnessNote(moved, now) {
+  if (moved.length === 0) {
+    return `  2. Your harness config already named this version, but the server it is running is
+` + `     whichever one it spawned when the session started, which this cannot see from here.
+` + "     Reconnect the MCP server, or restart the harness.";
+  }
+  return `  2. Your harness is still running the server it spawned from ${moved.join(", ")}.
+` + `     Its config names ${now} now.
+` + "     Reconnect the MCP server, or restart the harness.";
+}
 function launchedBy(entry) {
   if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
     return;
@@ -38891,6 +38939,7 @@ init_class_cache();
 init_headless();
 init_resources();
 init_server_version();
+import { spawnSync } from "node:child_process";
 import { cpSync, existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync7, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "node:fs";
 import { dirname as dirname3, join as join8 } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -38953,6 +39002,29 @@ async function enablePlugins(engine, projectPath, names) {
 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 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 = spawnSync("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") {
@@ -38984,6 +39056,13 @@ function inspectProject(projectPath) {
   }
   const autoload = settings["autoload"];
   const runtimeAutoload = autoload !== undefined && typeof readString(autoload, RUNTIME_AUTOLOAD.name) === "string";
+  const named = autoloadPaths(settings);
+  const tracked = trackedByGit(projectPath, [...named.values()]);
+  for (const [name, path] of named) {
+    if (tracked !== null && !tracked.has(path) && existsSync7(join8(projectPath, 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) {
@@ -39118,6 +39197,9 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 These need the runtime autoload, which \`gdharness setup\` registers. \`runtime_capture\` needs a
 window and refuses headless rather than handing back the last frame anything drew.
 
+A headless game answers; a \`godot -s\` script run does not. It has no game in it, so the autoload
+stays quiet there rather than announcing a test tier as the project.
+
 The autoload reaches an export. \`gdharness runtime off\` in the project before shipping.
 
 ## At a breakpoint
@@ -39342,6 +39424,7 @@ function reportConnection(group, launch, projectPath) {
       console.log(`  ${harness.name}: ${harness.manual}`);
     }
   }
+  return written.wasLaunchedBy;
 }
 function nextSteps(projectPath, runtime) {
   console.log(`
@@ -39475,8 +39558,12 @@ async function upgrade() {
   said2(await runOperation(godot, "refresh_class_cache", {}, projectPath), "rebuilding the class list");
   const launch = launchFor(version, godot.godotPath, projectPath);
   const already = HARNESSES.filter((harness) => registered(harness, projectPath));
+  const moved = [];
   for (const group of groupByFile(already, projectPath)) {
-    reportConnection(group, launch, projectPath);
+    const was = reportConnection(group, launch, projectPath);
+    if (was !== undefined && !moved.includes(was)) {
+      moved.push(was);
+    }
   }
   if (already.length === 0) {
     console.log("no harness config names gdharness, so none was re-pinned");
@@ -39488,8 +39575,7 @@ async function upgrade() {
 On ${version}. Two things this could not do for you:`);
   console.log(`  1. The open editor is still running the addons it loaded at startup. Restart it with the
 ` + "     editor_launch restart tool, which closes and reopens the window.");
-  console.log(`  2. Your harness is still running gdharness ${installed}: its config named that version when
-` + "     the server was spawned. Reconnect the MCP server, or restart the harness.");
+  console.log(harnessNote(moved, [launch.command, ...launch.args].join(" ")));
 }
 function doctorReport(projectPath) {
   const report = inspectProject(projectPath);

package/build/godot/addons/gdharness_runtime/runtime_autoload.gd

@@ -23,6 +23,12 @@ const BIND_ADDRESS_SETTING: String = "gdharness/runtime/bind_address"
 ## expects. A fixed port is for a client that cannot read the announcement.
 const PORT_SETTING: String = "gdharness/runtime/port"
 
+## How the engine is told to run a script instead of the game: `godot -s thing.gd`.
+const SCRIPT_FLAGS: PackedStringArray = ["-s", "--script"]
+
+## Serve a script run anyway, for somebody driving a `-s` script rather than a game.
+const SCRIPT_RUNS_SETTING: String = "gdharness/runtime/serve_script_runs"
+
 var values: Values = Values.new()
 
 # The modules are members and not locals of _init, because a Callable holds its object by id
@@ -161,6 +167,15 @@ func _start_server() -> void:
 		_enabled = false
 		return
 
+	# And a script run has nothing to serve. Autoloads come up for `godot -s` as well, so a test
+	# tier or a batch tool binds a loopback port and writes an announcement under the project's
+	# own path: a gate that starts sixteen engines at once announces sixteen games that are not
+	# games, and a client asking the runtime anything while they run can be answered by whichever
+	# of them replies first. Measured on two projects before it was written here.
+	if _script_run() and not bool(ProjectSettings.get_setting(SCRIPT_RUNS_SETTING, false)):
+		_enabled = false
+		return
+
 	_server = TCPServer.new()
 	# listen() defaults bind_address to "*", which exposes the game to the whole network.
 	var bind_address: String = str(ProjectSettings.get_setting(BIND_ADDRESS_SETTING, DEFAULT_BIND_ADDRESS))
@@ -180,6 +195,15 @@ func _start_server() -> void:
 	print("[gdharness] runtime listening on %s:%d, announced at %s" % [bind_address, _port, _announcement])
 
 
+## Whether the engine was told to run a script rather than the game.
+func _script_run() -> bool:
+	var given: PackedStringArray = OS.get_cmdline_args()
+	for flag: String in SCRIPT_FLAGS:
+		if given.has(flag):
+			return true
+	return false
+
+
 ## Where the announcement goes. The server derives the same path with the same precedence, so
 ## the two only meet if this stays in step with `runtimeDirectory` in src/runtime-client.ts.
 func _announcement_directory() -> String:

package/build/godot/addons/gdharness_runtime/runtime_queries.gd

@@ -160,6 +160,17 @@ static func _is_literal(pattern: String) -> bool:
 	return not pattern.is_empty() and not pattern.contains("*") and not pattern.contains("?")
 
 
+## Whether [param said] is what a find asked for in [param wanted].
+##
+## A plain word is a contains, which is what somebody looking for the row about a person means. A
+## pattern is a glob, because [code]namePattern[/code] beside it is one and nobody writes `*Still*`
+## in one field meaning a glob and in the other meaning those characters. Written as a contains
+## only, a glob matched nothing at all and an empty answer reads as a control that is not on the
+## screen: twice in one session here, over a button that was.
+static func _says(said: String, wanted: String) -> bool:
+	return said.containsn(wanted) if _is_literal(wanted) else said.matchn(wanted)
+
+
 ## Every filter but the name, so a find that came back empty can say how many nodes the name was
 ## the only thing standing between it and.
 func _matches_apart_from_name(node: Node, wanted: Dictionary[String, String]) -> bool:
@@ -168,7 +179,7 @@ func _matches_apart_from_name(node: Node, wanted: Dictionary[String, String]) ->
 	# What this node says, rather than everything said underneath it. A row is then found by the
 	# label in it, and the path answered is that label's, which is where the words a caller is
 	# looking at actually are: matching every container above it would answer with the screen.
-	if not wanted["says"].is_empty() and not said_by(node).containsn(wanted["says"]):
+	if not wanted["says"].is_empty() and not _says(said_by(node), wanted["says"]):
 		return false
 	var script: Variant = node.get_script()
 	if not wanted["script"].is_empty():

package/build/index.js

@@ -10126,7 +10126,7 @@ function defectReport(where, error, godotVersion) {
 
 // src/server.ts
 import { execFile as execFile3, spawn } from "node:child_process";
-import { existsSync as existsSync7, mkdtempSync as mkdtempSync2, readdirSync as readdirSync5, readFileSync as readFileSync9, realpathSync as realpathSync2, rmSync as rmSync4 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, mkdtempSync as mkdtempSync2, readdirSync as readdirSync5, readFileSync as readFileSync9, realpathSync as realpathSync2, rmSync as rmSync4 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
 import { basename, dirname as dirname4, join as join9, normalize as normalize2 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
@@ -26583,6 +26583,15 @@ function parseJUnit(xml) {
     suites
   };
 }
+var NOTHING_RAN = /no test cases found/i;
+var NO_SUCH_PATH = /given directory or file does not exists:\s*(\S+)/i;
+function whyNoReport(printed, asked) {
+  const missing = printed.map((line) => NO_SUCH_PATH.exec(line)).find((found) => found !== null);
+  if (missing !== undefined) {
+    return `nothing at ${missing[1] ?? asked}`;
+  }
+  return printed.some((line) => NOTHING_RAN.test(line)) ? `no test cases found at ${asked}` : null;
+}
 
 // src/lsp_client.ts
 import { realpathSync } from "node:fs";
@@ -27976,7 +27985,10 @@ var TOOL_SPECS = [
     parameters: {
       projectPath: PROJECT_PATH,
       preset: { type: "string", description: "Preset name from export_presets.cfg." },
-      outputPath: { type: "string", description: "Where the export is written, inside the project." },
+      outputPath: {
+        type: "string",
+        description: `Where the export is written, inside the project. The directory is created if it is not there: Godot's command-line exporter refuses a missing one with "The given export path doesn't exist", which reads as a wrong path in the preset.`
+      },
       debug: { type: "boolean", description: "run: a debug export. Default false." }
     },
     requires: ["projectPath"],
@@ -27987,7 +27999,7 @@ var TOOL_SPECS = [
   },
   {
     name: "project_test",
-    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. Needs gdUnit4 under addons/gdUnit4.",
+    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. Needs gdUnit4 under addons/gdUnit4.",
     parameters: {
       projectPath: PROJECT_PATH,
       path: {
@@ -28262,7 +28274,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_run",
-    description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way.",
+    description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way.",
     parameters: {
       projectPath: PROJECT_PATH,
       scene: { type: "string", description: "A scene to run instead of the main scene." },
@@ -28385,7 +28397,7 @@ var TOOL_SPECS = [
       says: {
         type: "string",
         ops: ["find"],
-        description: "find: part of what the node has written on it, case-insensitively, which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match."
+        description: "find: part of what the node has written on it, case-insensitively, which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern."
       },
       limit: {
         type: "number",
@@ -28864,6 +28876,21 @@ function aboveTheRunner(entry) {
     detail: [...entry.detail.slice(0, runner), `[and ${cut} frames inside ${RUNNER_DIRECTORY}]`]
   };
 }
+function elsewhereIn(projectPath, asked) {
+  const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
+  if (wanted === "" || existsSync7(join9(projectPath, wanted))) {
+    return "";
+  }
+  const root = (wanted.split("/")[0] ?? "").toLowerCase();
+  let near = [];
+  try {
+    near = readdirSync5(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 "";
+  }
+  const there = near.map((name) => `res://${name}`).join(" and ");
+  return near.length === 0 ? "" : ` The project does have ${there}.`;
+}
 function hasMainScene(projectFile) {
   const scene = parseProjectGodot(readFileSync9(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
@@ -29691,6 +29718,12 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
+    const folder = dirname4(output.absolutePath);
+    try {
+      mkdirSync4(folder, { recursive: true });
+    } catch (error) {
+      return this.createErrorResponse(`Cannot create ${dirname4(output.relativePath)} to export into: ${errorMessage(error)}`);
+    }
     const debug = readBoolean(args, "debug") ?? false;
     const exportArgs = [
       "--headless",
@@ -29764,6 +29797,7 @@ class GodotServer {
     }
     const reports = "res://.godot/gdharness-reports";
     const ignored = readStringArray(args, "ignore") ?? [];
+    const asked = readString(contained.value, "path") ?? "res://test";
     const cmdArgs = [
       "--headless",
       "--path",
@@ -29773,7 +29807,7 @@ class GodotServer {
       "--ignoreHeadlessMode",
       ...readBoolean(args, "failFast") === true ? [] : ["-c"],
       "-a",
-      readString(contained.value, "path") ?? "res://test",
+      asked,
       ...ignored.flatMap((entry) => ["-i", entry]),
       "-rd",
       reports,
@@ -29823,21 +29857,25 @@ class GodotServer {
       105: "script errors"
     };
     const exitCode = run.exitCode;
-    const verdict = hung ? `hung: killed after ${timeoutMs} ms` : verdicts[exitCode ?? -1] ?? `exit ${exitCode ?? "unknown"}`;
+    const printed = run.log.select({ severity: "info", sinceLastCall: false, limit: 200 }).entries;
+    const said = printed.map((entry) => entry.text);
+    const nothingRan = hung ? null : whyNoReport(said, asked);
+    const verdict = hung ? `hung: killed after ${timeoutMs} ms` : nothingRan ?? verdicts[exitCode ?? -1] ?? `exit ${exitCode ?? "unknown"}`;
     if (report === null) {
+      const note = nothingRan === null ? `The test run wrote no report (${verdict}${reportProblem ? `; ${reportProblem}` : ""}).` : `No tests ran: ${verdict}.${elsewhereIn(project.value.path, asked)}`;
       return {
         content: [
-          {
-            type: "text",
-            text: `The test run wrote no report (${verdict}${reportProblem ? `; ${reportProblem}` : ""}).`
-          },
+          { type: "text", text: note },
           {
             type: "text",
             text: JSON.stringify({
+              passed: false,
+              verdict,
+              tests: 0,
               exitCode,
               hung,
               arguments: cmdArgs,
-              entries: run.log.select({ severity: "info", sinceLastCall: false, limit: 60 }).entries
+              entries: printed.slice(0, 60)
             }, null, 2)
           }
         ],

package/package.json

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