@warpgogol/forge 5.3.4 → 6.2.0

package/os/compass/handlers/tests/compass-audit-validate.test.ts

@@ -16,6 +16,7 @@ import { join } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { runCompassAuditValidate } from "../compass-audit-handler.ts";
+import { ambientIo } from "../../../../src/utils/io.ts";
 import type { ForgeCommandInput, ForgeRuntimeContext } from "../../../../src/types.ts";
 
 const execFileAsync = promisify(execFile);
@@ -31,15 +32,15 @@ const logger = {
   },
 };
 
-function makeContext(workspaceRoot: string): ForgeRuntimeContext {
+function makeContext(workspaceRoot: string, dryRun = false): ForgeRuntimeContext {
   return {
     workspaceRoot,
     site: undefined,
     siteExplicit: false,
     logger: logger as never,
-    dryRun: false,
+    dryRun,
     outputFormat: "json",
-    io: {} as never,
+    io: ambientIo,
     actualState: undefined as never,
     fileIntents: [],
   } as unknown as ForgeRuntimeContext;
@@ -131,3 +132,91 @@ describe("compass.audit.validate — RFC-1143 ledger-ineligible skips", () => {
     expect(data.skippedIneligible).toBeGreaterThan(0);
   });
 });
+
+// RFC-1242 AC-5/AC-6: --prune drops ledger entries for paths that no longer
+// exist while preserving every surviving entry's verdict fields.
+const DEAD_PATH = "packages/gone/deleted.ts";
+const LEDGER_ENTRY = (path: string) =>
+  `  - path: ${path}\n    entityId: "eid-${path}"\n    auditedRevision: 7\n    auditedHash: "hash-${path}"\n    auditedAt: "2026-01-01T00:00:00Z"\n    verdict: pass\n    agent: human:test\n`;
+
+describe("compass.audit.validate --prune — RFC-1242", () => {
+  let root: string;
+
+  beforeEach(async () => {
+    root = await mkdtemp(join(tmpdir(), "compass-prune-"));
+    await mkdir(join(root, "packages", "foo"), { recursive: true });
+    await mkdir(join(root, "docs"), { recursive: true });
+    await writeFile(join(root, "packages", "foo", "index.ts"), "export const x = 1;\n", "utf8");
+    await writeFile(
+      join(root, "docs", "compass-audit-ledger.generated.yaml"),
+      `entries:\n${LEDGER_ENTRY(ELIGIBLE_FILE)}${LEDGER_ENTRY(DEAD_PATH)}`,
+      "utf8",
+    );
+    await execFileAsync("git", ["init"], { cwd: root });
+    await execFileAsync("git", ["config", "user.email", "test@test.com"], { cwd: root });
+    await execFileAsync("git", ["config", "user.name", "Test"], { cwd: root });
+    await execFileAsync("git", ["add", "."], { cwd: root });
+    await execFileAsync("git", ["commit", "-m", "init"], { cwd: root });
+  });
+
+  afterEach(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  it("AC-5: ledger contains no entry whose path does not exist after prune", async () => {
+    const result = await runCompassAuditValidate(
+      makeInput({ prune: true, root: ["packages"] }),
+      makeContext(root),
+    );
+    const data = result.data as { pruned: number; prunedPaths: string[] };
+    expect(data.pruned).toBe(1);
+    expect(data.prunedPaths).toEqual([DEAD_PATH]);
+    const { readFile } = await import("node:fs/promises");
+    const ledgerText = await readFile(
+      join(root, "docs", "compass-audit-ledger.generated.yaml"),
+      "utf8",
+    );
+    expect(ledgerText).not.toContain(DEAD_PATH);
+    expect(ledgerText).toContain(ELIGIBLE_FILE);
+  });
+
+  it("AC-6: surviving entries keep their verdict fields unchanged", async () => {
+    await runCompassAuditValidate(
+      makeInput({ prune: true, root: ["packages"] }),
+      makeContext(root),
+    );
+    const { readFile } = await import("node:fs/promises");
+    const { parse } = await import("yaml");
+    const ledger = parse(
+      await readFile(join(root, "docs", "compass-audit-ledger.generated.yaml"), "utf8"),
+    ) as { entries: Array<Record<string, unknown>> };
+    const survivor = ledger.entries.find((e) => e.path === ELIGIBLE_FILE);
+    expect(
+      survivor,
+      "surviving ledger entry must keep its verdict fields — check the keep/drop partition",
+    ).toMatchObject({
+      entityId: `eid-${ELIGIBLE_FILE}`,
+      auditedRevision: 7,
+      auditedHash: `hash-${ELIGIBLE_FILE}`,
+      auditedAt: "2026-01-01T00:00:00Z",
+      verdict: "pass",
+      agent: "human:test",
+    });
+  });
+
+  it("--prune --dry-run reports the drop set without rewriting the ledger", async () => {
+    const { readFile } = await import("node:fs/promises");
+    const ledgerPath = join(root, "docs", "compass-audit-ledger.generated.yaml");
+    const before = await readFile(ledgerPath, "utf8");
+    const result = await runCompassAuditValidate(
+      makeInput({ prune: true, root: ["packages"] }),
+      makeContext(root, true),
+    );
+    const data = result.data as { pruned: number };
+    expect(data.pruned).toBe(1);
+    expect(
+      await readFile(ledgerPath, "utf8"),
+      "dry-run must not rewrite the ledger — writes must route through context.io honoring context.dryRun",
+    ).toBe(before);
+  });
+});

package/os/compass/handlers/tests/compass-docs-validate.test.ts

@@ -0,0 +1,203 @@
+/*
+<MODULE_CONTRACT>
+  <purpose>
+    RFC-1242 AC-1..AC-4: compass.docs.validate scans the docs/*.xml corpus and
+    must fail on unresolvable <path> entries (COMPASS-DOC-01) and dead workspace
+    ids (COMPASS-DOC-02), warn on unresolvable link targets (COMPASS-DOC-03),
+    and flag malformed XML (COMPASS-DOC-00). A green corpus exits 0 with
+    status-shaped data.
+  </purpose>
+</MODULE_CONTRACT>
+*/
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runCompassDocsValidate } from "../compass-docs-validate.ts";
+import { ambientIo } from "../../../../src/utils/io.ts";
+import type { Diagnostic, ForgeCommandInput, ForgeRuntimeContext } from "../../../../src/types.ts";
+
+const logger = {
+  section() {},
+  info() {},
+  warn() {},
+  error() {},
+  success() {},
+  getEvents() {
+    return [];
+  },
+};
+
+function makeContext(workspaceRoot: string): ForgeRuntimeContext {
+  return {
+    workspaceRoot,
+    site: undefined,
+    siteExplicit: false,
+    logger: logger as never,
+    dryRun: false,
+    outputFormat: "json",
+    io: ambientIo,
+    actualState: undefined as never,
+    fileIntents: [],
+  } as unknown as ForgeRuntimeContext;
+}
+
+function makeInput(): ForgeCommandInput {
+  return { argv: [], flags: {} } as unknown as ForgeCommandInput;
+}
+
+const GREEN_DOC = `<root>
+  <path>\`docs/other.xml\`</path>
+  <workspace id="pkg-foo"><path>\`packages/foo\`</path></workspace>
+  <node id="packages.foo" type="package"><path>\`packages/foo\`</path></node>
+  <node id="root.a" type="compass-doc"><link rel="binds-to" target="root.b" /></node>
+  <node id="root.b" type="compass-doc" />
+</root>
+`;
+
+describe("compass.docs.validate — RFC-1242", () => {
+  let root: string;
+
+  beforeEach(async () => {
+    root = await mkdtemp(join(tmpdir(), "compass-docs-"));
+    await mkdir(join(root, "docs"), { recursive: true });
+    await mkdir(join(root, "packages", "foo"), { recursive: true });
+    await writeFile(join(root, "packages", "foo", "index.ts"), "export {};\n", "utf8");
+  });
+
+  afterEach(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  it("AC-2: green corpus exits 0 and reports scanned counts", async () => {
+    await writeFile(join(root, "docs", "a.xml"), GREEN_DOC, "utf8");
+    await writeFile(join(root, "docs", "other.xml"), "<root/>", "utf8");
+    const result = await runCompassDocsValidate(makeInput(), makeContext(root));
+    expect(result.exitCode).toBe(0);
+    const data = result.data as {
+      scanned: { xmlFiles: number; pathsChecked: number; idsChecked: number };
+      diagnostics: Diagnostic[];
+    };
+    expect(data.scanned.xmlFiles).toBe(2);
+    expect(data.diagnostics).toEqual([]);
+  });
+
+  it("AC-3: dead <path> emits COMPASS-DOC-01 error", async () => {
+    await writeFile(
+      join(root, "docs", "a.xml"),
+      `<root><path>\`packages/gone\`</path></root>`,
+      "utf8",
+    );
+    const result = await runCompassDocsValidate(makeInput(), makeContext(root));
+    const diagnostics = (result.data as { diagnostics: Diagnostic[] }).diagnostics;
+    expect(
+      diagnostics.some((d) => d.ruleId === "COMPASS-DOC-01" && d.severity === "error"),
+      "dead <path> must emit COMPASS-DOC-01 — check pathTokens/pathCheckTarget resolution",
+    ).toBe(true);
+  });
+
+  it("AC-4: dead <path> produces a non-zero exit", async () => {
+    await writeFile(
+      join(root, "docs", "a.xml"),
+      `<root><path>\`packages/gone\`</path></root>`,
+      "utf8",
+    );
+    const result = await runCompassDocsValidate(makeInput(), makeContext(root));
+    expect(result.exitCode).toBe(1);
+  });
+
+  it("dead workspace id emits COMPASS-DOC-02 error", async () => {
+    await writeFile(join(root, "docs", "a.xml"), `<root><workspace id="pkg-gone"/></root>`, "utf8");
+    const result = await runCompassDocsValidate(makeInput(), makeContext(root));
+    const diagnostics = (result.data as { diagnostics: Diagnostic[] }).diagnostics;
+    expect(
+      diagnostics.some((d) => d.ruleId === "COMPASS-DOC-02" && d.message.includes("pkg-gone")),
+      "dead workspace id must emit COMPASS-DOC-02 — check workspaceIdTarget mapping",
+    ).toBe(true);
+    expect(result.exitCode).toBe(1);
+  });
+
+  it("glob-tail <path> resolves against the parent directory", async () => {
+    await writeFile(
+      join(root, "docs", "a.xml"),
+      `<root><path>\`packages/*\`</path></root>`,
+      "utf8",
+    );
+    const result = await runCompassDocsValidate(makeInput(), makeContext(root));
+    expect(result.exitCode).toBe(0);
+  });
+
+  it("unresolvable link target emits COMPASS-DOC-03 warning, never an error", async () => {
+    await writeFile(
+      join(root, "docs", "a.xml"),
+      `<root><node id="x"><link rel="binds-to" target="docs.rfcs.rfc-9999" /></node></root>`,
+      "utf8",
+    );
+    const result = await runCompassDocsValidate(makeInput(), makeContext(root));
+    const diagnostics = (result.data as { diagnostics: Diagnostic[] }).diagnostics;
+    expect(
+      diagnostics.some((d) => d.ruleId === "COMPASS-DOC-03" && d.severity === "warning"),
+      "dangling link target must warn via COMPASS-DOC-03",
+    ).toBe(true);
+    expect(result.exitCode).toBe(0);
+  });
+
+  it("link target resolving to an archived RFC file passes", async () => {
+    await mkdir(join(root, "docs", "rfcs", "archive"), { recursive: true });
+    await writeFile(join(root, "docs", "rfcs", "archive", "rfc-0097-old.md"), "x", "utf8");
+    await writeFile(
+      join(root, "docs", "a.xml"),
+      `<root><node id="x"><link rel="binds-to" target="docs.rfcs.rfc-0097" /></node></root>`,
+      "utf8",
+    );
+    const result = await runCompassDocsValidate(makeInput(), makeContext(root));
+    expect(result.exitCode).toBe(0);
+  });
+
+  it("malformed XML emits COMPASS-DOC-00 and skips ref checks for that file", async () => {
+    await writeFile(join(root, "docs", "a.xml"), `<root><name>oops</root>`, "utf8");
+    const result = await runCompassDocsValidate(makeInput(), makeContext(root));
+    const diagnostics = (result.data as { diagnostics: Diagnostic[] }).diagnostics;
+    expect(diagnostics.some((d) => d.ruleId === "COMPASS-DOC-00")).toBe(true);
+    expect(diagnostics.some((d) => d.ruleId === "COMPASS-DOC-01")).toBe(false);
+    expect(result.exitCode).toBe(1);
+  });
+
+  it("quoted attribute value ending in / is not misread as self-closing", async () => {
+    await writeFile(
+      join(root, "docs", "a.xml"),
+      `<root><node id="x" type="compass-doc" path="docs/"><link rel="binds-to" target="x" /></node></root>`,
+      "utf8",
+    );
+    const result = await runCompassDocsValidate(makeInput(), makeContext(root));
+    const diagnostics = (result.data as { diagnostics: Diagnostic[] }).diagnostics;
+    expect(diagnostics.some((d) => d.ruleId === "COMPASS-DOC-00")).toBe(false);
+    expect(result.exitCode).toBe(0);
+  });
+
+  it("docs.plans.plan-rfc-* link target resolves to a plan-*.md basename", async () => {
+    await mkdir(join(root, "docs", "plans"), { recursive: true });
+    await writeFile(join(root, "docs", "plans", "plan-rfc-1242-x.md"), "x", "utf8");
+    await writeFile(
+      join(root, "docs", "a.xml"),
+      `<root><node id="x"><link rel="binds-to" target="docs.plans.plan-rfc-1242-x" /></node></root>`,
+      "utf8",
+    );
+    const result = await runCompassDocsValidate(makeInput(), makeContext(root));
+    const diagnostics = (result.data as { diagnostics: Diagnostic[] }).diagnostics;
+    expect(diagnostics.some((d) => d.ruleId === "COMPASS-DOC-03")).toBe(false);
+  });
+
+  it("AC-1: result data carries command-shaped payload fields", async () => {
+    await writeFile(join(root, "docs", "a.xml"), GREEN_DOC, "utf8");
+    await writeFile(join(root, "docs", "other.xml"), "<root/>", "utf8");
+    const result = await runCompassDocsValidate(makeInput(), makeContext(root));
+    const data = result.data as Record<string, unknown>;
+    expect(data).toHaveProperty("command", "compass.docs.validate");
+    expect(data).toHaveProperty("status", "pass");
+    expect(data).toHaveProperty("scanned");
+    expect(data).toHaveProperty("diagnostics");
+    expect(Array.isArray(data.diagnostics)).toBe(true);
+  });
+});

package/os/compass/handlers/tests/compass-ledger-scope.test.ts

@@ -16,6 +16,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { parse as yamlParse } from "yaml";
 import { runCompassAuditBaseline } from "../compass-audit-handler.ts";
+import { ambientIo } from "../../../../src/utils/io.ts";
 import type { ForgeCommandInput, ForgeRuntimeContext } from "../../../../src/types.ts";
 
 const execFileAsync = promisify(execFile);
@@ -39,7 +40,7 @@ function makeContext(workspaceRoot: string): ForgeRuntimeContext {
     logger: logger as never,
     dryRun: false,
     outputFormat: "json",
-    io: {} as never,
+    io: ambientIo,
     actualState: undefined as never,
     fileIntents: [],
   } as unknown as ForgeRuntimeContext;

package/os/compass/handlers/tests/compass-policy.test.ts

@@ -11,6 +11,7 @@ the named-config-error contract.</purpose>
   <item>RFC-1096: initial coverage for resolveCompassPolicy (AC-1..AC-5).</item>
   <item>RFC-1220: step 1 — widen governance-ID tail regex</item>
   <item>RFC-1220: fo-review — F-1 shared forge-yaml fixture, F-2 temp-dir cleanup</item>
+  <item>RFC-1252: harden export pipeline — CI-parity verify-extract, --from-head publish-forge, EC-20 staged lint gate</item>
 </CHANGE_SUMMARY>
 */
 
@@ -163,8 +164,13 @@ describe("resolveCompassPolicy (RFC-1096)", () => {
     const inventoryFile = join(COMPASS_DIR, "handlers", "compass-inventory.ts");
 
     const offenders: string[] = [];
+    // Compass contract blocks are mechanical governance metadata — a recorded
+    // item text may name a consumer command and still be a name, not a path
+    // literal. The documented exemption above only holds if those blocks are
+    // stripped before the substring scan.
+    const compassBlockRe = /<(MODULE_CONTRACT|KEY_DECISIONS|CHANGE_SUMMARY)>[\s\S]*?<\/\1>/g;
     for (const file of collectTsFiles(COMPASS_DIR)) {
-      const source = readFileSync(file, "utf8");
+      const source = readFileSync(file, "utf8").replace(compassBlockRe, "");
       const banned = file === inventoryFile ? bannedInInventory : bannedPathLiterals;
       for (const literal of banned) {
         if (source.includes(literal)) {

package/os/compass/handlers/tests/summary-record.test.ts

@@ -2,12 +2,14 @@ import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { mkdtemp, mkdir, writeFile, readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { execFileSync } from "node:child_process";
 import {
   runCompassSummaryRecord,
   parseChangeSummary,
   mergeHistoryIds,
   buildChangeSummaryBlock,
   stripConventionalPrefix,
+  stripGitTrailers,
   isValidGovernanceId,
   CHANGE_SUMMARY_WINDOW,
 } from "../summary-record.ts";
@@ -160,6 +162,51 @@ describe("compass.summary.record", () => {
     expect(missing.exitCode).toBe(1);
   });
 
+  it("skips auto-inject when the worktree diff already adds a same-ID item (id-in-diff)", async () => {
+    execFileSync("git", ["init"], { cwd: root });
+    execFileSync("git", ["config", "user.email", "t@t"], { cwd: root });
+    execFileSync("git", ["config", "user.name", "T"], { cwd: root });
+    await writeFile(join(root, "src", "a.ts"), TS_HEADER(["RFC-0001: existing item."]));
+    execFileSync("git", ["add", "-A"], { cwd: root });
+    execFileSync("git", ["commit", "-m", "baseline"], { cwd: root });
+    // The pending change carries a hand-authored descriptive item for the ID.
+    await writeFile(
+      join(root, "src", "a.ts"),
+      TS_HEADER(["RFC-0001: existing item.", "RFC-1095: descriptive hand-written entry"]),
+    );
+
+    const result = await runCompassSummaryRecord(
+      makeInput({ id: "RFC-1095", files: ["src/a.ts"], text: "generic subject line" }),
+      makeContext(root),
+    );
+
+    expect(result.data?.skipped).toEqual([{ file: "src/a.ts", reason: "id-in-diff" }]);
+    expect(result.data?.recorded).toEqual([]);
+    const source = await readFile(join(root, "src", "a.ts"), "utf8");
+    expect(source).not.toContain("generic subject line");
+  });
+
+  it("still records when the same-ID item already exists at HEAD (consecutive-commit stack)", async () => {
+    execFileSync("git", ["init"], { cwd: root });
+    execFileSync("git", ["config", "user.email", "t@t"], { cwd: root });
+    execFileSync("git", ["config", "user.name", "T"], { cwd: root });
+    await writeFile(
+      join(root, "src", "a.ts"),
+      TS_HEADER(["RFC-1095: step 1 — recorded by the previous commit"]),
+    );
+    execFileSync("git", ["add", "-A"], { cwd: root });
+    execFileSync("git", ["commit", "-m", "baseline"], { cwd: root });
+
+    const result = await runCompassSummaryRecord(
+      makeInput({ id: "RFC-1095", files: ["src/a.ts"], text: "step 2" }),
+      makeContext(root),
+    );
+
+    expect(result.data?.recorded).toEqual(["src/a.ts"]);
+    const source = await readFile(join(root, "src", "a.ts"), "utf8");
+    expect(source).toContain("<item>RFC-1095: step 2</item>");
+  });
+
   it("defaults item text to the bare ID when --text is absent", async () => {
     await writeFile(join(root, "src", "a.ts"), TS_HEADER([]));
     await runCompassSummaryRecord(
@@ -191,6 +238,65 @@ describe("compass.summary.record", () => {
     expect(source).toContain("<item>RFC-1095: record command</item>");
     expect(source).not.toContain("RFC-1095: RFC-1095");
   });
+
+  it("strips Generated-with/Co-Authored-By trailer blocks from the recorded item (RFC-1233 AC-1)", async () => {
+    await writeFile(join(root, "src", "a.ts"), TS_HEADER([]));
+    await runCompassSummaryRecord(
+      makeInput({
+        id: "RFC-1233",
+        files: ["src/a.ts"],
+        text: "trailer stripping\n\nGenerated with [Devin](https://devin.ai)\nCo-Authored-By: Devin <bot@users.noreply.github.com>",
+      }),
+      makeContext(root),
+    );
+    const source = await readFile(join(root, "src", "a.ts"), "utf8");
+    expect(source).toContain("<item>RFC-1233: trailer stripping</item>");
+    expect(source).not.toContain("Co-Authored-By");
+    expect(source).not.toContain("Generated with");
+    expect(source).not.toContain("devin.ai");
+  });
+
+  it("neutralizes a literal star-slash in --text so the item cannot terminate the block comment (RFC-1233 AC-2)", async () => {
+    await writeFile(join(root, "src", "a.ts"), TS_HEADER([]));
+    await runCompassSummaryRecord(
+      makeInput({
+        id: "RFC-1233",
+        files: ["src/a.ts"],
+        text: "glob src" + "/**/*.ts in comments",
+      }),
+      makeContext(root),
+    );
+    const source = await readFile(join(root, "src", "a.ts"), "utf8");
+    expect(source).toContain("RFC-1233: glob src");
+    expect(source.match(CS_BLOCK_RE)).not.toBeNull();
+    // The neutralized form keeps both characters readable but cannot close /*.
+    expect(source).toContain("glob src/**" + "∕*.ts in comments");
+  });
+
+  it("keeps a single-line subject identical — negative regression (RFC-1233 AC-3)", async () => {
+    await writeFile(join(root, "src", "a.ts"), TS_HEADER([]));
+    await runCompassSummaryRecord(
+      makeInput({ id: "RFC-1233", files: ["src/a.ts"], text: "plain subject line" }),
+      makeContext(root),
+    );
+    const source = await readFile(join(root, "src", "a.ts"), "utf8");
+    expect(source).toContain("<item>RFC-1233: plain subject line</item>");
+  });
+
+  it("preserves a Key: value-shaped line when it is not in the trailing block (RFC-1233 AC-4)", async () => {
+    await writeFile(join(root, "src", "a.ts"), TS_HEADER([]));
+    await runCompassSummaryRecord(
+      makeInput({
+        id: "RFC-1233",
+        files: ["src/a.ts"],
+        text: "fix the parser\n\nNote: this line is prose about the fix\nfinal summary line",
+      }),
+      makeContext(root),
+    );
+    const source = await readFile(join(root, "src", "a.ts"), "utf8");
+    expect(source).toContain("Note: this line is prose about the fix");
+    expect(source).toContain("final summary line");
+  });
 });
 
 describe("summary-record helpers", () => {
@@ -246,4 +352,25 @@ describe("summary-record helpers", () => {
     expect(block).not.toContain("<history>");
     expect(block).toContain("<item>RFC-1: a</item>");
   });
+
+  it("stripGitTrailers strips a Token:-shaped tail block (RFC-1233)", () => {
+    expect(
+      stripGitTrailers("subject\n\nbody line\nCo-Authored-By: Devin <bot@x>\nX-RFC: RFC-1233"),
+    ).toBe("subject\n\nbody line");
+  });
+
+  it("stripGitTrailers keeps a lone markdown-link tail (no strict trailer line)", () => {
+    const msg = "subject\n\nsee [the docs](https://example.com)";
+    expect(stripGitTrailers(msg)).toBe(msg);
+  });
+
+  it("stripGitTrailers on a trailer-only message returns empty", () => {
+    expect(stripGitTrailers("Co-Authored-By: Devin <bot@x>")).toBe("");
+  });
+
+  it("stripGitTrailers strips empty-value trailers (Token:) — interpret-trailers allows them", () => {
+    expect(stripGitTrailers("subject\n\nReviewed-by:\nSigned-off-by: Devin <bot@x>")).toBe(
+      "subject",
+    );
+  });
 });