gdharness 1.1.26 → 1.1.28

package/build/cli.js

@@ -17617,7 +17617,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_status",
-      description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs gdharness upgrade, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. Every runtime_* answer from such a game carries addonIsStale and staleNote too. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs.",
+      description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it; null when there is none. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs gdharness upgrade, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. Every runtime_* answer from such a game carries addonIsStale and staleNote too. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs.",
       parameters: {},
       requires: []
     },
@@ -17724,7 +17724,7 @@ var init_tool_definitions = __esm(() => {
         namePattern: {
           type: "string",
           ops: ["find"],
-          description: 'find: a case-insensitive glob on the node name, such as "Enemy*". Matched against the whole name, so a bare word finds only a node called exactly that; an answer of none says how many names contain it and what glob would have found them.'
+          description: 'find: a case-insensitive glob on the node name, such as "Enemy*", or several separated by | the way says takes them, such as "Enemy*|Boss", with \\| for a bar in a name. Matched against the whole name, so a bare word finds only a node called exactly that; an answer of none says how many names contain it and what glob would have found them.'
         },
         group: { type: "string", ops: ["find"], description: "find: a group the node is in." },
         says: {
@@ -42183,6 +42183,13 @@ class GodotServer {
       return null;
     }
   }
+  runNamed(run) {
+    return {
+      pid: run.pid ?? this.announcedPidOf(run) ?? run.announcedPid ?? null,
+      ...run.throughEditor || run.projectPath === null ? {} : { project: run.projectPath },
+      ...run.pickedUp === true ? { adopted: true } : {}
+    };
+  }
   async handleEditorStatus() {
     const located = await this.locator.find();
     const announced = runtimesAnnounced();
@@ -42215,10 +42222,11 @@ class GodotServer {
       return {
         playing,
         active,
+        run: current === null ? null : this.runNamed(current),
         hold: current === null ? {} : await this.holdOf(current, active)
       };
     })();
-    const [games, { playing, active, hold }, scan, editorStatus] = await Promise.all([
+    const [games, { playing, active, run, hold }, scan, editorStatus] = await Promise.all([
       pinged,
       asked,
       this.editorScanState(),
@@ -42237,6 +42245,7 @@ class GodotServer {
       },
       game: {
         processActive: active,
+        run,
         playingInEditor: playing,
         ...hold,
         runtimeConnected: games.some((game) => game.reachable && game.ofThisProject !== false),

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

@@ -70,7 +70,8 @@ func get_tree(params: Dictionary) -> Dictionary:
 
 ## Nodes matching every filter given, as paths, so a caller can name what it wants without
 ## reading the whole tree to find it. `class` matches native classes and their subclasses, and
-## the global name of a script class; `name` is a case-insensitive glob; `script` is a path;
+## the global name of a script class; `name` is a case-insensitive glob, or several separated by `|`
+## the way `says` takes them, with `\|` for a bar in a name; `script` is a path;
 ## `says` is what the node has written on it.
 ##
 ## `property` names one to read off each of them, which is the difference between one question and
@@ -103,6 +104,12 @@ func find_nodes(params: Dictionary) -> Dictionary:
 	if not wanted["script"].is_empty() and not wanted["script"].begins_with("res://"):
 		wanted["script"] = "res://" + wanted["script"]
 
+	# Split once here rather than for each node the walk passes.
+	var names: Array[String] = Says.split_at_bars(wanted["name"])
+	if not wanted["name"].is_empty() and names.is_empty():
+		var bars_only: String = 'name "%s" is only bars, so it names no node; write the names between them'
+		return {"type": "error", "message": bars_only % wanted["name"]}
+
 	var reached: Dictionary = Values.node_at(_host.get_tree().root, root_path)
 	if reached.has("message"):
 		return reached
@@ -113,7 +120,10 @@ func find_nodes(params: Dictionary) -> Dictionary:
 	var truncated: bool = false
 	# Counted while the tree is already being walked, for the answer below: how many nodes this
 	# find would have matched if the name had been read the way it was probably meant.
-	var literal: bool = Says.is_plain(wanted["name"])
+	var plain_names: Array[String] = []
+	for named: String in names:
+		if Says.is_plain(named):
+			plain_names.append(named)
 	var nearly: int = 0
 	# The same for the words: a glob is matched against the whole text, and one written as a prefix
 	# by habit, "Taken together*", missed the label whose sentence those words are in the middle of.
@@ -132,7 +142,7 @@ func find_nodes(params: Dictionary) -> Dictionary:
 	while not pending.is_empty():
 		var node: Node = pending.pop_front()
 		var rest: bool = _matches_apart_from_name(node, wanted)
-		if rest and _named(node, wanted["name"]):
+		if rest and _named(node, names):
 			if not include_hidden and not shown(node):
 				hidden += 1
 			elif found.size() >= limit:
@@ -140,16 +150,12 @@ func find_nodes(params: Dictionary) -> Dictionary:
 				break
 			else:
 				found.append(_found(node, wanted_property))
-		elif rest and literal and str(node.name).containsn(wanted["name"]):
+		elif rest and _contains_any(str(node.name), plain_names):
 			if include_hidden or shown(node):
 				nearly += 1
 			else:
 				nearly_hidden += 1
-		elif (
-			not widened_says.is_empty()
-			and _named(node, wanted["name"])
-			and _matches_apart_from_name(node, widened)
-		):
+		elif not widened_says.is_empty() and _named(node, names) and _matches_apart_from_name(node, widened):
 			if include_hidden or shown(node):
 				nearly_said += 1
 			else:
@@ -172,17 +178,23 @@ func find_nodes(params: Dictionary) -> Dictionary:
 	if found.is_empty() and nearly + nearly_hidden > 0:
 		var named_near: int = nearly if nearly > 0 else nearly_hidden
 		var holding: String = "names contain" if named_near > 1 else "name contains"
+		var near_words: Array[String] = []
+		for named: String in plain_names:
+			near_words.append('"%s"' % named)
+		var opened: Array[String] = []
+		for named: String in names:
+			opened.append("*%s*" % named if Says.is_plain(named) else named)
 		(
 			notes
 			. append(
 				(
-					'name is matched as a glob against the whole name; %d %snode %s "%s", which "*%s*"%s would find'
+					'name is matched as a glob against the whole name; %d %snode %s %s, which "%s"%s would find'
 					% [
 						named_near,
 						"" if nearly > 0 else "hidden ",
 						holding,
-						wanted["name"],
-						wanted["name"],
+						" or ".join(PackedStringArray(near_words)),
+						Says.joined_at_bars(opened),
 						"" if nearly > 0 else " with includeHidden true",
 					]
 				)
@@ -308,10 +320,23 @@ static func _anything_asked(wanted: Dictionary[String, String]) -> bool:
 	return false
 
 
-## Whether [param node] carries the name a find asked for. Empty matches everything, which is what
-## makes leaving a filter out the same as not having one.
-static func _named(node: Node, pattern: String) -> bool:
-	return pattern.is_empty() or str(node.name).matchn(pattern)
+## Whether [param node] carries one of the names a find asked for. None matches everything, which is
+## what makes leaving a filter out the same as not having one.
+static func _named(node: Node, names: Array[String]) -> bool:
+	if names.is_empty():
+		return true
+	var called: String = str(node.name)
+	for pattern: String in names:
+		if called.matchn(pattern):
+			return true
+	return false
+
+
+static func _contains_any(called: String, words: Array[String]) -> bool:
+	for word: String in words:
+		if called.containsn(word):
+			return true
+	return false
 
 
 ## Every filter but the name, so a find that came back empty can say how many nodes the name was

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

@@ -54,18 +54,34 @@ static func alternatives(wanted: String) -> Array[String]:
 	if kept != null:
 		var split: Array[String] = kept
 		return split
-	var held: String = as_said(wanted).replace("\\|", ESCAPED_BAR)
+	var found: Array[String] = split_at_bars(as_said(wanted))
+	if _splits.size() >= SPLITS_KEPT:
+		_splits.clear()
+	_splits[wanted] = found
+	return found
+
+
+## [param written] split at every `|` not written as `\|`, empty alternatives dropped. Shared with a
+## find's name, which takes alternatives by the same rule so the two arguments beside each other do
+## not read a bar two ways: written in a name, `A|B` was one glob no node matched, and the empty
+## answer came with no note.
+static func split_at_bars(written: String) -> Array[String]:
 	var found: Array[String] = []
-	for part: String in held.split("|"):
+	for part: String in written.replace("\\|", ESCAPED_BAR).split("|"):
 		var words: String = part.replace(ESCAPED_BAR, "|")
 		if not words.is_empty():
 			found.append(words)
-	if _splits.size() >= SPLITS_KEPT:
-		_splits.clear()
-	_splits[wanted] = found
 	return found
 
 
+## [param parts] joined back into one pattern that [method split_at_bars] reads as them.
+static func joined_at_bars(parts: Array[String]) -> String:
+	var escaped: Array[String] = []
+	for words: String in parts:
+		escaped.append(words.replace("|", "\\|"))
+	return "|".join(PackedStringArray(escaped))
+
+
 ## Whether [param pattern] is words written whole rather than as a glob, which is how a caller
 ## writes them when they mean "contains". [method String.matchn] answers nothing to it, and nothing
 ## is also what words that are simply not there answer.

package/build/index.js

@@ -31601,7 +31601,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_status",
-    description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs gdharness upgrade, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. Every runtime_* answer from such a game carries addonIsStale and staleNote too. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs.",
+    description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it; null when there is none. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs gdharness upgrade, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. Every runtime_* answer from such a game carries addonIsStale and staleNote too. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs.",
     parameters: {},
     requires: []
   },
@@ -31708,7 +31708,7 @@ var TOOL_SPECS = [
       namePattern: {
         type: "string",
         ops: ["find"],
-        description: 'find: a case-insensitive glob on the node name, such as "Enemy*". Matched against the whole name, so a bare word finds only a node called exactly that; an answer of none says how many names contain it and what glob would have found them.'
+        description: 'find: a case-insensitive glob on the node name, such as "Enemy*", or several separated by | the way says takes them, such as "Enemy*|Boss", with \\| for a bar in a name. Matched against the whole name, so a bare word finds only a node called exactly that; an answer of none says how many names contain it and what glob would have found them.'
       },
       group: { type: "string", ops: ["find"], description: "find: a group the node is in." },
       says: {
@@ -34763,6 +34763,13 @@ class GodotServer {
       return null;
     }
   }
+  runNamed(run) {
+    return {
+      pid: run.pid ?? this.announcedPidOf(run) ?? run.announcedPid ?? null,
+      ...run.throughEditor || run.projectPath === null ? {} : { project: run.projectPath },
+      ...run.pickedUp === true ? { adopted: true } : {}
+    };
+  }
   async handleEditorStatus() {
     const located = await this.locator.find();
     const announced = runtimesAnnounced();
@@ -34795,10 +34802,11 @@ class GodotServer {
       return {
         playing,
         active,
+        run: current === null ? null : this.runNamed(current),
         hold: current === null ? {} : await this.holdOf(current, active)
       };
     })();
-    const [games, { playing, active, hold }, scan, editorStatus] = await Promise.all([
+    const [games, { playing, active, run, hold }, scan, editorStatus] = await Promise.all([
       pinged,
       asked,
       this.editorScanState(),
@@ -34817,6 +34825,7 @@ class GodotServer {
       },
       game: {
         processActive: active,
+        run,
         playingInEditor: playing,
         ...hold,
         runtimeConnected: games.some((game) => game.reachable && game.ofThisProject !== false),

package/package.json

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