@codyswann/lisa 4.34.14 → 4.34.16

package/plugins/src/base/hooks/block-no-verify.agy.sh

@@ -28,7 +28,7 @@
 # not JSON). Malformed/empty stdin → allow (fail open, never crash the tool).
 #
 # Capability names below are the canonical guard's, kept identical on every agent.
-# lisa-guard-capabilities: no-verify-abbrev, husky-env, hookspath-allowlist, config-env, env-split-string, git-config-key, git-config-parameters, git-config-parameters-append, git-config-parameters-expansion, heredoc-shell-word, herestring-aware, no-verify-short, nested-shell-no-verify, nested-shell-long-options, env-split-string-abbrev, command-wrapper-normalization, executed-script-reach, source-builtin-reach, stdin-redirect-reach, wrapper-positional-operand, dispatcher-exec-position
+# lisa-guard-capabilities: no-verify-abbrev, husky-env, hookspath-allowlist, config-env, env-split-string, git-config-key, git-config-parameters, git-config-parameters-append, git-config-parameters-expansion, heredoc-shell-word, herestring-aware, no-verify-short, nested-shell-no-verify, nested-shell-long-options, env-split-string-abbrev, command-wrapper-normalization, executed-script-reach, source-builtin-reach, stdin-redirect-reach, wrapper-positional-operand, dispatcher-exec-position, tilde-script-reach, shell-option-stdin-reach
 set -uo pipefail
 
 allow() {
@@ -195,8 +195,38 @@ ENV_LONG_SEPARATE_VALUE = {"--argv0", "--chdir", "--split-string", "--unset"}
 
 # env's single-letter options, by whether the rest of a cluster is more
 # options or the option's value.
+#
+# BOTH PLATFORMS' SETS, not one. These began as GNU's, and an option that is
+# in neither set falls through to `ambiguous`, which this guard treats as
+# suspicious. That default is correct and stays — an unknown option genuinely
+# could take a value and swallow the command name. What is wrong is a
+# well-known option being unknown, and on a macOS fleet `env -P` is exactly
+# that: BSD's "search altpath for the utility", refused on every ordinary
+# command it prefixes.
+#
+# Measured, one option at a time, against the guard before this change. BSD's
+# complete short set is `0 i v u C P S`, from the synopsis in env(1):
+#
+#     allowed   -0  -i  -v  -u NAME  -C DIR     already covered
+#     BLOCKED   -P altpath                      the defect, and the ONLY one
+#     BLOCKED   -S string                       correct: split-string reparses
+#                                               an opaque payload, so what it
+#                                               runs cannot be proven here
+#     BLOCKED   -Z  -Q                          correct: unknown stays suspicious
+#
+# So the population is one letter, not a class. The two platforms' short
+# options coincide everywhere else, which is why "detect the platform and
+# choose a table" would be machinery for a single character — and would fail
+# on a machine running GNU coreutils under a BSD userland, or the reverse.
+# Recognising the union is both smaller and more robust.
+#
+# Adding a letter here is a WEAKENING, so it needs the same evidence as any
+# other: ten bypass shapes routed through `-P` — long flag, attached value,
+# short cluster, abbreviation, an assignment, `HUSKY=0`, a hooksPath disable,
+# a nested `-c` shell, an executed script, and `-P` swallowing the command
+# word — were all refused before this change and are all still refused after.
 ENV_SHORT_NO_VALUE = frozenset("i0v")
-ENV_SHORT_TAKES_VALUE = frozenset("uCaS")
+ENV_SHORT_TAKES_VALUE = frozenset("uCaSP")
 
 # Builtins and wrappers that run whatever FOLLOWS them without changing what
 # it is: `command env -S ...` runs exactly the `env` that `env -S ...` runs,
@@ -907,7 +937,7 @@ def resolve_script(token):
     """
     if COMPUTED_VALUE.search(token):
         return (None, "a computed path the guard cannot resolve before the shell does")
-    text = token.strip().strip("'\"")
+    text = os.path.expanduser(token.strip().strip("'\""))
     # `bash -` and a bare `-` read the script from stdin; there is no file.
     if not text or text == "-":
         return (None, None)
@@ -929,6 +959,48 @@ def resolve_script(token):
     return (None, "a script that does not exist or cannot be read")
 
 
+SHELL_COMMAND_STRING = object()
+SHELL_STDIN = object()
+
+
+def shell_execution_operand(args):
+    """The file a shell runs, or a sentinel for `-c` and stdin modes.
+
+    `shell_script_operand` intentionally collapses both cases to None for the
+    nested-command scanner. Reach cannot: `bash -c '...'` has already exposed
+    its text, while `bash -x`, `bash -e`, and `bash --` still await a script on
+    stdin and must remain linked to a following `< file` separator.
+    """
+    index = 0
+    opaque_option_seen = False
+    while index < len(args):
+        token = args[index]
+        if token == "--":
+            index += 1
+            break
+        if not token.startswith(("-", "+")):
+            if not opaque_option_seen:
+                break
+            index += 1
+            opaque_option_seen = False
+            continue
+        if token in SHELL_OPTIONS_SEPARATE_VALUE:
+            index += 2
+            continue
+        if token.startswith(SHELL_OPTIONS_INLINE_VALUE):
+            index += 1
+            continue
+        if token.startswith("--"):
+            if token not in SHELL_LONG_OPTIONS_NO_VALUE:
+                opaque_option_seen = True
+            index += 1
+            continue
+        if "c" in token[1:]:
+            return SHELL_COMMAND_STRING
+        index += 1
+    return args[index] if index < len(args) else SHELL_STDIN
+
+
 def executed_scripts(tokens):
     """The files a command line will RUN, and the executions it cannot follow.
 
@@ -963,9 +1035,12 @@ def executed_scripts(tokens):
             if name in SOURCE_BUILTINS:
                 operand = arguments[0] if arguments else None
             elif name in SHELL_PROGRAMS:
-                operand = shell_script_operand(arguments)
-                if operand is None and not arguments:
+                operand = shell_execution_operand(arguments)
+                if operand is SHELL_STDIN:
                     previous_shell_awaiting_stdin = True
+                    continue
+                if operand is SHELL_COMMAND_STRING:
+                    continue
             else:
                 continue
             if operand is None:

package/plugins/src/base/hooks/block-no-verify.sh

@@ -33,7 +33,7 @@
 # Add a name here in the same commit that closes a vector. A hardening that
 # forgets to is invisible to refresh, and shows up as an unexplained diff at
 # review time instead of a named capability.
-# lisa-guard-capabilities: no-verify-abbrev, husky-env, hookspath-allowlist, config-env, env-split-string, git-config-key, git-config-parameters, git-config-parameters-append, git-config-parameters-expansion, heredoc-shell-word, herestring-aware, no-verify-short, nested-shell-no-verify, nested-shell-long-options, env-split-string-abbrev, command-wrapper-normalization, executed-script-reach, source-builtin-reach, stdin-redirect-reach, wrapper-positional-operand, dispatcher-exec-position
+# lisa-guard-capabilities: no-verify-abbrev, husky-env, hookspath-allowlist, config-env, env-split-string, git-config-key, git-config-parameters, git-config-parameters-append, git-config-parameters-expansion, heredoc-shell-word, herestring-aware, no-verify-short, nested-shell-no-verify, nested-shell-long-options, env-split-string-abbrev, command-wrapper-normalization, executed-script-reach, source-builtin-reach, stdin-redirect-reach, wrapper-positional-operand, dispatcher-exec-position, tilde-script-reach, shell-option-stdin-reach
 #
 # Shell-token matching avoids false positives from issue bodies, heredocs, and
 # commit-message prose while still catching quoted real argv values such as
@@ -265,8 +265,38 @@ ENV_LONG_SEPARATE_VALUE = {"--argv0", "--chdir", "--split-string", "--unset"}
 
 # env's single-letter options, by whether the rest of a cluster is more
 # options or the option's value.
+#
+# BOTH PLATFORMS' SETS, not one. These began as GNU's, and an option that is
+# in neither set falls through to `ambiguous`, which this guard treats as
+# suspicious. That default is correct and stays — an unknown option genuinely
+# could take a value and swallow the command name. What is wrong is a
+# well-known option being unknown, and on a macOS fleet `env -P` is exactly
+# that: BSD's "search altpath for the utility", refused on every ordinary
+# command it prefixes.
+#
+# Measured, one option at a time, against the guard before this change. BSD's
+# complete short set is `0 i v u C P S`, from the synopsis in env(1):
+#
+#     allowed   -0  -i  -v  -u NAME  -C DIR     already covered
+#     BLOCKED   -P altpath                      the defect, and the ONLY one
+#     BLOCKED   -S string                       correct: split-string reparses
+#                                               an opaque payload, so what it
+#                                               runs cannot be proven here
+#     BLOCKED   -Z  -Q                          correct: unknown stays suspicious
+#
+# So the population is one letter, not a class. The two platforms' short
+# options coincide everywhere else, which is why "detect the platform and
+# choose a table" would be machinery for a single character — and would fail
+# on a machine running GNU coreutils under a BSD userland, or the reverse.
+# Recognising the union is both smaller and more robust.
+#
+# Adding a letter here is a WEAKENING, so it needs the same evidence as any
+# other: ten bypass shapes routed through `-P` — long flag, attached value,
+# short cluster, abbreviation, an assignment, `HUSKY=0`, a hooksPath disable,
+# a nested `-c` shell, an executed script, and `-P` swallowing the command
+# word — were all refused before this change and are all still refused after.
 ENV_SHORT_NO_VALUE = frozenset("i0v")
-ENV_SHORT_TAKES_VALUE = frozenset("uCaS")
+ENV_SHORT_TAKES_VALUE = frozenset("uCaSP")
 
 # Builtins and wrappers that run whatever FOLLOWS them without changing what
 # it is: `command env -S ...` runs exactly the `env` that `env -S ...` runs,
@@ -977,7 +1007,7 @@ def resolve_script(token):
     """
     if COMPUTED_VALUE.search(token):
         return (None, "a computed path the guard cannot resolve before the shell does")
-    text = token.strip().strip("'\"")
+    text = os.path.expanduser(token.strip().strip("'\""))
     # `bash -` and a bare `-` read the script from stdin; there is no file.
     if not text or text == "-":
         return (None, None)
@@ -999,6 +1029,48 @@ def resolve_script(token):
     return (None, "a script that does not exist or cannot be read")
 
 
+SHELL_COMMAND_STRING = object()
+SHELL_STDIN = object()
+
+
+def shell_execution_operand(args):
+    """The file a shell runs, or a sentinel for `-c` and stdin modes.
+
+    `shell_script_operand` intentionally collapses both cases to None for the
+    nested-command scanner. Reach cannot: `bash -c '...'` has already exposed
+    its text, while `bash -x`, `bash -e`, and `bash --` still await a script on
+    stdin and must remain linked to a following `< file` separator.
+    """
+    index = 0
+    opaque_option_seen = False
+    while index < len(args):
+        token = args[index]
+        if token == "--":
+            index += 1
+            break
+        if not token.startswith(("-", "+")):
+            if not opaque_option_seen:
+                break
+            index += 1
+            opaque_option_seen = False
+            continue
+        if token in SHELL_OPTIONS_SEPARATE_VALUE:
+            index += 2
+            continue
+        if token.startswith(SHELL_OPTIONS_INLINE_VALUE):
+            index += 1
+            continue
+        if token.startswith("--"):
+            if token not in SHELL_LONG_OPTIONS_NO_VALUE:
+                opaque_option_seen = True
+            index += 1
+            continue
+        if "c" in token[1:]:
+            return SHELL_COMMAND_STRING
+        index += 1
+    return args[index] if index < len(args) else SHELL_STDIN
+
+
 def executed_scripts(tokens):
     """The files a command line will RUN, and the executions it cannot follow.
 
@@ -1033,9 +1105,12 @@ def executed_scripts(tokens):
             if name in SOURCE_BUILTINS:
                 operand = arguments[0] if arguments else None
             elif name in SHELL_PROGRAMS:
-                operand = shell_script_operand(arguments)
-                if operand is None and not arguments:
+                operand = shell_execution_operand(arguments)
+                if operand is SHELL_STDIN:
                     previous_shell_awaiting_stdin = True
+                    continue
+                if operand is SHELL_COMMAND_STRING:
+                    continue
             else:
                 continue
             if operand is None:

package/plugins/src/base/skills/lisa-drive-pr-to-merge/SKILL.md

@@ -460,6 +460,50 @@ passed off as success.
   `blocked:unreviewed`. This fallback lives inside the gated section above —
   with `auto_merge=false` it never fires; the PR remains open awaiting a human.
 
+### The mergeability gate — never arm a PR that cannot merge
+
+The arm gate above asks *did the review context do work?* This one asks a
+different question — *is there a verdict standing in the way?* — and they are
+not the same. A `CHANGES_REQUESTED` review unambiguously **did work**, so it
+sails through the arm gate and the latch goes on over the top of it.
+
+**Read `reviewDecision` explicitly. Never infer it from a check count.**
+
+```bash
+gh pr view <pr> --json reviewDecision,reviewThreads \
+  --jq '{decision: .reviewDecision, unresolved: [.reviewThreads[]? | select(.isResolved == false)] | length}'
+```
+
+`reviewDecision` is **not part of `statusCheckRollup`**. That is the whole reason
+this stayed invisible: a failing-check count reads **zero** on a PR that can
+never merge, and the checks tab is entirely green. Any rule keyed on "no red
+checks" is satisfied by exactly the PR this gate exists to catch (#3720).
+
+**Do not arm while `reviewDecision == CHANGES_REQUESTED`.** Arming is a claim
+that this PR will merge, and that claim is false here. Clear the verdict through
+step (e) first — which discriminates a live objection from a stranded one by
+unresolved thread count, not by `reviewDecision` — and arm afterwards.
+
+**Two ruleset settings decide whether a standing verdict ever clears itself, and
+in this repository both say no.** Verify them for the repo you are in rather
+than assuming, with `gh api repos/<owner>/<repo>/rulesets`:
+
+- `dismiss_stale_reviews_on_push: false` — the review stays attached to the
+  commit it was made on, so **pushing the fix never clears it**. The intuition
+  that a new head resets the verdict is wrong here.
+- `required_approving_review_count: 0` — no approval is required to merge, so a
+  standing `CHANGES_REQUESTED` is not holding a slot for a review that would
+  otherwise arrive. Nothing is scheduled to clear it.
+
+Together those mean the block is **indefinite, not slow**. Waiting is not a
+strategy; something has to act.
+
+**Unresolved threads block independently of the verdict.** This repository sets
+`required_review_thread_resolution: true`, so a PR can have a clear
+`reviewDecision` and still be unmergeable on threads alone — a second blocker
+that is equally absent from the check rollup. Read both, and name whichever one
+is standing; reporting the wrong one sends the operator to the wrong place.
+
 ## 2. The watch loop
 
 Poll the live state each iteration:
@@ -1078,6 +1122,14 @@ Loop until one of:
   the one thing nobody would then do is investigate it. Usually a missing
   `issues: read` / label-read permission, which is fixable and invisible from
   the merge outcome alone.
+- **`blocked:armed-unmergeable`** — the PR is OPEN, auto-merge is ON, every check
+  is green, and it still cannot merge: `reviewDecision == CHANGES_REQUESTED`, or
+  unresolved review threads under `required_review_thread_resolution`. Report the
+  PR URL, **which** of the two is standing, and that it will not clear itself.
+  For example: *"PR #123 looks ready — every check is green and auto-merge is on
+  — but a review asked for changes and that is still on record, so it will sit
+  there forever. Someone needs to clear that review or resolve the open
+  comments."* Never report this PR as merging.
 - **`CLOSED`** → report (PR was closed without merge).
 - **Hard block needing a human**: an unresolvable conflict, a failing check that
   needs design input, or genuine unresolved human objection (not a bot gate). Stop
@@ -1087,6 +1139,44 @@ Loop until one of:
   adversarial-review substitute is posted (step d); it never extends to any
   other gate.
 
+### Before you stop: never leave a PR armed and unmergeable in silence
+
+**This applies at every exit that leaves the PR OPEN** — not only the terminal
+states above, but any point where this run concludes it is finished, hands back,
+or gives up. Re-read, from the live PR, immediately before reporting:
+
+```bash
+gh pr view <pr> --json state,autoMergeRequest,reviewDecision,reviewThreads \
+  --jq '{state, armed: (.autoMergeRequest != null), decision: .reviewDecision,
+         unresolved: [.reviewThreads[]? | select(.isResolved == false)] | length}'
+```
+
+If `state == OPEN` and `armed` and either `decision == "CHANGES_REQUESTED"` or
+`unresolved > 0`, the outcome is **`blocked:armed-unmergeable`** — never a
+success, and never silence.
+
+**Why this exists rather than trusting the loop.** While the loop runs this is
+already covered: the watch poll reads `reviewDecision` and step (e) handles it.
+The failure is a run that **stops** while the PR is armed and blocked — the
+session ends, or the agent decides the work is done because arming looked like
+completion. Measured (#3720): three PRs were left armed, green and permanently
+unmergeable, and every one was found only because a person queried
+`reviewDecision` by hand. An agent that arms auto-merge and reports "armed, will
+merge" is reporting something false and has no reason to know it.
+
+**Arming is not completion.** It is a claim about the future that this check is
+what makes honest. The claim costs nothing when true — one read, and the report
+says merging — and when false it is the only thing standing between a parked PR
+and nobody noticing for hours.
+
+**Read the two fields; do not substitute a check count.** Zero failing checks is
+the symptom, not the signal — that is precisely why this class was invisible.
+
+In `on_blocker=report` mode the same condition returns the existing
+`blocked:changes_requested` classification rather than this terminal state: that
+mode returns a blocker for the caller to act on, and does not drive. The two
+names describe the same PR seen from the two modes.
+
 At every terminal state, release the babysitter lease
 (`gh pr edit <pr> --remove-label "lisa:babysitter-on-duty"`) so the CI
 auto-fix workflow can take over as fixer of last resort if the branch goes

package/scripts/check-npm-publish-landed.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+/**
+ * Lisa's own entry point for the shipped npm-publish verification.
+ *
+ * `publish-to-npm.yml` runs `node scripts/check-npm-publish-landed.mjs`, and
+ * that path is the CALLER's tree: in a host project `lisa apply` writes it from
+ * `all/copy-overwrite/scripts/`, and in this repository it is this file. So the
+ * step needs the path to exist here too, or Lisa's own release is the one
+ * release the check never runs on.
+ *
+ * A re-export rather than a second copy. The sibling in the same workflow,
+ * `check-release-package-identity.mjs`, is duplicated byte-for-byte across both
+ * channels, and duplicated checks are exactly what drifts unnoticed — the whole
+ * `hook-copy-parity` subsystem exists because two copies of one check cannot be
+ * kept in step by intention. There is one implementation, and both paths reach
+ * it.
+ * @module scripts/check-npm-publish-landed
+ */
+import process from "node:process";
+
+import { main } from "../all/copy-overwrite/scripts/check-npm-publish-landed.mjs";
+
+main(process.argv.slice(2))
+  .then(code => {
+    process.exitCode = code;
+  })
+  .catch(error => {
+    process.stderr.write(`❌ ${error.message}\n`);
+    process.exitCode = 1;
+  });

package/scripts/two-channel-couplings.json

@@ -5,13 +5,13 @@
   },
   "inspected": {
     "workflows": 22,
-    "steps": 715,
-    "couplings": 33,
-    "inventory": 70
+    "steps": 716,
+    "couplings": 34,
+    "inventory": 71
   },
   "counts": {
     "package-backed": 10,
-    "apply-lagged": 21,
+    "apply-lagged": 22,
     "never-delivered": 0,
     "undelivered": 2
   },
@@ -133,6 +133,19 @@
       ],
       "detail": "`nightly-e2e-tracking.yml` is delivered at `@main`, so this step is live in every consumer on their next run. It reads `scripts/reconcile-nightly-e2e-tracking.mjs` from the CALLER's tree with no package-relative candidate, and Lisa delivers that path on the `lisa apply` channel (typescript/copy-overwrite). The two halves land in the wrong order: this step is live everywhere immediately, the file it needs is live only where somebody applied. The read is unguarded, so an absent path fails the job loudly. Visible, which makes it the better of the two failures."
     },
+    {
+      "key": "publish-to-npm.yml::scripts/check-npm-publish-landed.mjs",
+      "workflow": "publish-to-npm.yml",
+      "path": "scripts/check-npm-publish-landed.mjs",
+      "channel": "apply",
+      "verdict": "apply-lagged",
+      "remedy": "run-lisa-apply",
+      "guarded": false,
+      "lanes": [
+        "all/copy-overwrite"
+      ],
+      "detail": "`publish-to-npm.yml` is delivered at `@main`, so this step is live in every consumer on their next run. It reads `scripts/check-npm-publish-landed.mjs` from the CALLER's tree with no package-relative candidate, and Lisa delivers that path on the `lisa apply` channel (all/copy-overwrite). The two halves land in the wrong order: this step is live everywhere immediately, the file it needs is live only where somebody applied. The read is unguarded, so an absent path fails the job loudly. Visible, which makes it the better of the two failures."
+    },
     {
       "key": "publish-to-npm.yml::scripts/check-release-package-identity.mjs",
       "workflow": "publish-to-npm.yml",

package/typescript/copy-overwrite/.claude/hooks/worktree-create.sh

@@ -199,12 +199,14 @@ fi
 if git -C "$_root" show-ref --verify --quiet "refs/heads/$_wt_branch" 2>/dev/null; then
   _reused=1
   _add_err="$(git -C "$_root" worktree add "$_path" "$_wt_branch" 2>&1 >/dev/null)"
+  _add_status=$?
 else
   _reused=0
   _add_err="$(git -C "$_root" worktree add --no-track -b "$_wt_branch" "$_path" "$_base_ref" 2>&1 >/dev/null)"
+  _add_status=$?
 fi
 
-if [ ! -d "$_path" ]; then
+if [ "$_add_status" -ne 0 ] || [ ! -d "$_path" ]; then
   _log "WorktreeCreate: git worktree add failed for $_path."
   [ -n "$_add_err" ] && _log "  git: $_add_err"
   exit 1

package/typescript/copy-overwrite/.prettierignore

@@ -69,6 +69,7 @@ scripts/check-orphaned-branches.mjs
 scripts/check-e2e-coverage.mjs
 scripts/check-lighthouse-details.mjs
 scripts/check-nightly-e2e-health.mjs
+scripts/check-npm-publish-landed.mjs
 scripts/check-release-package-identity.mjs
 scripts/check-skipped-required-checks.mjs
 scripts/check-state-classification.mjs

package/typescript/copy-overwrite/scripts/lisa-mutation.mjs

@@ -197,46 +197,6 @@ export const OUTCOMES = Object.freeze({
   noFloorApplied: "mutation-gate: no-floor-applied",
 });
 
-/**
- * The outcomes under which Stryker generated mutants and produced a score.
- *
- * THE POINT OF #3668. Every other outcome in {@link OUTCOMES} ends a run that
- * MEASURED NOTHING, and until this set existed the exit-0 members of that group
- * were indistinguishable from a real pass at the only layer a merge decision
- * consults: `🔍 Quality Checks / 🧬 Mutation Testing Gate` printed `pass` for a
- * pull request no mutant had touched. Measured on #3664 — a 400-line change to
- * a shipped guard script, `nothing-to-mutate`, `pass`.
- *
- * The file said so itself, above {@link OUTCOMES}, and had for months: "both
- * exit 0, and only the marker says which one happened." The marker lives in a
- * log; a log is not a control. This set is what lets the workflow render the
- * difference.
- *
- * MEMBERSHIP IS THE STRYKER RUN, not the verdict. `scoped` and `wholeList` are
- * the two outcomes that carry a `reportRun`, so they are the two under which
- * mutants existed — whether the score then cleared the floor or not is a
- * different question, answered by the exit code. A run that measured and FAILED
- * is still a run that measured.
- */
-export const MEASURED_OUTCOMES = Object.freeze([
-  OUTCOMES.scoped,
-  OUTCOMES.wholeList,
-]);
-
-/**
- * Whether an outcome means mutants were generated against this change.
- *
- * An unknown marker answers `false`, and that direction is deliberate: a new
- * outcome added without being classified must not inherit "measured". Failing
- * closed here costs a `skipping` row on a run that did measure; failing open
- * costs exactly the false green this issue is about.
- *
- * @param {string} outcome - One {@link OUTCOMES} marker
- * @returns {boolean} True when Stryker produced mutants
- */
-export const measuredAnything = outcome =>
-  MEASURED_OUTCOMES.includes(String(outcome));
-
 /**
  * Publishes the outcome where the workflow can render it, then returns the code.
  *
@@ -259,16 +219,17 @@ export const measuredAnything = outcome =>
  *
  * @param {string} outcome - The {@link OUTCOMES} marker this run ended on
  * @param {number} code - The exit code to return unchanged
+ * @param {boolean} [measured] - Whether this concrete run produced a score
  * @param {NodeJS.ProcessEnv} [env] - Environment, injectable for tests
  * @returns {number} `code`, unchanged
  */
-export const finish = (outcome, code, env = process.env) => {
+export const finish = (outcome, code, measured = false, env = process.env) => {
   const target = env.GITHUB_OUTPUT;
   if (target === undefined || target === "") return code;
   try {
     fs.appendFileSync(
       target,
-      `mutation_outcome=${outcome}\nmutation_measured=${measuredAnything(outcome)}\n`
+      `mutation_outcome=${outcome}\nmutation_measured=${measured === true}\n`
     );
   } catch (error) {
     console.error(
@@ -2107,10 +2068,10 @@ export const WHOLE_LIST_FLAG = "--all";
  * measured, printed, and — when it is what carried the run over the floor —
  * failed on. See {@link timeoutAccounting}.
  * @param {string} cwd - Project root.
- * @param {{code: number, output: string|null}} result - From `runStryker`.
- * @returns {number} The exit code the caller should use.
+ * @param {{code: number, output: string|null, killedBy?: string}} result - From `runStryker`.
+ * @returns {{code: number, measured: boolean}} The exit code and whether a score was produced.
  */
-const reportRun = (cwd, result) => {
+export const reportRun = (cwd, result) => {
   const accounting = accountForTimeouts(result.output, cwd);
   if (result.killedBy === CHILD_DEADLINE) {
     // A gate that ran and failed measured something; a gate that was KILLED
@@ -2119,7 +2080,7 @@ const reportRun = (cwd, result) => {
     // arm comes before the classification below because that reads Stryker's
     // transcript, and a killed run's transcript stops wherever the kill landed.
     console.error(childDeadlineBlock(resolveChildDeadline()));
-    return result.code;
+    return { code: result.code, measured: false };
   }
   if (result.code !== 0) {
     // Stryker's own verdict stands; what is added is WHICH failure it was. The
@@ -2135,14 +2096,14 @@ const reportRun = (cwd, result) => {
     // that DID produce one still gets the honest recomputation: a run under the
     // floor is under it by more than Stryker said.
     if (accounting.measured) console.error(accounting.message);
-    return result.code;
+    return { code: result.code, measured: accounting.measured };
   }
   if (accounting.failed) {
     console.error(accounting.message);
-    return 1;
+    return { code: 1, measured: accounting.measured };
   }
   console.log(accounting.message);
-  return 0;
+  return { code: 0, measured: accounting.measured };
 };
 
 /**
@@ -2216,7 +2177,8 @@ export const runGate = (cwd = process.cwd(), argv = []) => {
       `🧬 ${OUTCOMES.wholeList} — Stryker over every pattern in ` +
         `${declaration.source}, with no diff scoping.`
     );
-    return finish(OUTCOMES.wholeList, reportRun(cwd, runStryker(cwd, [])));
+    const reported = reportRun(cwd, runStryker(cwd, []));
+    return finish(OUTCOMES.wholeList, reported.code, reported.measured);
   }
 
   const base = resolveDiffBase(cwd, since);
@@ -2324,10 +2286,8 @@ export const runGate = (cwd = process.cwd(), argv = []) => {
   );
   for (const file of scope.selected) console.log(`   • ${file}`);
 
-  return finish(
-    OUTCOMES.scoped,
-    reportRun(cwd, runStryker(cwd, scope.selected))
-  );
+  const reported = reportRun(cwd, runStryker(cwd, scope.selected));
+  return finish(OUTCOMES.scoped, reported.code, reported.measured);
 };
 
 /**