@muggleai/works 5.17.0 → 5.18.0-staging.118

package/README.md

@@ -387,7 +387,7 @@ muggle serve --e2e        # Cloud E2E tools only (muggle-remote-*)
 muggle serve --local      # Local E2E tools only (muggle-local-*)
 
 # Setup and Diagnostics
-muggle init               # First-run walkthrough: explains Muggle Test, saves preferences
+muggle init               # First-run walkthrough: preferences, then offers the CI check
 muggle init --json        # Emit the walkthrough for another front-end to render
 muggle setup              # Download/update browser test runner
 muggle setup --force      # Force re-download
@@ -398,6 +398,10 @@ muggle login              # Manually trigger login
 muggle logout             # Clear credentials
 muggle status             # Show auth status
 
+# Pull request checks
+muggle ci-install         # Add the walkthrough check to this repo's GitHub Actions
+muggle ci-install --force # Replace an existing workflow file
+
 # Info
 muggle --version          # Show version
 muggle --help             # Show help
@@ -405,6 +409,59 @@ muggle --help             # Show help
 
 ---
 
+## Pull request walkthrough check
+
+When you open a pull request from a Claude session running this plugin, Muggle reserves a comment on it for the E2E visual walkthrough and holds the turn open until that comment is settled — by the walkthrough itself, or by a stated reason E2E does not apply.
+
+A pull request opened any other way — the GitHub web UI, a teammate without the plugin — never passes through that session, so the check also runs in GitHub Actions.
+
+`muggle init` asks whether you want it and installs it for you. To add it to another repository later:
+
+```bash
+muggle ci-install
+```
+
+That creates `.github/workflows/muggle-walkthrough.yml`. To add it by hand instead, create that file with:
+
+<!-- muggle:ci-workflow-snippet -->
+```yaml
+name: muggle-walkthrough
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, ready_for_review]
+  issue_comment:
+    types: [created, edited]
+
+permissions:
+  contents: read
+  checks: write
+  pull-requests: write
+
+concurrency:
+  group: muggle-walkthrough-${{ github.event.pull_request.number || github.event.issue.number }}
+  cancel-in-progress: true
+
+jobs:
+  walkthrough-comment:
+    if: github.event_name == 'pull_request' || github.event.issue.pull_request
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check the walkthrough comment
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: npx -y -p @muggleai/works muggle pr-walkthrough-check --check-run
+```
+<!-- /muggle:ci-workflow-snippet -->
+
+Three things worth knowing:
+
+- The verdict is published as a check run against the pull request's head commit, not as this job's own status. An `issue_comment` run executes against the default branch, and only a head-commit check reaches the pull request from there — which is what lets settling the comment turn the check green without a new push.
+- GitHub reads the `issue_comment` trigger from the **default branch's** copy of the workflow, so comment-driven re-runs start working only once it is merged.
+- On a pull request from a fork, `GITHUB_TOKEN` is read-only and the check run cannot be published. The command fails open and reports nothing rather than blocking the pull request.
+
+---
+
 ## Setup and Configuration
 
 Authentication happens automatically when you first use a tool that requires it: a browser window opens with a verification code, you log in with your Muggle AI account, and the tool call continues. Credentials persist across sessions in `~/.muggle-ai/`.

package/dist/{chunk-6ILUPFM5.js → chunk-63RAPKGG.js}

@@ -13,7 +13,7 @@ import { Command } from 'commander';
 import axios from 'axios';
 import { platform, homedir, arch } from 'os';
 import { createInterface } from 'readline/promises';
-import { execFile } from 'child_process';
+import { execFile, execFileSync } from 'child_process';
 import { pipeline } from 'stream/promises';
 import { readFile } from 'fs/promises';
 import { verify } from 'sigstore';
@@ -893,6 +893,81 @@ async function buildPrSectionCommand(options) {
     process.exitCode = code;
   }
 }
+
+// src/ci-workflow/constants.ts
+var USER_WORKFLOW_PATH = ".github/workflows/muggle-walkthrough.yml";
+var USER_WORKFLOW_COMMAND = "npx -y -p @muggleai/works muggle pr-walkthrough-check --check-run";
+
+// src/ci-workflow/template.ts
+function renderUserWorkflow() {
+  return `name: muggle-walkthrough
+
+# Every PR owes a settled Muggle AI walkthrough comment: the E2E acceptance
+# result, or a stated reason E2E does not apply. The verdict rides a check run
+# against the PR head SHA rather than this job's own status, because the
+# issue_comment trigger runs against the default branch \u2014 only a head-SHA check
+# reaches the PR from there, which is what lets settling the comment turn the
+# check green with no new push.
+#
+# GitHub reads the issue_comment trigger from the default branch's copy of this
+# file, so comment-driven re-runs only start working once this is merged.
+#
+# On a pull request from a fork, GITHUB_TOKEN is read-only and the check run
+# cannot be published; the command fails open and reports nothing.
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, ready_for_review]
+  issue_comment:
+    types: [created, edited]
+
+permissions:
+  contents: read
+  checks: write
+  pull-requests: write
+
+concurrency:
+  group: muggle-walkthrough-\${{ github.event.pull_request.number || github.event.issue.number }}
+  cancel-in-progress: true
+
+jobs:
+  walkthrough-comment:
+    # issue_comment fires for plain issues too; only PR conversations matter.
+    if: github.event_name == 'pull_request' || github.event.issue.pull_request
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check the walkthrough comment
+        env:
+          GH_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+        run: ${USER_WORKFLOW_COMMAND}
+`;
+}
+
+// src/cli/ci-install.ts
+function installCiWorkflow(options) {
+  const workflowPath = join(options.cwd, USER_WORKFLOW_PATH);
+  if (!existsSync(join(options.cwd, ".git"))) {
+    return { outcome: "not-a-repository" /* NotARepository */, workflowPath };
+  }
+  if (existsSync(workflowPath) && !options.force) {
+    return { outcome: "already-present" /* AlreadyPresent */, workflowPath };
+  }
+  mkdirSync(dirname(workflowPath), { recursive: true });
+  writeFileSync(workflowPath, renderUserWorkflow());
+  return { outcome: "installed" /* Installed */, workflowPath };
+}
+var MESSAGES = {
+  ["installed" /* Installed */]: (path6) => `Wrote ${path6}
+Commit it, and every pull request here will owe a settled Muggle AI walkthrough comment.`,
+  ["already-present" /* AlreadyPresent */]: (path6) => `${path6} already exists \u2014 left untouched. Re-run with --force to replace it.`,
+  ["not-a-repository" /* NotARepository */]: () => "Not a git repository \u2014 run this from the repo that should carry the check."
+};
+function ciInstallCommand(flags) {
+  const report = installCiWorkflow({ cwd: process.cwd(), force: flags.force === true });
+  const render = MESSAGES[report.outcome];
+  process.stdout.write(`${render(report.workflowPath)}
+`);
+  if (report.outcome === "not-a-repository" /* NotARepository */) process.exitCode = 1;
+}
 var logger2 = getLogger();
 var ELECTRON_APP_DIR = "electron-app";
 var CURSOR_SKILLS_DIR = ".cursor";
@@ -1619,6 +1694,15 @@ function getHelpGuidance() {
 function helpCommand() {
   console.log(getHelpGuidance());
 }
+var QUESTION = "Make E2E acceptance a CI check in this repo? It adds a GitHub Actions workflow so pull requests\nopened outside Claude still have to carry a Muggle walkthrough comment. [y/N]: ";
+async function offerCiWorkflow(ask, cwd) {
+  if (!existsSync(join(cwd, ".git"))) return "not-applicable" /* NotApplicable */;
+  if (existsSync(join(cwd, USER_WORKFLOW_PATH))) return "already-installed" /* AlreadyInstalled */;
+  const answer = (await ask(QUESTION)).trim().toLowerCase();
+  if (answer !== "y" && answer !== "yes") return "declined" /* Declined */;
+  installCiWorkflow({ cwd, force: false });
+  return "installed" /* Installed */;
+}
 var ACCEPT_HINT = "press Enter to accept";
 function printPrimer() {
   const plan = buildOnboardingPlan();
@@ -1760,6 +1844,24 @@ function reportOutcome(result) {
   console.log("Preferences saved.");
   console.log(summary);
 }
+var CI_OFFER_REPORT = {
+  ["installed" /* Installed */]: `Added ${USER_WORKFLOW_PATH} \u2014 commit it, and every pull request here will owe a settled walkthrough comment.`,
+  ["declined" /* Declined */]: "Left CI alone. Run `muggle ci-install` whenever you want it.",
+  ["already-installed" /* AlreadyInstalled */]: null,
+  ["not-applicable" /* NotApplicable */]: null
+};
+async function runCiOffer() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const line = CI_OFFER_REPORT[await offerCiWorkflow((q) => rl.question(q), process.cwd())];
+    if (line) {
+      console.log("");
+      console.log(line);
+    }
+  } finally {
+    rl.close();
+  }
+}
 async function initCommand(options) {
   if (options.json) {
     console.log(JSON.stringify(buildOnboardingPlan(), null, 2));
@@ -1785,6 +1887,7 @@ async function initCommand(options) {
     console.log("Muggle is already set up. Re-running the walkthrough \u2014 your current values are pre-selected.");
   }
   reportOutcome(applyOnboardingAnswers(await runTerminalWalkthrough()));
+  await runCiOffer();
 }
 
 // src/cli/login.ts
@@ -1856,6 +1959,180 @@ async function statusCommand() {
   }
 }
 
+// src/pr-walkthrough/constants.ts
+var REPORT_SENTINEL = "muggle-pr-section";
+var WALKTHROUGH_SLOT_MARKER = "<!-- muggle-pr-walkthrough:v1 -->";
+var WALKTHROUGH_SKIPPED_MARKER = "<!-- muggle-pr-walkthrough-status:skipped -->";
+var WALKTHROUGH_COMMENT_HEADING = "### Muggle AI \u2014 PR visual walkthrough";
+var GH_COMMENT_TIMEOUT_MS = 1e4;
+
+// src/pr-walkthrough/comment.ts
+function renderReservedComment() {
+  return `${WALKTHROUGH_SLOT_MARKER}
+${WALKTHROUGH_COMMENT_HEADING}
+
+_Awaiting the E2E acceptance run. Muggle edits this comment in place when the run finishes \u2014 or records why E2E does not apply to this change._`;
+}
+function classifyComment(body) {
+  if (body.includes(REPORT_SENTINEL)) return "reported" /* Reported */;
+  if (!body.includes(WALKTHROUGH_SLOT_MARKER)) return "not-designated" /* NotDesignated */;
+  if (body.includes(WALKTHROUGH_SKIPPED_MARKER)) return "skipped" /* Skipped */;
+  return "pending" /* Pending */;
+}
+function walkthroughVerdict(bodies) {
+  const statuses = bodies.map(classifyComment);
+  if (statuses.includes("reported" /* Reported */) || statuses.includes("skipped" /* Skipped */)) {
+    return "satisfied" /* Satisfied */;
+  }
+  if (statuses.includes("pending" /* Pending */)) return "pending" /* Pending */;
+  return "missing" /* Missing */;
+}
+var GH_CALLS_ENV = "MUGGLE_GUARDRAIL_GH_CALLS";
+var defaultGhRunner = (args, input) => {
+  if (process.env[GH_CALLS_ENV] === "off") return null;
+  try {
+    return execFileSync("gh", args, {
+      encoding: "utf-8",
+      input,
+      timeout: GH_COMMENT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+  } catch {
+    return null;
+  }
+};
+function listPrComments(pr, run) {
+  let raw;
+  try {
+    raw = run(["api", "--paginate", `repos/${pr.repo}/issues/${pr.prNumber}/comments`]);
+  } catch {
+    return null;
+  }
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function writeJson(args, payload, run) {
+  try {
+    return run(args, JSON.stringify(payload)) !== null;
+  } catch {
+    return false;
+  }
+}
+function postPrComment(pr, body, run) {
+  return writeJson(
+    ["api", "--method", "POST", `repos/${pr.repo}/issues/${pr.prNumber}/comments`, "--input", "-"],
+    { body },
+    run
+  );
+}
+function createCheckRun(repo, checkRun, run) {
+  return writeJson(["api", "--method", "POST", `repos/${repo}/check-runs`, "--input", "-"], {
+    name: checkRun.name,
+    head_sha: checkRun.headSha,
+    status: "completed",
+    conclusion: checkRun.conclusion,
+    output: { title: checkRun.title, summary: checkRun.summary }
+  }, run);
+}
+
+// src/pr-walkthrough/reserve.ts
+function reserveComment(pr, comments, run) {
+  const claimed = comments.some(
+    (comment) => classifyComment(comment.body) !== "not-designated" /* NotDesignated */
+  );
+  if (claimed) return false;
+  return postPrComment(pr, renderReservedComment(), run);
+}
+
+// src/cli/pr-walkthrough/check.ts
+var CHECK_RUN_NAME = "muggle-walkthrough";
+var SUMMARIES = {
+  ["success" /* Success */]: "This PR's Muggle AI walkthrough comment is settled \u2014 it carries the E2E acceptance walkthrough, or states why E2E does not apply.",
+  ["failure" /* Failure */]: "This PR's Muggle AI walkthrough comment is still empty. Run the E2E acceptance suite and post the walkthrough into it (/muggle:muggle-test), or record why E2E does not apply to this change.",
+  ["neutral" /* Neutral */]: "The PR's comments could not be read, so the walkthrough duty could not be judged."
+};
+function conclusionFor(verdict) {
+  return verdict === "satisfied" /* Satisfied */ ? "success" /* Success */ : "failure" /* Failure */;
+}
+async function runPrWalkthroughCheck(options, run = defaultGhRunner) {
+  const pr = { repo: options.repo, prNumber: options.prNumber };
+  const comments = listPrComments(pr, run);
+  let conclusion = "neutral" /* Neutral */;
+  if (comments !== null) {
+    const verdict = walkthroughVerdict(comments.map((comment) => comment.body));
+    if (verdict === "missing" /* Missing */) reserveComment(pr, comments, run);
+    conclusion = conclusionFor(verdict);
+  }
+  if (options.publishCheckRun) {
+    createCheckRun(
+      options.repo,
+      {
+        name: CHECK_RUN_NAME,
+        headSha: options.headSha,
+        conclusion,
+        title: "Muggle AI PR visual walkthrough",
+        summary: SUMMARIES[conclusion]
+      },
+      run
+    );
+  }
+  const failsLocally = conclusion === "failure" /* Failure */ && !options.publishCheckRun;
+  return {
+    conclusion,
+    exitCode: failsLocally ? 1 : 0,
+    summary: SUMMARIES[conclusion]
+  };
+}
+function readEvent(eventPath) {
+  if (!eventPath) return {};
+  try {
+    return JSON.parse(readFileSync(eventPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function fetchHeadSha(repo, prNumber, run) {
+  try {
+    return run(["api", `repos/${repo}/pulls/${prNumber}`, "--jq", ".head.sha"])?.trim() ?? null;
+  } catch {
+    return null;
+  }
+}
+function resolveCheckTarget(flags, env, run = defaultGhRunner) {
+  const repo = flags.repo ?? env.GITHUB_REPOSITORY;
+  if (!repo) return null;
+  const event = readEvent(env.GITHUB_EVENT_PATH);
+  const commentedPrNumber = event.issue?.pull_request ? event.issue.number : void 0;
+  const prNumber = Number(flags.pr ?? event.pull_request?.number ?? commentedPrNumber ?? NaN);
+  if (!Number.isInteger(prNumber) || prNumber <= 0) return null;
+  const headSha = flags.headSha ?? event.pull_request?.head?.sha ?? fetchHeadSha(repo, prNumber, run);
+  if (!headSha) return null;
+  return {
+    repo,
+    prNumber,
+    headSha,
+    publishCheckRun: flags.checkRun === true
+  };
+}
+
+// src/cli/pr-walkthrough-check.ts
+async function prWalkthroughCheckCommand(flags) {
+  const target = resolveCheckTarget(flags, process.env);
+  if (!target) {
+    process.stderr.write("pr-walkthrough-check: no pull request to judge\n");
+    return;
+  }
+  const judgment = await runPrWalkthroughCheck(target);
+  process.stdout.write(`${judgment.conclusion}: ${judgment.summary}
+`);
+  process.exitCode = judgment.exitCode;
+}
+
 // src/cli/disclosure/disclosure-constants.ts
 var DISCLOSURE_OPT_OUT_MARKER = "To opt out,";
 var DISCLOSURE_OPT_OUT_COPY = 'To opt out, set MUGGLE_TELEMETRY_DISABLED=1 in your environment, or set "telemetryEnabled": false at the top level of ~/.muggle-ai/preferences.json.';
@@ -2641,6 +2918,8 @@ function createProgram() {
   program.command("logout").description("Clear stored credentials").action(logoutCommand);
   program.command("status").description("Show authentication status").action(statusCommand);
   program.command("build-pr-section").description("Render a muggle-do PR body evidence block from an e2e report on stdin").option("--max-body-bytes <n>", "Max UTF-8 byte budget for the PR body (default 60000)").action(buildPrSectionCommand);
+  program.command("pr-walkthrough-check").description("Check that a PR's Muggle AI walkthrough comment carries a result or a stated skip").option("--repo <owner/repo>", "Repository (default: $GITHUB_REPOSITORY)").option("--pr <number>", "Pull request number (default: the Actions event payload)").option("--head-sha <sha>", "Commit the check run attaches to (default: the PR head)").option("--check-run", "Publish the verdict as a check run instead of failing the process").action(prWalkthroughCheckCommand);
+  program.command("ci-install").description("Add the Muggle walkthrough check to this repository's GitHub Actions").option("--force", "Replace an existing workflow file").action(ciInstallCommand);
   program.action(() => {
     helpCommand();
   });

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { runCli } from './chunk-6ILUPFM5.js';
+import { runCli } from './chunk-63RAPKGG.js';
 import './chunk-EKSYEVM2.js';
 
 // src/cli/main.ts

package/dist/index.js

@@ -1,2 +1,2 @@
-export { src_exports as commands, createUnifiedMcpServer, server_exports as server } from './chunk-6ILUPFM5.js';
+export { src_exports as commands, createUnifiedMcpServer, server_exports as server } from './chunk-63RAPKGG.js';
 export { createChildLogger, e2e_exports as e2e, getConfig, getLocalQaTools, getLogger, getQaTools, local_exports as localQa, mcp_exports as mcp, e2e_exports as qa, src_exports as shared } from './chunk-EKSYEVM2.js';

package/dist/plugin/agents/visual-walkthrough-builder.md

@@ -33,18 +33,18 @@ echo "$REPORT_JSON" | muggle build-pr-section > /tmp/muggle-pr-section.json
 
 **Mode A (`post`)** — deliver `body`, then `comment` only if non-null. Sign each posted body per [`../skills/_shared/vcs/post-signature.md`](../skills/_shared/vcs/post-signature.md) with `--mode plain` — this post is the walkthrough's own, so the command it names is `/muggle-pr-visual-walkthrough`.
 
-**Update in place when this PR already carries a walkthrough.** A rerun after a failure must leave the PR with **one** walkthrough reflecting latest state, not a comment per attempt. Resolve which comment to update by reading the PR — never by remembering an id — so the behavior is idempotent across sessions and survives a lost session or a forgotten handle:
+**Settle the designated comment.** Every PR carries one comment reserved for this walkthrough — posted the moment the PR opened, marked `muggle-pr-walkthrough`, and empty until a run settles it. Fill that comment rather than adding another: a rerun after a failure must leave the PR with **one** walkthrough reflecting latest state, and a fresh post would strand the reserved slot pending, which is what the PR's walkthrough check fails on. Resolve which comment to fill by reading the PR — never by remembering an id — so the behavior is idempotent across sessions and survives a lost session or a forgotten handle:
 
 ```bash
 sign() { bash "${CLAUDE_PLUGIN_ROOT}/scripts/sign-body.sh" --command /muggle-pr-visual-walkthrough --mode plain; }
 existing=$(gh api "repos/<owner>/<repo>/issues/<prNumber>/comments" \
-  --jq '[.[] | select(.body | contains("muggle-pr-section")) | .id] | join(" ")')
+  --jq '[.[] | select(.body | contains("muggle-pr-section") or contains("muggle-pr-walkthrough")) | .id] | join(" ")')
 ```
 
 - `existing` empty → post fresh: `jq -r '.body' … | sign | gh pr comment <prNumber> --body-file -`, then the same for `.comment` when non-null.
 - `existing` non-empty → update the first id with `body` via `gh api --method PATCH repos/<owner>/<repo>/issues/comments/<id> -F body=@-`, feeding the same signed text on stdin. Handle `comment` against the second id when both exist; post it fresh when the overflow is new, and delete a now-surplus overflow comment (`gh api --method DELETE …`) so a stale tail never outlives the run it described.
 
-Match only comments carrying the sentinel — never every comment the loop user wrote — so an unrelated reply is never overwritten.
+Match only comments carrying one of those markers — never every comment the loop user wrote — so an unrelated reply is never overwritten.
 
 Report back: PR URL, whether an overflow comment was involved, and whether this was a fresh post or an update.
 

package/dist/plugin/hooks/hooks.json

@@ -27,7 +27,7 @@
     ],
     "PreToolUse": [
       {
-        "matcher": "Bash",
+        "matcher": "Bash|PowerShell",
         "hooks": [
           {
             "type": "command",
@@ -57,13 +57,13 @@
     ],
     "PostToolUse": [
       {
-        "matcher": "Bash",
+        "matcher": "Bash|PowerShell",
         "hooks": [
           {
             "type": "command",
             "command": "bash \"${CLAUDE_PLUGIN_ROOT}/scripts/guardrail-pr-opened.sh\"",
             "async": false,
-            "timeout": 10
+            "timeout": 25
           },
           {
             "type": "command",

package/dist/plugin/scripts/guardrail-e2e-gate.sh

@@ -1,17 +1,19 @@
 #!/usr/bin/env bash
 set -uo pipefail
 
-# tests-green → E2E gate (Stop). When unit tests passed this session and no E2E
-# acceptance run has happened, offer to run change-driven E2E (gated by
-# autoE2ETest). Fires once per session.
+# tests-green-or-PR-opened → E2E gate (Stop). When unit tests passed this
+# session or a PR was opened, and no E2E acceptance run has happened, offer to
+# run change-driven E2E (gated by autoE2ETest). Fires once per session.
 #
 # This must stay synchronous (only a sync Stop hook can block the turn end), and
 # it fires on EVERY turn end. There is no command payload to key off, so the
 # pre-filter reads the same per-session state file guardrails.mjs uses and only
-# spawns Node when the gate could actually fire — i.e. shouldRunE2E: unit tests
-# went green and no E2E run is recorded yet. On the overwhelming majority of
-# turns (no test run this session) the state file is absent or unitTestsGreen is
-# unset, so we return {} in-shell and never pay Node cold-start. Degrades to {}.
+# spawns Node when the gate could actually fire — i.e. shouldRunE2E's two
+# triggers, with no E2E run recorded yet. It must track that predicate exactly:
+# a pre-filter narrower than the gate retires the gate silently. On the
+# overwhelming majority of turns (no test run, no PR) the state file is absent,
+# or unitTestsGreen is unset while prsHandled is empty, so we return {} in-shell
+# and never pay Node cold-start. Degrades to {}.
 payload="$(cat)"
 
 raw_sid="$(printf '%s' "$payload" | grep -oE '"session_id"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 | sed -E 's/.*:[[:space:]]*"([^"]*)".*/\1/')"
@@ -28,7 +30,7 @@ fi
 
 state_file="$home/.muggle-ai/guardrails/$sid.json"
 if [ ! -f "$state_file" ] \
-  || ! grep -q '"unitTestsGreen": true' "$state_file" \
+  || { ! grep -q '"unitTestsGreen": true' "$state_file" && grep -q '"prsHandled": \[\]' "$state_file"; } \
   || grep -q '"e2eReleased": true' "$state_file" \
   || grep -q '"e2eRun": true' "$state_file"; then
   printf '{}'