gdharness 0.6.8 → 0.7.0

package/build/cli.js

@@ -15034,6 +15034,13 @@ function readParams(params, key) {
 }
 
 // src/tool-definitions.ts
+function opTakes(spec, op, name) {
+  const ops = spec.parameters[name]?.ops;
+  return ops === undefined || ops.includes(op);
+}
+function argumentsOf(spec, op) {
+  return Object.keys(spec.parameters).filter((name) => opTakes(spec, op, name));
+}
 function toolSpec(name) {
   return SPECS_BY_NAME[name];
 }
@@ -15059,7 +15066,8 @@ function buildToolDefinitions() {
       };
     }
     for (const [name, schema] of Object.entries(spec.parameters)) {
-      properties[name] = schema;
+      const { ops: _ops, ...carried } = schema;
+      properties[name] = carried;
     }
     const required = [...spec.requires];
     if (spec.operations && !spec.defaultOperation) {
@@ -15380,7 +15388,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "project_test",
-      description: "Runs the project's gdUnit4 tests headless and answers with every case: which failed, where, and what the assertion said. 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. Needs gdUnit4 under addons/gdUnit4.",
       parameters: {
         projectPath: PROJECT_PATH,
         path: {
@@ -15749,35 +15757,46 @@ var init_tool_definitions = __esm(() => {
         projectPath: RUNNING_PROJECT_PATH,
         nodePath: {
           type: "string",
+          ops: ["tree", "text", "find", "rect", "property"],
           description: "tree, find, text: where to start, default /root. rect: the node to place. property: the node to read."
         },
         property: {
           type: "string",
+          ops: ["property", "find"],
           description: "property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label."
         },
-        depth: { type: "number", description: "tree: levels to descend. Default 3." },
+        depth: { type: "number", ops: ["tree"], description: "tree: levels to descend. Default 3." },
         includeProperties: {
           type: "boolean",
+          ops: ["tree"],
           description: "tree: include each node's properties. Default false."
         },
         className: {
           type: "string",
+          ops: ["find"],
           description: "find: a native class, matching its subclasses too, or a class_name."
         },
-        script: { type: "string", description: "find: the script file the node carries." },
+        script: { type: "string", ops: ["find"], description: "find: the script file the node carries." },
         namePattern: {
           type: "string",
+          ops: ["find"],
           description: 'find: a case-insensitive glob on the node name, such as "Enemy*".'
         },
-        group: { type: "string", description: "find: a group the node is in." },
-        limit: { type: "number", description: "find: the most nodes to answer with. Default 100." },
+        group: { type: "string", ops: ["find"], description: "find: a group the node is in." },
+        limit: {
+          type: "number",
+          ops: ["find", "text"],
+          description: "find: the most nodes to answer with, default 100. text: the most lines, default 500, with truncated saying whether there were more."
+        },
         includeHidden: {
           type: "boolean",
+          ops: ["text"],
           description: "text: read hidden nodes as well, for checking that something is not showing. Default false."
         },
         metrics: {
           type: "array",
           items: { type: "string" },
+          ops: ["metrics"],
           description: "metrics: which to read. Default all."
         }
       },
@@ -15810,10 +15829,14 @@ var init_tool_definitions = __esm(() => {
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         nodePath: { type: "string", description: 'Absolute node path, such as "/root/Main/Player".' },
-        property: { type: "string" },
-        value: { description: "set: the value, fitted to the property's type." },
-        method: { type: "string" },
-        args: { type: "array", description: "call: the arguments, fitted to the method's parameter types." }
+        property: { type: "string", ops: ["set"] },
+        value: { ops: ["set"], description: "set: the value, fitted to the property's type." },
+        method: { type: "string", ops: ["call"] },
+        args: {
+          type: "array",
+          ops: ["call"],
+          description: "call: the arguments, fitted to the method's parameter types."
+        }
       },
       requires: ["nodePath"],
       operations: {
@@ -15828,6 +15851,7 @@ var init_tool_definitions = __esm(() => {
         projectPath: RUNNING_PROJECT_PATH,
         viewportPath: {
           type: "string",
+          ops: ["viewport"],
           description: "viewport: the Viewport node. Default the root viewport."
         },
         width: { type: "number", description: "Scale the image to this width." },
@@ -15847,38 +15871,69 @@ var init_tool_definitions = __esm(() => {
         projectPath: RUNNING_PROJECT_PATH,
         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."
         },
-        action: { type: "string", description: "action: the InputMap action name." },
+        action: { type: "string", ops: ["action"], description: "action: the InputMap action name." },
         pressed: {
           type: "boolean",
-          description: "action, key: leave it out and the press is a whole one, down and up a frame apart. true holds it down, false lets go of one being held."
+          ops: ["action", "key", "mouse_click"],
+          description: "action, key: leave it out and the press is a whole one, down and up a frame apart. true holds it down, false lets go of one being held. mouse_click is one raw event, so it is down unless you say false."
         },
-        strength: { type: "number", description: "action: 0 to 1. Default 1." },
+        strength: { type: "number", ops: ["action"], description: "action: 0 to 1. Default 1." },
         keycode: {
           type: ["string", "number"],
+          ops: ["key"],
           description: 'key: the key name, such as "Space" or "A", or its Godot keycode.'
         },
         text: {
           type: "string",
+          ops: ["text", "choose"],
           description: "text: what to type. A newline is Enter and a tab is Tab. choose: the item to take, by what it says."
         },
+        replace: {
+          type: "boolean",
+          ops: ["text"],
+          description: 'text: true writes over what the field already says, which is what filling one in means. Default false types at the caret, so a field reading 2.1 typed "0.3" at reads 2.10.3. The answer says what the field holds afterwards either way.'
+        },
         index: {
           type: "number",
+          ops: ["choose"],
           description: "choose: the item to take, by where it is in the list, when text will not do."
         },
-        shift: { type: "boolean" },
-        ctrl: { type: "boolean" },
-        alt: { type: "boolean" },
-        x: { type: "number", description: "mouse_click, mouse_motion: window pixels." },
-        y: { type: "number", description: "mouse_click, mouse_motion: window pixels." },
+        shift: { type: "boolean", ops: ["key"] },
+        ctrl: { type: "boolean", ops: ["key"] },
+        alt: { type: "boolean", ops: ["key"] },
+        x: {
+          type: "number",
+          ops: ["mouse_click", "mouse_motion"],
+          description: "mouse_click, mouse_motion: window pixels."
+        },
+        y: {
+          type: "number",
+          ops: ["mouse_click", "mouse_motion"],
+          description: "mouse_click, mouse_motion: window pixels."
+        },
         button: {
           type: ["string", "number"],
+          ops: ["click", "mouse_click"],
           description: "click, mouse_click: left, right, middle, wheel_up or wheel_down, or a button number. Default left."
         },
-        doubleClick: { type: "boolean", description: "click, mouse_click: default false." },
-        relativeX: { type: "number", description: "mouse_motion: movement since the last event." },
-        relativeY: { type: "number", description: "mouse_motion: movement since the last event." }
+        doubleClick: {
+          type: "boolean",
+          ops: ["click", "mouse_click"],
+          description: "click, mouse_click: default false."
+        },
+        relativeX: {
+          type: "number",
+          ops: ["mouse_motion"],
+          description: "mouse_motion: movement since the last event."
+        },
+        relativeY: {
+          type: "number",
+          ops: ["mouse_motion"],
+          description: "mouse_motion: movement since the last event."
+        }
       },
       requires: [],
       operations: {
@@ -15907,14 +15962,16 @@ var init_tool_definitions = __esm(() => {
         projectPath: RUNNING_PROJECT_PATH,
         frames: {
           type: "number",
+          ops: ["frames"],
           description: "frames: how many to let pass, 1 to 600. More than that is refused."
         },
-        nodePath: { type: "string", description: "signal, until: the node." },
-        signal: { type: "string", description: "signal: the signal name." },
-        property: { type: "string", description: "until: the property name." },
-        value: { description: "until: the value to wait for, fitted to the property's type." },
+        nodePath: { type: "string", ops: ["signal", "until"], description: "signal, until: the node." },
+        signal: { type: "string", ops: ["signal"], description: "signal: the signal name." },
+        property: { type: "string", ops: ["until"], description: "until: the property name." },
+        value: { ops: ["until"], description: "until: the value to wait for, fitted to the property's type." },
         timeoutMs: {
           type: "number",
+          ops: ["signal", "until"],
           description: "signal, until: how long to wait before answering anyway, 1 to 120000. Default 5000."
         }
       },
@@ -15962,6 +16019,7 @@ var init_tool_definitions = __esm(() => {
       parameters: {
         frameId: {
           type: "number",
+          ops: ["variables"],
           description: "variables: which frame, from a stack answer. Default the innermost."
         }
       },
@@ -35923,6 +35981,17 @@ function realPathOr(path) {
     return path;
   }
 }
+function aboveTheRunner(entry) {
+  const runner = entry.detail.findIndex((line) => line.includes(RUNNER_DIRECTORY));
+  if (runner < 0) {
+    return entry;
+  }
+  const cut = entry.detail.length - runner;
+  return {
+    ...entry,
+    detail: [...entry.detail.slice(0, runner), `[and ${cut} frames inside ${RUNNER_DIRECTORY}]`]
+  };
+}
 function hasMainScene(projectFile) {
   const scene = parseProjectGodot(readFileSync12(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
@@ -36265,6 +36334,15 @@ class GodotServer {
         };
       }
     }
+    if (op !== null) {
+      const elsewhere = Object.keys(args).filter((key) => key !== "op" && !opTakes(spec, op, key));
+      if (elsewhere.length > 0) {
+        return {
+          ok: false,
+          response: this.createErrorResponse(`${spec.name} ${op} does not take ${elsewhere.join(", ")}. ${op} takes: ${argumentsOf(spec, op).join(", ")}.`)
+        };
+      }
+    }
     const required = [...spec.requires, ...op !== null ? spec.operations?.[op]?.requires ?? [] : []];
     const missing = required.filter((field) => {
       const value = Object.hasOwn(args, field) ? args[field] : undefined;
@@ -36389,7 +36467,8 @@ class GodotServer {
             return await this.handleRuntimeCommand("read_text", {
               projectPath: args["projectPath"],
               root: readNonEmptyString(args, "nodePath") ?? "/root",
-              include_hidden: readBoolean(args, "includeHidden") ?? false
+              include_hidden: readBoolean(args, "includeHidden") ?? false,
+              limit: readPositiveNumber(args, "limit") ?? 500
             });
           case "rect":
             return await this.handleRuntimeCommand("get_rect", {
@@ -36815,7 +36894,7 @@ class GodotServer {
       rmSync8(reportsDir, { recursive: true, force: true });
       rmSync8(userData, { recursive: true, force: true });
     }
-    const engineEntries = run.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries;
+    const engineEntries = run.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries.map(aboveTheRunner);
     const verdicts = {
       0: "passed",
       100: "failures",
@@ -36847,6 +36926,7 @@ class GodotServer {
       };
     }
     const failed = report.suites.flatMap((suite) => suite.cases.filter((entry) => entry.status === "failed" || entry.status === "error").map((entry) => ({ ...entry, path: suite.path })));
+    const unclean = report.suites.filter((suite) => suite.failures > 0 || suite.errors > 0 || suite.skipped > 0);
     return this.jsonTextResponse({
       passed: !hung && exitCode === 0 && report.failures === 0 && report.errors === 0,
       verdict,
@@ -36857,7 +36937,7 @@ class GodotServer {
       skipped: report.skipped,
       time: report.time,
       failed,
-      suites: report.suites.map((suite) => ({
+      suites: unclean.map((suite) => ({
         name: suite.name,
         path: suite.path,
         tests: suite.tests,
@@ -36866,6 +36946,7 @@ class GodotServer {
         skipped: suite.skipped,
         time: suite.time
       })),
+      suitesPassed: report.suites.length - unclean.length,
       engineErrors: run.log.count("error"),
       engineWarnings: run.log.count("warning"),
       engineEntries,
@@ -37431,38 +37512,33 @@ class GodotServer {
     });
   }
   async handleRuntimeWait(op, args) {
+    if (op === "frames") {
+      const frames = readPositiveNumber(args, "frames") ?? 1;
+      const waited = patienceForFrames(frames, this.runtimeTimeoutMs());
+      return await this.handleRuntimeCommand("wait_frames", { projectPath: args["projectPath"], frames }, waited);
+    }
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 5000;
     const nodePath = readNonEmptyString(args, "nodePath") ?? "";
     const patience = Math.max(this.runtimeTimeoutMs(), timeoutMs + 5000);
-    switch (op) {
-      case "frames": {
-        const frames = readPositiveNumber(args, "frames") ?? 1;
-        const waited = patienceForFrames(frames, patience);
-        return await this.handleRuntimeCommand("wait_frames", { projectPath: args["projectPath"], frames }, waited);
-      }
-      case "signal":
-        return await this.handleRuntimeCommand("wait_signal", {
-          projectPath: args["projectPath"],
-          path: nodePath,
-          signal: readString(args, "signal") ?? "",
-          timeout_ms: timeoutMs
-        }, patience);
-      default:
-        return await this.handleRuntimeCommand("wait_until", {
-          projectPath: args["projectPath"],
-          path: nodePath,
-          property: readString(args, "property") ?? "",
-          value: args["value"],
-          timeout_ms: timeoutMs
-        }, patience);
-    }
+    return op === "signal" ? await this.handleRuntimeCommand("wait_signal", {
+      projectPath: args["projectPath"],
+      path: nodePath,
+      signal: readString(args, "signal") ?? "",
+      timeout_ms: timeoutMs
+    }, patience) : await this.handleRuntimeCommand("wait_until", {
+      projectPath: args["projectPath"],
+      path: nodePath,
+      property: readString(args, "property") ?? "",
+      value: args["value"],
+      timeout_ms: timeoutMs
+    }, patience);
   }
 }
 async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run5, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, SLOWEST_FRAME_RATE = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, HEADLESS_OPERATIONS, PROJECT_INFO_SECTIONS;
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run5, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, SLOWEST_FRAME_RATE = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, HEADLESS_OPERATIONS, PROJECT_INFO_SECTIONS, RUNNER_DIRECTORY = "addons/gdUnit4/";
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();
@@ -38766,7 +38842,9 @@ function renderToolsMarkdown() {
         const needs = [...tool.requires, ...spec.requires];
         const isDefault = tool.defaultOperation === op ? " (default)" : "";
         const wants = needs.length > 0 ? ` Needs: ${needs.map((name) => `\`${name}\``).join(", ")}.` : "";
-        lines.push(`- \`op: ${op}\`${isDefault}: ${spec.summary}.${wants}`);
+        const spare = argumentsOf(tool, op).filter((name) => !needs.includes(name) && name !== "projectPath");
+        const takes = spare.length > 0 ? ` Takes: ${spare.map((name) => `\`${name}\``).join(", ")}.` : "";
+        lines.push(`- \`op: ${op}\`${isDefault}: ${spec.summary}.${wants}${takes}`);
       }
       lines.push("");
     } else if (tool.requires.length > 0) {
@@ -38830,7 +38908,7 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | Where a control is, and whether it is visible | \`runtime_inspect\` \`find\`, \`rect\` |
 | What a property reads right now | \`runtime_inspect\` \`property\`, \`runtime_invoke\` |
 | Press a button | \`runtime_input click\`, which says what was under the pointer |
-| Fill in a field | \`runtime_input click\` on it, then \`runtime_input text\`; a submitted field has to be clicked again |
+| 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 |
 | Pick something out of a dropdown | \`runtime_input choose\` on it, by what the item says |
 | Answer a dialog, or press a bound key | \`runtime_input action\` or \`key\`, a whole press unless you hold it |

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

@@ -155,6 +155,11 @@ func inject_key(params: Dictionary) -> Dictionary:
 ## Pushed into the viewport for the reason [method click] is, and it matters more here: the focus
 ## is what decides where a character lands, so a caller that clicked a field and then typed would
 ## otherwise have both waiting in the same queue with nothing said about the order.
+##
+## [code]replace[/code] is for a field that already says something, which is most of them: typing
+## lands at the caret, so a spin box reading 2.1 typed "0.3" at reads 2.10.3 and parses back to
+## 2.1, and the answer said four characters had gone in. What the field holds afterwards is read
+## back now rather than echoed from the request, so a call that typed somewhere unhelpful says so.
 func inject_text(params: Dictionary) -> Dictionary:
 	var text: String = String(params.get("text", ""))
 	if text.is_empty():
@@ -166,6 +171,7 @@ func inject_text(params: Dictionary) -> Dictionary:
 	if not shut.is_empty():
 		return {"type": "error", "message": shut}
 
+	var replaced: bool = bool(params.get("replace", false)) and _select_everything(focused)
 	for index: int in text.length():
 		var down: InputEventKey = _typed(text.unicode_at(index))
 		viewport.push_input(down)
@@ -186,9 +192,44 @@ func inject_text(params: Dictionary) -> Dictionary:
 		"text": text,
 		"characters": text.length(),
 		"into": into,
+		"replaced": replaced,
+		"holds": _what_it_holds(focused),
 	}
 
 
+## Selects everything in [param focused] so the next character typed writes over it, and answers
+## whether there was a field to select in.
+##
+## Through the control rather than through a Ctrl+A, which is the one part of filling a field that
+## cannot honestly be sent as a key: the shortcut is Cmd+A on macOS and is an [InputMap] action a
+## project is free to unbind, and a caller asking for the field to be replaced would then be typing
+## on the end of what was there. The replacement itself is still every character a player types.
+static func _select_everything(focused: Control) -> bool:
+	var field: LineEdit = focused as LineEdit
+	if field != null:
+		field.select_all()
+		return true
+	var box: TextEdit = focused as TextEdit
+	if box == null:
+		return false
+	box.select_all()
+	return true
+
+
+## What the field says now, or null where the focus is not a field at all.
+##
+## A spin box rewrites its own text out of the number it parsed, so this is the only thing that
+## says whether what was typed became what the field means.
+static func _what_it_holds(focused: Control) -> Variant:
+	var field: LineEdit = focused as LineEdit
+	if field != null:
+		return field.text
+	var box: TextEdit = focused as TextEdit
+	if box == null:
+		return null
+	return box.text
+
+
 ## Why nothing typed would reach [param focused], or "" when it would.
 ##
 ## Having the focus is not the same as being edited. Since Godot 4.4 a field is focused and shut

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

@@ -10,8 +10,8 @@ const Values = preload("runtime_values.gd")
 const FIND_LIMIT: int = 100
 const FIND_LIMIT_CEILING: int = 1000
 
-## The most lines one read answers with. A screen is a few dozen; a thousand is a tree somebody
-## pointed this at by mistake.
+## The most lines one read answers with, unless asked for fewer. A screen is a few dozen; a
+## thousand is a tree somebody pointed this at by mistake.
 const READ_LIMIT: int = 500
 
 var _host: Node
@@ -153,22 +153,32 @@ func _matches(
 ## A hidden node is left out and so is everything under it, because what a player reads is what is
 ## drawn. [param include_hidden] asks for the lot instead, which is what a caller checking that
 ## something is not showing wants.
+##
+## [param limit] is the first few lines rather than all of them, which is how the top of a screen
+## is read without the hall under it: the bar along the top of a guild is eleven lines and the
+## panel it sits on is two hundred.
 func read_text(params: Dictionary) -> Dictionary:
 	var root_path: String = str(params.get("root", "/root"))
 	var include_hidden: bool = bool(params.get("include_hidden", false))
+	var limit: int = clampi(int(params.get("limit", READ_LIMIT)), 1, READ_LIMIT)
 
 	var root: Node = _host.get_tree().root.get_node_or_null(root_path)
 	if root == null:
 		return {"type": "error", "message": "Node not found: " + root_path}
 
-	var lines: PackedStringArray = PackedStringArray()
-	_read_into(root, include_hidden, lines)
+	# One line further than asked for, so that whether anything was left behind is read off the
+	# walk rather than guessed at from the count: a panel of exactly as many lines as the caller
+	# asked for is one they have read all of, and saying otherwise sends them back for nothing.
+	var read: PackedStringArray = PackedStringArray()
+	_read_into(root, include_hidden, limit + 1, read)
+	var more: bool = read.size() > limit
+	var lines: PackedStringArray = read.slice(0, limit) if more else read
 	return {
 		"type": "text",
 		"root": root_path,
 		"lines": lines,
 		"count": lines.size(),
-		"truncated": lines.size() >= READ_LIMIT,
+		"truncated": more,
 	}
 
 
@@ -180,8 +190,8 @@ func read_text(params: Dictionary) -> Dictionary:
 ## screen full of forms answered with every label on it and none of the values in it. The hidden
 ## check covers a [Window] for the same walk: a dropdown's popup is a child that is not drawn
 ## until it is opened, and reading a closed menu would put every item on the screen.
-func _read_into(node: Node, include_hidden: bool, into: PackedStringArray) -> void:
-	if into.size() >= READ_LIMIT:
+func _read_into(node: Node, include_hidden: bool, most: int, into: PackedStringArray) -> void:
+	if into.size() >= most:
 		return
 	if not include_hidden and not _drawn(node):
 		return
@@ -189,7 +199,7 @@ func _read_into(node: Node, include_hidden: bool, into: PackedStringArray) -> vo
 	if not said.is_empty():
 		into.append(said)
 	for child: Node in node.get_children(true):
-		_read_into(child, include_hidden, into)
+		_read_into(child, include_hidden, most, into)
 
 
 ## Whether [param node] is on the screen at all, for the two kinds of thing that can be hidden.

package/build/index.js

@@ -27633,6 +27633,13 @@ function installedAddonVersion(projectPath) {
 }
 
 // src/tool-definitions.ts
+function opTakes(spec, op, name) {
+  const ops = spec.parameters[name]?.ops;
+  return ops === undefined || ops.includes(op);
+}
+function argumentsOf(spec, op) {
+  return Object.keys(spec.parameters).filter((name) => opTakes(spec, op, name));
+}
 var PROJECT_PATH = {
   type: "string",
   description: "Absolute path to the project directory, the one holding project.godot."
@@ -27934,7 +27941,7 @@ var TOOL_SPECS = [
   },
   {
     name: "project_test",
-    description: "Runs the project's gdUnit4 tests headless and answers with every case: which failed, where, and what the assertion said. 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. Needs gdUnit4 under addons/gdUnit4.",
     parameters: {
       projectPath: PROJECT_PATH,
       path: {
@@ -28303,35 +28310,46 @@ var TOOL_SPECS = [
       projectPath: RUNNING_PROJECT_PATH,
       nodePath: {
         type: "string",
+        ops: ["tree", "text", "find", "rect", "property"],
         description: "tree, find, text: where to start, default /root. rect: the node to place. property: the node to read."
       },
       property: {
         type: "string",
+        ops: ["property", "find"],
         description: "property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label."
       },
-      depth: { type: "number", description: "tree: levels to descend. Default 3." },
+      depth: { type: "number", ops: ["tree"], description: "tree: levels to descend. Default 3." },
       includeProperties: {
         type: "boolean",
+        ops: ["tree"],
         description: "tree: include each node's properties. Default false."
       },
       className: {
         type: "string",
+        ops: ["find"],
         description: "find: a native class, matching its subclasses too, or a class_name."
       },
-      script: { type: "string", description: "find: the script file the node carries." },
+      script: { type: "string", ops: ["find"], description: "find: the script file the node carries." },
       namePattern: {
         type: "string",
+        ops: ["find"],
         description: 'find: a case-insensitive glob on the node name, such as "Enemy*".'
       },
-      group: { type: "string", description: "find: a group the node is in." },
-      limit: { type: "number", description: "find: the most nodes to answer with. Default 100." },
+      group: { type: "string", ops: ["find"], description: "find: a group the node is in." },
+      limit: {
+        type: "number",
+        ops: ["find", "text"],
+        description: "find: the most nodes to answer with, default 100. text: the most lines, default 500, with truncated saying whether there were more."
+      },
       includeHidden: {
         type: "boolean",
+        ops: ["text"],
         description: "text: read hidden nodes as well, for checking that something is not showing. Default false."
       },
       metrics: {
         type: "array",
         items: { type: "string" },
+        ops: ["metrics"],
         description: "metrics: which to read. Default all."
       }
     },
@@ -28364,10 +28382,14 @@ var TOOL_SPECS = [
     parameters: {
       projectPath: RUNNING_PROJECT_PATH,
       nodePath: { type: "string", description: 'Absolute node path, such as "/root/Main/Player".' },
-      property: { type: "string" },
-      value: { description: "set: the value, fitted to the property's type." },
-      method: { type: "string" },
-      args: { type: "array", description: "call: the arguments, fitted to the method's parameter types." }
+      property: { type: "string", ops: ["set"] },
+      value: { ops: ["set"], description: "set: the value, fitted to the property's type." },
+      method: { type: "string", ops: ["call"] },
+      args: {
+        type: "array",
+        ops: ["call"],
+        description: "call: the arguments, fitted to the method's parameter types."
+      }
     },
     requires: ["nodePath"],
     operations: {
@@ -28382,6 +28404,7 @@ var TOOL_SPECS = [
       projectPath: RUNNING_PROJECT_PATH,
       viewportPath: {
         type: "string",
+        ops: ["viewport"],
         description: "viewport: the Viewport node. Default the root viewport."
       },
       width: { type: "number", description: "Scale the image to this width." },
@@ -28401,38 +28424,69 @@ var TOOL_SPECS = [
       projectPath: RUNNING_PROJECT_PATH,
       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."
       },
-      action: { type: "string", description: "action: the InputMap action name." },
+      action: { type: "string", ops: ["action"], description: "action: the InputMap action name." },
       pressed: {
         type: "boolean",
-        description: "action, key: leave it out and the press is a whole one, down and up a frame apart. true holds it down, false lets go of one being held."
+        ops: ["action", "key", "mouse_click"],
+        description: "action, key: leave it out and the press is a whole one, down and up a frame apart. true holds it down, false lets go of one being held. mouse_click is one raw event, so it is down unless you say false."
       },
-      strength: { type: "number", description: "action: 0 to 1. Default 1." },
+      strength: { type: "number", ops: ["action"], description: "action: 0 to 1. Default 1." },
       keycode: {
         type: ["string", "number"],
+        ops: ["key"],
         description: 'key: the key name, such as "Space" or "A", or its Godot keycode.'
       },
       text: {
         type: "string",
+        ops: ["text", "choose"],
         description: "text: what to type. A newline is Enter and a tab is Tab. choose: the item to take, by what it says."
       },
+      replace: {
+        type: "boolean",
+        ops: ["text"],
+        description: 'text: true writes over what the field already says, which is what filling one in means. Default false types at the caret, so a field reading 2.1 typed "0.3" at reads 2.10.3. The answer says what the field holds afterwards either way.'
+      },
       index: {
         type: "number",
+        ops: ["choose"],
         description: "choose: the item to take, by where it is in the list, when text will not do."
       },
-      shift: { type: "boolean" },
-      ctrl: { type: "boolean" },
-      alt: { type: "boolean" },
-      x: { type: "number", description: "mouse_click, mouse_motion: window pixels." },
-      y: { type: "number", description: "mouse_click, mouse_motion: window pixels." },
+      shift: { type: "boolean", ops: ["key"] },
+      ctrl: { type: "boolean", ops: ["key"] },
+      alt: { type: "boolean", ops: ["key"] },
+      x: {
+        type: "number",
+        ops: ["mouse_click", "mouse_motion"],
+        description: "mouse_click, mouse_motion: window pixels."
+      },
+      y: {
+        type: "number",
+        ops: ["mouse_click", "mouse_motion"],
+        description: "mouse_click, mouse_motion: window pixels."
+      },
       button: {
         type: ["string", "number"],
+        ops: ["click", "mouse_click"],
         description: "click, mouse_click: left, right, middle, wheel_up or wheel_down, or a button number. Default left."
       },
-      doubleClick: { type: "boolean", description: "click, mouse_click: default false." },
-      relativeX: { type: "number", description: "mouse_motion: movement since the last event." },
-      relativeY: { type: "number", description: "mouse_motion: movement since the last event." }
+      doubleClick: {
+        type: "boolean",
+        ops: ["click", "mouse_click"],
+        description: "click, mouse_click: default false."
+      },
+      relativeX: {
+        type: "number",
+        ops: ["mouse_motion"],
+        description: "mouse_motion: movement since the last event."
+      },
+      relativeY: {
+        type: "number",
+        ops: ["mouse_motion"],
+        description: "mouse_motion: movement since the last event."
+      }
     },
     requires: [],
     operations: {
@@ -28461,14 +28515,16 @@ var TOOL_SPECS = [
       projectPath: RUNNING_PROJECT_PATH,
       frames: {
         type: "number",
+        ops: ["frames"],
         description: "frames: how many to let pass, 1 to 600. More than that is refused."
       },
-      nodePath: { type: "string", description: "signal, until: the node." },
-      signal: { type: "string", description: "signal: the signal name." },
-      property: { type: "string", description: "until: the property name." },
-      value: { description: "until: the value to wait for, fitted to the property's type." },
+      nodePath: { type: "string", ops: ["signal", "until"], description: "signal, until: the node." },
+      signal: { type: "string", ops: ["signal"], description: "signal: the signal name." },
+      property: { type: "string", ops: ["until"], description: "until: the property name." },
+      value: { ops: ["until"], description: "until: the value to wait for, fitted to the property's type." },
       timeoutMs: {
         type: "number",
+        ops: ["signal", "until"],
         description: "signal, until: how long to wait before answering anyway, 1 to 120000. Default 5000."
       }
     },
@@ -28516,6 +28572,7 @@ var TOOL_SPECS = [
     parameters: {
       frameId: {
         type: "number",
+        ops: ["variables"],
         description: "variables: which frame, from a stack answer. Default the innermost."
       }
     },
@@ -28554,7 +28611,8 @@ function buildToolDefinitions() {
       };
     }
     for (const [name, schema] of Object.entries(spec.parameters)) {
-      properties[name] = schema;
+      const { ops: _ops, ...carried } = schema;
+      properties[name] = carried;
     }
     const required = [...spec.requires];
     if (spec.operations && !spec.defaultOperation) {
@@ -28703,6 +28761,18 @@ function realPathOr(path) {
     return path;
   }
 }
+var RUNNER_DIRECTORY = "addons/gdUnit4/";
+function aboveTheRunner(entry) {
+  const runner = entry.detail.findIndex((line) => line.includes(RUNNER_DIRECTORY));
+  if (runner < 0) {
+    return entry;
+  }
+  const cut = entry.detail.length - runner;
+  return {
+    ...entry,
+    detail: [...entry.detail.slice(0, runner), `[and ${cut} frames inside ${RUNNER_DIRECTORY}]`]
+  };
+}
 function hasMainScene(projectFile) {
   const scene = parseProjectGodot(readFileSync8(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
@@ -29045,6 +29115,15 @@ class GodotServer {
         };
       }
     }
+    if (op !== null) {
+      const elsewhere = Object.keys(args).filter((key) => key !== "op" && !opTakes(spec, op, key));
+      if (elsewhere.length > 0) {
+        return {
+          ok: false,
+          response: this.createErrorResponse(`${spec.name} ${op} does not take ${elsewhere.join(", ")}. ${op} takes: ${argumentsOf(spec, op).join(", ")}.`)
+        };
+      }
+    }
     const required = [...spec.requires, ...op !== null ? spec.operations?.[op]?.requires ?? [] : []];
     const missing = required.filter((field) => {
       const value = Object.hasOwn(args, field) ? args[field] : undefined;
@@ -29169,7 +29248,8 @@ class GodotServer {
             return await this.handleRuntimeCommand("read_text", {
               projectPath: args["projectPath"],
               root: readNonEmptyString(args, "nodePath") ?? "/root",
-              include_hidden: readBoolean(args, "includeHidden") ?? false
+              include_hidden: readBoolean(args, "includeHidden") ?? false,
+              limit: readPositiveNumber(args, "limit") ?? 500
             });
           case "rect":
             return await this.handleRuntimeCommand("get_rect", {
@@ -29595,7 +29675,7 @@ class GodotServer {
       rmSync4(reportsDir, { recursive: true, force: true });
       rmSync4(userData, { recursive: true, force: true });
     }
-    const engineEntries = run.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries;
+    const engineEntries = run.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries.map(aboveTheRunner);
     const verdicts = {
       0: "passed",
       100: "failures",
@@ -29627,6 +29707,7 @@ class GodotServer {
       };
     }
     const failed = report.suites.flatMap((suite) => suite.cases.filter((entry) => entry.status === "failed" || entry.status === "error").map((entry) => ({ ...entry, path: suite.path })));
+    const unclean = report.suites.filter((suite) => suite.failures > 0 || suite.errors > 0 || suite.skipped > 0);
     return this.jsonTextResponse({
       passed: !hung && exitCode === 0 && report.failures === 0 && report.errors === 0,
       verdict,
@@ -29637,7 +29718,7 @@ class GodotServer {
       skipped: report.skipped,
       time: report.time,
       failed,
-      suites: report.suites.map((suite) => ({
+      suites: unclean.map((suite) => ({
         name: suite.name,
         path: suite.path,
         tests: suite.tests,
@@ -29646,6 +29727,7 @@ class GodotServer {
         skipped: suite.skipped,
         time: suite.time
       })),
+      suitesPassed: report.suites.length - unclean.length,
       engineErrors: run.log.count("error"),
       engineWarnings: run.log.count("warning"),
       engineEntries,
@@ -30211,31 +30293,26 @@ class GodotServer {
     });
   }
   async handleRuntimeWait(op, args) {
+    if (op === "frames") {
+      const frames = readPositiveNumber(args, "frames") ?? 1;
+      const waited = patienceForFrames(frames, this.runtimeTimeoutMs());
+      return await this.handleRuntimeCommand("wait_frames", { projectPath: args["projectPath"], frames }, waited);
+    }
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 5000;
     const nodePath = readNonEmptyString(args, "nodePath") ?? "";
     const patience = Math.max(this.runtimeTimeoutMs(), timeoutMs + 5000);
-    switch (op) {
-      case "frames": {
-        const frames = readPositiveNumber(args, "frames") ?? 1;
-        const waited = patienceForFrames(frames, patience);
-        return await this.handleRuntimeCommand("wait_frames", { projectPath: args["projectPath"], frames }, waited);
-      }
-      case "signal":
-        return await this.handleRuntimeCommand("wait_signal", {
-          projectPath: args["projectPath"],
-          path: nodePath,
-          signal: readString(args, "signal") ?? "",
-          timeout_ms: timeoutMs
-        }, patience);
-      default:
-        return await this.handleRuntimeCommand("wait_until", {
-          projectPath: args["projectPath"],
-          path: nodePath,
-          property: readString(args, "property") ?? "",
-          value: args["value"],
-          timeout_ms: timeoutMs
-        }, patience);
-    }
+    return op === "signal" ? await this.handleRuntimeCommand("wait_signal", {
+      projectPath: args["projectPath"],
+      path: nodePath,
+      signal: readString(args, "signal") ?? "",
+      timeout_ms: timeoutMs
+    }, patience) : await this.handleRuntimeCommand("wait_until", {
+      projectPath: args["projectPath"],
+      path: nodePath,
+      property: readString(args, "property") ?? "",
+      value: args["value"],
+      timeout_ms: timeoutMs
+    }, patience);
   }
 }
 async function runGodotServer() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "0.6.8",
+  "version": "0.7.0",
   "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",