forgedock 1.10.3 → 1.12.0

package/bin/engine/phases-args.test.mjs

@@ -0,0 +1,112 @@
+// Contract test (forge#3499): the arguments each engine phase passes to its
+// work-on sub-skill must satisfy that spec's `argument-hint`. Fails CI when a
+// phase's `buildArgs` and `commands/<command>.md` drift apart — the failure
+// mode that parked every orchestrate run at architect.
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { PHASES, PhaseArgsError } from "./phases.mjs";
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+
+function argumentHint(command) {
+  const file = path.join(ROOT, "commands", `${command}.md`);
+  assert.ok(existsSync(file), `engine phase command has no spec: ${file}`);
+  const m = readFileSync(file, "utf-8").match(/^---\n([\s\S]*?)\n---/);
+  assert.ok(m, `${command}.md has no frontmatter`);
+  const h = m[1].match(/^argument-hint:\s*(.*)$/m);
+  assert.ok(h, `${command}.md has no argument-hint`);
+  let v = h[1].trim();
+  if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) v = v.slice(1, -1);
+  return v.replace(/\\"/g, '"');
+}
+
+/** Required = flags/positional outside [...] groups; optional = inside. */
+function parseHint(hint) {
+  const required = hint.replace(/\[[^\]]*\]/g, " ");
+  const flagsIn = (t) => [...t.matchAll(/(--[a-z][a-z-]*)/g)].map((x) => x[1]);
+  return {
+    requiredFlags: flagsIn(required),
+    allFlags: flagsIn(hint),
+    requiredPositional: /^\s*\{[A-Z_]+\}/.test(required),
+  };
+}
+
+const state = { v: 0, run: "r", issue: 3499, lane: "staging", committed: ["investigate", "build", "review"],
+  phase: null, branch: "fix/example-3499", pr: 77, terminal: false, terminalReason: null, lease: null };
+const ctx = { repo: "acme/widgets" };
+const io = {
+  git: async () =>
+    "worktree /repo/.claude/worktrees/fix-example-3499\nHEAD 1111111\nbranch refs/heads/fix/example-3499\n",
+};
+
+describe("engine phase args satisfy each target spec's argument-hint (forge#3499)", () => {
+  it("context/architect are not engine phases (work-on/build owns them)", () => {
+    const ids = PHASES.map((p) => p.id);
+    assert.ok(!ids.includes("context") && !ids.includes("architect"), ids.join(","));
+  });
+
+  for (const phase of PHASES) {
+    it(`${phase.id} (${phase.command})`, async () => {
+      assert.equal(typeof phase.buildArgs, "function", `${phase.id} must define buildArgs`);
+      const hint = parseHint(argumentHint(phase.command));
+      const args = await phase.buildArgs({ ...state, terminalReason: phase.id === "remediate" ? "needs-human" : null }, ctx, io);
+
+      assert.ok(Array.isArray(args) && args.every((a) => typeof a === "string"), "args must be an array of strings");
+      assert.ok(args.length > 1, `${phase.id} must not be invoked with only a positional`);
+      for (const a of args) assert.ok(!/[\n\r\t]/.test(a), `control char in arg ${JSON.stringify(a)}`);
+
+      // positional: issue number (or PR number for remediate) comes first
+      const expectedPositional = phase.id === "remediate" ? String(state.pr) : String(state.issue);
+      assert.equal(args[0], expectedPositional);
+      if (hint.requiredPositional) assert.match(args[0], /^[0-9]+$/);
+
+      const emitted = args.filter((a) => a.startsWith("--"));
+      for (const flag of hint.requiredFlags) {
+        const i = args.indexOf(flag);
+        assert.ok(i >= 0, `${phase.id}: required ${flag} missing from [${args.join(" ")}]`);
+        assert.ok(args[i + 1] !== undefined && args[i + 1] !== "" && !args[i + 1].startsWith("--"),
+          `${phase.id}: ${flag} has no value`);
+      }
+      for (const flag of emitted) {
+        assert.ok(hint.allFlags.includes(flag), `${phase.id}: emits ${flag}, which ${phase.command}.md does not declare`);
+      }
+    });
+  }
+
+  it("--gh-flag is a single quoted token, as in the specs' argument-hint", async () => {
+    const args = await PHASES.find((p) => p.id === "investigate").buildArgs(state, ctx, io);
+    assert.equal(args[args.indexOf("--gh-flag") + 1], '"-R acme/widgets"');
+  });
+
+  it("fails closed (PhaseArgsError) on a missing or injectable repo/branch/worktree rather than sending a partial arg set", async () => {
+    const inv = PHASES.find((p) => p.id === "investigate");
+    const review = PHASES.find((p) => p.id === "review");
+    for (const repo of [null, "", "no-slash", "a/b --base main", 'a/b"c', "a/b\nc"]) {
+      await assert.rejects(() => inv.buildArgs(state, { repo }, io), PhaseArgsError, `repo=${JSON.stringify(repo)}`);
+    }
+    await assert.rejects(() => review.buildArgs({ ...state, branch: "x y" }, ctx, io), PhaseArgsError);
+    await assert.rejects(() => review.buildArgs({ ...state, branch: null }, ctx, io), PhaseArgsError);
+    await assert.rejects(() => review.buildArgs(state, ctx, { git: async () => "worktree /repo\nbranch refs/heads/main\n" }), PhaseArgsError);
+    await assert.rejects(() => review.buildArgs(state, ctx, { git: async () => { throw new Error("git down"); } }), PhaseArgsError);
+    await assert.rejects(() => PHASES.find((p) => p.id === "remediate").buildArgs({ ...state, pr: null }, ctx, io), PhaseArgsError);
+  });
+
+  it("close refuses a merged terminal state without a PR (forge#3504)", async () => {
+    const close = PHASES.find((p) => p.id === "close");
+    await assert.rejects(() => close.buildArgs({ ...state, pr: null, terminalReason: "merged" }, ctx, io), PhaseArgsError);
+  });
+
+  it("close derives --terminal-state from the run's terminal reason", async () => {
+    const close = PHASES.find((p) => p.id === "close");
+    for (const [reason, expected] of [[null, "merged"], ["invalid", "invalid"], ["decomposed", "decomposed"]]) {
+      const args = await close.buildArgs({ ...state, terminalReason: reason }, ctx, io);
+      assert.equal(args[args.indexOf("--terminal-state") + 1], expected);
+    }
+    // worktree is optional for close: absent worktree must not fail it
+    const args = await close.buildArgs(state, ctx, { git: async () => "" });
+    assert.ok(!args.includes("--worktree"));
+  });
+});

package/bin/engine/phases.mjs

@@ -221,11 +221,90 @@ function resolveBranch(state, comments) {
   return parseBranchFromMarkers(comments) || state.branch || null;
 }
 
+
+/**
+ * forge#3499: non-blocking evidence about the context / architect children that
+ * `work-on/build` now runs itself. Recorded for visibility only — a missing
+ * marker NEVER fails build (context is advisory; the TRIVIAL band legitimately
+ * skips both children). A BLOCKED / missing-arg child is not hidden here: it
+ * shows up as `absent`, never as a fabricated "skipped" commit.
+ */
+function buildChildEvidence(blob, comments) {
+  const trivial = complexityBand(comments) === "TRIVIAL";
+  const state = (marker) => (has(blob, marker) ? "complete" : trivial ? "skipped-trivial" : "absent");
+  return {
+    context: state(PHASE_MARKERS.context.completionMarker),
+    architect: state(PHASE_MARKERS.architect.completionMarker),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// forge#3499: per-phase argument construction.
+//
+// Every `work-on` phase sub-skill takes ALL of its inputs as arguments (forge#3398
+// forked-phase router) and stops with BLOCKED when one is missing. Each phase's
+// `buildArgs` emits exactly the flags its `commands/<command>.md` `argument-hint`
+// requires; bin/engine/phases-args.test.mjs pins the two together.
+//
+// Values are validated against strict allowlists before use: the runner joins the
+// args array with single spaces into the prompt, so a value with whitespace,
+// quotes or newlines would splice extra arguments (forge#3466 class).
+// ---------------------------------------------------------------------------
+
+export class PhaseArgsError extends Error {
+  constructor(message) { super(message); this.name = "PhaseArgsError"; this.code = "PHASE_ARGS_INVALID"; }
+}
+
+const REPO_RE = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+const BRANCH_RE = /^[A-Za-z0-9._][A-Za-z0-9._\/-]*$/;
+const LANE_RE = BRANCH_RE;
+const PATH_RE = /^[A-Za-z0-9_.\/\\:@+~-]+$/;
+
+function need(value, name, re) {
+  if (value === null || value === undefined || value === "") throw new PhaseArgsError(`missing ${name}`);
+  const v = String(value);
+  if (!re.test(v) || v.includes("..")) throw new PhaseArgsError(`invalid ${name}: ${JSON.stringify(v)}`);
+  return v;
+}
+/** @returns {string[]} the `--repo`/`--gh-flag` pair (gh-flag is ONE quoted token, as in the argument-hint). */
+function repoArgs(ctx) {
+  const repo = need(ctx.repo, "repo", REPO_RE);
+  return ["--repo", repo, "--gh-flag", `"-R ${repo}"`];
+}
+function baseArgs(state) { return ["--base", need(state.lane, "base (lane)", LANE_RE)]; }
+
+/**
+ * Resolve the linked worktree checked out on `branch` from `git worktree list
+ * --porcelain` — the only engine-side ground truth (build.md B1C creates it).
+ * Returns null when absent/prunable/unresolvable; never invents a path.
+ */
+export async function resolveWorktree(state, io) {
+  if (state.worktree) return state.worktree;
+  if (!state.branch) return null;
+  let out;
+  try { out = await io.git(["worktree", "list", "--porcelain"]); } catch { return null; }
+  for (const block of String(out || "").split(/\n\s*\n/)) {
+    const lines = block.split("\n");
+    const wt = lines.find((l) => l.startsWith("worktree "));
+    const br = lines.find((l) => l.startsWith("branch "));
+    if (!wt || !br || lines.some((l) => l.startsWith("prunable"))) continue;
+    if (br.slice("branch ".length).trim() === `refs/heads/${state.branch}`) return wt.slice("worktree ".length).trim();
+  }
+  return null;
+}
+
+async function reviewArgs(state, ctx, io) {
+  const worktree = need(await resolveWorktree(state, io), "worktree (no linked worktree for branch)", PATH_RE);
+  return [String(state.issue), ...repoArgs(ctx), "--worktree", worktree,
+          "--branch", need(state.branch, "branch", BRANCH_RE), ...baseArgs(state)];
+}
+
 /** @type {Phase[]} */
 export const PHASES = [
   {
     id: "investigate",
     command: "work-on/investigate",
+    buildArgs: async (state, ctx) => [String(state.issue), ...repoArgs(ctx)],
     entryCondition: () => true,
     async detectOutcome(state, io) {
       const { blob } = await issueMarkers(state.issue, io);
@@ -255,6 +334,7 @@ export const PHASES = [
     // before the run terminates.
     id: "decompose",
     command: "work-on/decompose",
+    buildArgs: async (state, ctx) => [String(state.issue), ...repoArgs(ctx)],
     entryCondition: (s) => s.terminalReason === "decomposed",
     async detectOutcome(state, io) {
       const { blob } = await issueMarkers(state.issue, io);
@@ -266,50 +346,15 @@ export const PHASES = [
     // which runs its own /work-on pipeline — nothing more for THIS run to do.
     isTerminalAfter: () => true,
   },
-  {
-    id: "context",
-    command: "work-on/build/context",
-    entryCondition: (s) => s.committed.includes("investigate"),
-    async reconcile(state, io) {
-      const markers = await issueMarkers(state.issue, io);
-      if (complexityBand(markers.comments) === "TRIVIAL") {
-        return { satisfied: true, outputs: { skipped: "trivial-complexity-band", phase: "context" } };
-      }
-      // Idempotent resume: FORGE:CONTEXT:COMPLETE present → skip the LLM re-run.
-      // Bare FORGE:CONTEXT matches a partial/interrupted annotation — require :COMPLETE.
-      return has(markers.blob, PHASE_MARKERS.context.completionMarker) ? { satisfied: true } : { satisfied: false };
-    },
-    async detectOutcome(state, io) {
-      const { blob } = await issueMarkers(state.issue, io);
-      // Context is non-critical: a missing marker is a VISIBLE skip, not a hard fail (spec §7).
-      if (has(blob, PHASE_MARKERS.context.presenceMarker)) return { status: "committed", outputs: {} };
-      return { status: "committed", outputs: { skipped: true, which: "context" } };
-    },
-  },
-  {
-    id: "architect",
-    command: "work-on/build/architect",
-    entryCondition: (s) => s.committed.includes("context"),
-    async reconcile(state, io) {
-      const markers = await issueMarkers(state.issue, io);
-      if (complexityBand(markers.comments) === "TRIVIAL") {
-        return { satisfied: true, outputs: { skipped: "trivial-complexity-band", phase: "architect" } };
-      }
-      // Idempotent resume: FORGE:ARCHITECT:COMPLETE present → skip the LLM re-run.
-      // Bare FORGE:ARCHITECT matches a partial/interrupted annotation — require :COMPLETE.
-      return has(markers.blob, PHASE_MARKERS.architect.completionMarker) ? { satisfied: true } : { satisfied: false };
-    },
-    async detectOutcome(state, io) {
-      const { blob } = await issueMarkers(state.issue, io);
-      return has(blob, PHASE_MARKERS.architect.completionMarker)
-        ? { status: "committed", outputs: {} }
-        : { status: "failed", detail: `no ${PHASE_MARKERS.architect.completionMarker}` };
-    },
-  },
   {
     id: "build",
     command: "work-on/build",
-    entryCondition: (s) => s.committed.includes("architect"),
+    buildArgs: async (state, ctx) => [String(state.issue), ...repoArgs(ctx), ...baseArgs(state)],
+    // forge#3499: work-on/build owns worktree creation and runs the context /
+    // architect / implement / validate children itself (it needs the worktree
+    // as `--repo-path`), so the engine no longer schedules context/architect as
+    // top-level phases — build is eligible as soon as investigate committed.
+    entryCondition: (s) => s.committed.includes("investigate"),
     async reconcile(state, io) {
       // Idempotent resume: resolve the real branch from ground truth (FORGE:BUILDER
       // comment) rather than trusting a possibly-stale/absent state.branch, then
@@ -334,7 +379,9 @@ export const PHASES = [
       // from a genuine git-confirmed zero and would wrongly trip the
       // non-retryable guard below on the very first attempt.
       const ahead = branch ? await commitsAhead(state.lane, branch, io) : -1; // … AND real commits
-      if (complete && ahead > 0) return { status: "committed", outputs: { branch } };
+      if (complete && ahead > 0) {
+        return { status: "committed", outputs: { branch, ...buildChildEvidence(blob, comments) } };
+      }
       const detail = `builder complete=${complete} commitsAhead=${ahead} branch=${branch || "unresolved"}`;
       // forge#2176: when the builder has already posted FORGE:BUILDER:COMPLETE
       // but the resolved (real, ground-truth) branch has zero commits ahead of
@@ -369,17 +416,33 @@ export const PHASES = [
   {
     id: "review",
     command: "work-on/review",
+    buildArgs: reviewArgs,
     entryCondition: (s) => s.committed.includes("build"),
     async reconcile(state, io) {
       const pr = await openPrFor(state, io);   // adopt an existing PR instead of opening a second
       return pr ? { satisfied: false, outputs: { pr } } : { satisfied: false };
     },
-    async detectOutcome(state, io) {
+    async detectOutcome(state, io, result) {
       const pr = await prStatusFor(state, io);
       if (!pr) return { status: "failed", detail: "no PR created" };
       if (pr.merged) return { status: "committed", outputs: { pr: pr.number } };
-      if (pr.needsHuman) return { status: "blocked", detail: "review escalated", outputs: { pr: pr.number } };
-      return { status: "failed", detail: "PR open, not merged", retryable: false };
+      // forge#3521: the spec (commands/work-on/review.md) signals an in-PR fix
+      // by labelling the ISSUE needs-human and returning REVIEW_RESULT
+      // `status: NEXT / next: remediate`; the PR label is back-compat only.
+      // The PR number from GitHub (openPrFor) always wins over parsed text.
+      const outputs = { pr: pr.number };
+      const escalated = { status: "blocked", detail: "review escalated", outputs };
+      if (pr.needsHuman) return escalated;
+      const rr = parseReviewResult(result?.text);
+      if (rr && rr.status === "NEXT" && rr.next === "remediate") return escalated;
+      // An explicit REVIEW_RESULT status is authoritative: BLOCKED/COMPLETE exits
+      // (phase trail, ci gate, base conflict, merge refusal) also label the issue
+      // needs-human but are NOT remediation handoffs, so skip the label fallback.
+      if (rr && rr.status) return { status: "failed", detail: "PR open, not merged", retryable: false, handoff: false, outputs };
+      let snap = null;
+      try { snap = await issueSnapshot(state.issue, io); } catch { snap = null; }
+      if (snap?.ok && snap.labels.includes("needs-human")) return escalated;
+      return { status: "failed", detail: "PR open, not merged", retryable: false, outputs };
     },
   },
   {
@@ -398,6 +461,9 @@ export const PHASES = [
     // handing the PR to remediation in the same run.
     id: "remediate",
     command: "work-on/remediate",
+    buildArgs: async (state, ctx) => [
+      need(state.pr, "pr", /^[0-9]+$/), "--issue", String(state.issue), ...repoArgs(ctx), ...baseArgs(state),
+    ],
     entryCondition: (s) => s.committed.includes("review") && s.terminalReason === "needs-human",
     async detectOutcome(state, io) {
       const { blob } = await issueMarkers(state.issue, io);
@@ -435,6 +501,25 @@ export const PHASES = [
   {
     id: "close",
     command: "work-on/close",
+    buildArgs: async (state, ctx, io) => {
+      // Only --terminal-state is required by close.md; the rest are optional context.
+      // forge#3506: fail closed — `merged` only from a null/merged reason. A residual
+      // non-merged handoff reason (needs-human, awaiting-merge, engine-error, ...) must never
+      // be closed as merged.
+      const reason = state.terminalReason ?? null;
+      if (reason !== null && !["merged", "decomposed", "invalid"].includes(reason))
+        throw new PhaseArgsError(`refusing close --terminal-state merged from terminalReason ${JSON.stringify(reason)}`);
+      const terminal = reason === "decomposed" ? "decomposed"
+        : reason === "invalid" ? "invalid" : "merged";
+      const args = [String(state.issue), ...repoArgs(ctx), ...baseArgs(state)];
+      // forge#3504: a merged close with no PR is fabricated evidence — require it.
+      if (state.pr != null || terminal === "merged") args.push("--pr", need(state.pr, "pr", /^[0-9]+$/));
+      if (state.branch) args.push("--branch", need(state.branch, "branch", BRANCH_RE));
+      const wt = await resolveWorktree(state, io);
+      if (wt && PATH_RE.test(wt)) args.push("--worktree", wt);
+      args.push("--terminal-state", terminal);
+      return args;
+    },
     entryCondition: (s) => s.committed.includes("review"),
     async reconcile(state, io) {
       // Idempotent resume: issue already closed or workflow:merged label set → skip the LLM re-run.
@@ -468,6 +553,28 @@ export const PHASES = [
   },
 ];
 
+/**
+ * Parse the LAST `REVIEW_RESULT:` block from a phase's final reply (forge#3521).
+ * Untrusted model output: only the fixed keys below are read, via anchored
+ * line matches; `pr_number` must be digits-only. Returns null when absent.
+ */
+export function parseReviewResult(text) {
+  if (typeof text !== "string" || !text) return null;
+  const lines = text.split(/\r?\n/);
+  let start = -1;
+  for (let i = 0; i < lines.length; i++) if (/^\s*REVIEW_RESULT:\s*$/.test(lines[i])) start = i;
+  if (start < 0) return null;
+  const out = {};
+  for (let i = start + 1; i < lines.length; i++) {
+    const m = /^\s+(status|next|remediation|pr_number):[ \t]*(\S*)[ \t]*$/.exec(lines[i]);
+    if (m) { if (!(m[1] in out)) out[m[1]] = m[2]; continue; }
+    if (/^\s+[A-Za-z_]+:/.test(lines[i]) || !lines[i].trim()) continue;
+    break;
+  }
+  if (out.pr_number !== undefined && !/^[0-9]+$/.test(out.pr_number)) delete out.pr_number;
+  return out;
+}
+
 async function openPrFor(state, io) {
   if (!state.branch) return null;
   const out = await io.gh(["pr", "list", "--head", state.branch, "--json", "number", "--state", "all"]);

package/bin/engine/runlog.mjs

@@ -68,10 +68,19 @@ export function deriveState(events) {
         s.v = e.seq;
         if (e.outputs?.branch) s.branch = e.outputs.branch;
         if (e.outputs?.pr != null) s.pr = e.outputs.pr;
+        // forge#3504: a blocked phase persists its reason so a resumed run still routes to
+        // remediate instead of defaulting to a "merged" close.
+        if (e.terminalReason) s.terminalReason = e.terminalReason;
         break;
       case "RUN_TERMINAL":
         s.terminal = true; s.terminalReason = e.reason ?? "done"; s.v = e.seq;
         break;
+      // forge#3511: an explicit `run-issue --retry` reopens an engine-error
+      // terminal. Bumping `v` makes the local state newer than the stale
+      // remote terminal index so reconcile remirrors instead of re-terminating.
+      case "RUN_REOPEN":
+        s.terminal = false; s.terminalReason = null; s.v = e.seq;
+        break;
       // forge#2524: a session-limit pause is purely informational — it does
       // NOT touch committed/terminal/terminalReason. The phase that hit the
       // pause is, by construction, not yet committed (the engine is about to

package/bin/engine-cli.mjs

@@ -337,16 +337,21 @@ export function lastLocalRun(dir) {
  *                          `runCommand()` call; only applies on the "api" backend.
  *                          Omit to keep runner.mjs's default (`FORGEDOCK_MODEL` env
  *                          or its built-in default).
+ *   --retry                Optional (forge#3511). Reopen a run that ended `engine-error`
+ *                          (e.g. a session-limit hit) and resume from its last committed
+ *                          phase. Other terminal reasons are not reopened.
  */
 export async function runFromCli(argv, deps = {}) {
   const issue = parseInt(argv[0], 10);
-  if (!Number.isInteger(issue)) throw new Error("usage: forgedock run-issue <issue-number> --lane <lane>");
+  if (!Number.isInteger(issue)) throw new Error("usage: forgedock run-issue <issue-number> --lane <lane> [--retry]");
   assertOpenCodeNativeRuntime({ operation: "forgedock run-issue" });
   const lane = flag(argv, "--lane");
   if (!lane) throw new Error("--lane is required: e.g. --lane main or --lane staging. No default to prevent accidental production targeting.");
   const repo = flag(argv, "--repo");
   const backend = flag(argv, "--backend");
   const model = flag(argv, "--model");
+  // Boolean flag: only counts at a flag position, never as another flag's value.
+  const retry = argv.some((a, i) => a === "--retry" && !["--lane", "--repo", "--backend", "--model"].includes(argv[i - 1]));
   const io = deps.io ?? makeIo();
   await assertRepoMatchesCwd(io, repo);
   const runIssueFn = deps.runIssue ?? runIssue;
@@ -375,13 +380,19 @@ export async function runFromCli(argv, deps = {}) {
     else if (e.event === "phase_paused") console.log(`⏸ phase ${e.phase} paused: ${e.detail ?? "session limit"}`);
   };
   const res = await runIssueFn({ issue, dir, agentId, lane, io,
+    ...(repo ? { repo } : {}),
     runner: (await import("./runner.mjs")).runCommand, now: () => Date.now(),
     onProgress,
     // Only forwarded when explicitly provided — omitting them preserves
     // runIssue's/runner.mjs's existing defaults (forge#2028).
     ...(backend ? { backend } : {}),
-    ...(model ? { model } : {}) });
+    ...(model ? { model } : {}),
+    ...(retry ? { retry: true } : {}) });
   console.log(`issue #${issue} → ${res.terminalReason}`);
+  if (res.terminalReason === "not-retryable") {
+    console.log(res.detail ?? "run is not retryable");
+    return res;
+  }
   // forge#2175: a non-success termination previously printed nothing beyond
   // the bare reason above — the actual failing phase/attempt/reason was only
   // recoverable by manually reading ~/.forge/runs/{issue}.jsonl and then the