@mhingston5/lasso 0.1.0

package/test/reference/PatchValidation.failures.test.ts

@@ -0,0 +1,137 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { buildPatchValidationHarnessSpec } from "../../src/reference/patch-validation.js";
+import { compileHarnessSpec } from "../../src/compiler/compile.js";
+import { createPatchValidationFixture } from "../helpers/createPatchValidationFixture.js";
+import { runCompiledWorkflow } from "../helpers/runCompiledWorkflow.js";
+import type { ToolNode } from "../../src/spec/types.js";
+
+describe("buildPatchValidationHarnessSpec failures", () => {
+  const cleanups: Array<() => void> = [];
+
+  afterEach(() => {
+    while (cleanups.length > 0) {
+      cleanups.pop()?.();
+    }
+  });
+
+  it("routes to not-reproduced when the baseline reproduce command passes on baseline", async () => {
+    const fixture = createPatchValidationFixture({ baselineAlwaysPasses: true });
+    cleanups.push(fixture.cleanup);
+
+    const compiled = compileHarnessSpec(buildPatchValidationHarnessSpec(fixture.bundle));
+    const result = await runCompiledWorkflow(compiled, fixture.bundle, {});
+
+    expect(result.status).toBe("completed");
+    expect(result.terminalNodeId).toBe("not-reproduced");
+
+    const baselineOutput = result.outputs["run-baseline"] as { reproduced: boolean };
+    expect(baselineOutput.reproduced).toBe(false);
+  });
+
+  it("routes to apply-failed when the branch candidate does not exist", async () => {
+    const fixture = createPatchValidationFixture({ applyFailure: true, candidateKind: "branch" });
+    cleanups.push(fixture.cleanup);
+
+    const compiled = compileHarnessSpec(buildPatchValidationHarnessSpec(fixture.bundle));
+    const result = await runCompiledWorkflow(compiled, fixture.bundle, {});
+
+    expect(result.status).toBe("completed");
+    expect(result.terminalNodeId).toBe("apply-failed");
+
+    const applyOutput = result.outputs["apply-candidate"] as { applied: boolean; reason?: string };
+    expect(applyOutput.applied).toBe(false);
+    expect(applyOutput.reason).toMatch(/branch checkout failed/);
+  });
+
+  it("routes to apply-failed when the patch-file candidate is malformed", async () => {
+    const fixture = createPatchValidationFixture({ applyFailure: true, candidateKind: "patchFile" });
+    cleanups.push(fixture.cleanup);
+
+    const compiled = compileHarnessSpec(buildPatchValidationHarnessSpec(fixture.bundle));
+    const result = await runCompiledWorkflow(compiled, fixture.bundle, {});
+
+    expect(result.status).toBe("completed");
+    expect(result.terminalNodeId).toBe("apply-failed");
+
+    const applyOutput = result.outputs["apply-candidate"] as { applied: boolean; reason?: string };
+    expect(applyOutput.applied).toBe(false);
+    expect(applyOutput.reason).toMatch(/patch apply failed/);
+  });
+
+  it("routes to candidate-failed when the bug still reproduces after candidate is applied", async () => {
+    const fixture = createPatchValidationFixture({ fixDoesNotFixBug: true });
+    cleanups.push(fixture.cleanup);
+
+    const compiled = compileHarnessSpec(buildPatchValidationHarnessSpec(fixture.bundle));
+    const result = await runCompiledWorkflow(compiled, fixture.bundle, {});
+
+    expect(result.status).toBe("completed");
+    expect(result.terminalNodeId).toBe("candidate-failed");
+
+    const candidateOutput = result.outputs["run-candidate-reproduce"] as { reproduced: boolean };
+    expect(candidateOutput.reproduced).toBe(true);
+  });
+
+  it("routes to candidate-failed when the candidate passes reproduction but fails broader verification", async () => {
+    const fixture = createPatchValidationFixture({ verificationFailure: true });
+    cleanups.push(fixture.cleanup);
+
+    const compiled = compileHarnessSpec(buildPatchValidationHarnessSpec(fixture.bundle));
+    const result = await runCompiledWorkflow(compiled, fixture.bundle, {});
+
+    expect(result.status).toBe("completed");
+    expect(result.terminalNodeId).toBe("candidate-failed");
+
+    const candidateOutput = result.outputs["run-candidate-reproduce"] as { reproduced: boolean };
+    expect(candidateOutput.reproduced).toBe(false);
+
+    const verificationOutput = result.outputs["run-verification"] as { passed: boolean };
+    expect(verificationOutput.passed).toBe(false);
+  });
+
+  it("routes to rejected when the human reviewer rejects the candidate", async () => {
+    const fixture = createPatchValidationFixture({ approvalRequired: true });
+    cleanups.push(fixture.cleanup);
+
+    const compiled = compileHarnessSpec(buildPatchValidationHarnessSpec(fixture.bundle));
+    const result = await runCompiledWorkflow(compiled, fixture.bundle, {
+      llmResult: { summary: "Candidate looks good but requires human sign-off." },
+      humanResponse: { approved: false },
+    });
+
+    expect(result.status).toBe("completed");
+    expect(result.terminalNodeId).toBe("rejected");
+  });
+
+  it("exhausts retries and throws when run-verification emits a transient error", async () => {
+    const fixture = createPatchValidationFixture();
+    cleanups.push(fixture.cleanup);
+
+    const spec = buildPatchValidationHarnessSpec(fixture.bundle);
+
+    // Patch run-verification to throw a transient error instead of returning JSON.
+    const verifyIdx = spec.graph.nodes.findIndex(n => n.id === "run-verification");
+    const originalNode = spec.graph.nodes[verifyIdx] as ToolNode;
+    spec.graph.nodes[verifyIdx] = {
+      ...originalNode,
+      args: ["-lc", `echo 'transient-verify-fail' >&2 && exit 1`],
+      retryPolicy: {
+        maxAttempts: 2,
+        backoff: "constant",
+        initialDelay: 0,
+        retryOn: ["transient"],
+      },
+      executionPolicy: {
+        failureClassification: [
+          { pattern: "transient-verify-fail", category: "transient", retry: true },
+        ],
+      },
+    } as ToolNode;
+
+    const compiled = compileHarnessSpec(spec);
+
+    await expect(
+      runCompiledWorkflow(compiled, fixture.bundle, {}),
+    ).rejects.toThrow(/transient-verify-fail/i);
+  });
+});

package/test/reference/PatchValidation.test.ts

@@ -0,0 +1,326 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { buildPatchValidationHarnessSpec } from "../../src/reference/patch-validation.js";
+import { compileHarnessSpec } from "../../src/compiler/compile.js";
+import { validateHarnessSpec } from "../../src/spec/validate.js";
+import { createPatchValidationFixture } from "../helpers/createPatchValidationFixture.js";
+import { runCompiledWorkflow } from "../helpers/runCompiledWorkflow.js";
+import type { LocalPatchValidationBundle } from "../../src/reference/types.js";
+
+const ALWAYS_PRESENT_TERMINAL_IDS = ["validated-fix", "not-reproduced", "apply-failed", "candidate-failed"];
+const APPROVAL_ONLY_TERMINAL_IDS = ["rejected"];
+
+describe("buildPatchValidationHarnessSpec", () => {
+  it("builds a valid serial spec for a branch candidate source", () => {
+    const bundle: LocalPatchValidationBundle = {
+      repoPath: "/tmp/repo",
+      baselineRef: "HEAD",
+      candidateSource: { kind: "branch", value: "fix/bug-123" },
+      reproduceCommands: ["npm test -- failing.spec.ts"],
+      verificationCommands: ["npm test", "npm run build"],
+      reviewInstructions: "Approve only if baseline fails and candidate passes.",
+      approvalRequired: true,
+    };
+
+    const spec = buildPatchValidationHarnessSpec(bundle);
+
+    expect(spec.name).toBe("patch-validation");
+    expect(spec.graph.entryNodeId).toBeDefined();
+
+    const nodeKinds = spec.graph.nodes.map(n => n.kind);
+    expect(nodeKinds).not.toContain("merge");
+
+    const nodeIds = spec.graph.nodes.map(n => n.id);
+    for (const terminal of ALWAYS_PRESENT_TERMINAL_IDS) {
+      expect(nodeIds).toContain(terminal);
+    }
+    for (const terminal of APPROVAL_ONLY_TERMINAL_IDS) {
+      expect(nodeIds).toContain(terminal);
+    }
+
+    const allTerminalIds = [...ALWAYS_PRESENT_TERMINAL_IDS, ...APPROVAL_ONLY_TERMINAL_IDS];
+    const terminalNodes = spec.graph.nodes.filter(n => allTerminalIds.includes(n.id));
+    for (const node of terminalNodes) {
+      expect(node.kind).toBe("subworkflow");
+    }
+  });
+
+  it("builds a valid serial spec for a patch-file candidate source", () => {
+    const bundle: LocalPatchValidationBundle = {
+      repoPath: "/tmp/repo",
+      baselineRef: "HEAD",
+      candidateSource: { kind: "patchFile", value: "/patches/fix.patch" },
+      reproduceCommands: ["cargo test buggy_test"],
+      verificationCommands: ["cargo test", "cargo clippy"],
+      reviewInstructions: "Validate the patch fixes the regression.",
+      approvalRequired: false,
+    };
+
+    const spec = buildPatchValidationHarnessSpec(bundle);
+
+    expect(spec.name).toBe("patch-validation");
+
+    const nodeKinds = spec.graph.nodes.map(n => n.kind);
+    expect(nodeKinds).not.toContain("merge");
+
+    const nodeIds = spec.graph.nodes.map(n => n.id);
+    for (const terminal of ALWAYS_PRESENT_TERMINAL_IDS) {
+      expect(nodeIds).toContain(terminal);
+    }
+    for (const terminal of APPROVAL_ONLY_TERMINAL_IDS) {
+      expect(nodeIds).not.toContain(terminal);
+    }
+  });
+
+  it("includes a human gate node when approvalRequired is true", () => {
+    const bundle: LocalPatchValidationBundle = {
+      repoPath: "/tmp/repo",
+      baselineRef: "HEAD",
+      candidateSource: { kind: "branch", value: "fix/bug-123" },
+      reproduceCommands: ["npm test"],
+      verificationCommands: ["npm test"],
+      reviewInstructions: "Review required.",
+      approvalRequired: true,
+    };
+
+    const spec = buildPatchValidationHarnessSpec(bundle);
+    const humanNodes = spec.graph.nodes.filter(n => n.kind === "human");
+    expect(humanNodes.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it("omits the human gate node when approvalRequired is false", () => {
+    const bundle: LocalPatchValidationBundle = {
+      repoPath: "/tmp/repo",
+      baselineRef: "HEAD",
+      candidateSource: { kind: "patchFile", value: "/patches/fix.patch" },
+      reproduceCommands: ["npm test"],
+      verificationCommands: ["npm test"],
+      reviewInstructions: "No human review.",
+      approvalRequired: false,
+    };
+
+    const spec = buildPatchValidationHarnessSpec(bundle);
+    const humanNodes = spec.graph.nodes.filter(n => n.kind === "human");
+    expect(humanNodes).toHaveLength(0);
+  });
+
+  it("has a linear edge chain with no merge node (serial ordering)", () => {
+    const bundle: LocalPatchValidationBundle = {
+      repoPath: "/tmp/repo",
+      baselineRef: "HEAD",
+      candidateSource: { kind: "branch", value: "fix/bug-123" },
+      reproduceCommands: ["npm test"],
+      verificationCommands: ["npm test"],
+      reviewInstructions: "Approve.",
+      approvalRequired: false,
+    };
+
+    const spec = buildPatchValidationHarnessSpec(bundle);
+
+    // No merge nodes — the workflow must be serial
+    const mergeNodes = spec.graph.nodes.filter(n => n.kind === "merge");
+    expect(mergeNodes).toHaveLength(0);
+
+    // No fan-in: no node should appear as an edge target more than once
+    const edgeTargets = spec.graph.edges.map(e => e.to);
+    const targetCounts = new Map<string, number>();
+    for (const t of edgeTargets) {
+      targetCounts.set(t, (targetCounts.get(t) ?? 0) + 1);
+    }
+    for (const [nodeId, count] of targetCounts) {
+      expect(count, `node ${nodeId} has ${count} incoming edges (fan-in detected)`).toBe(1);
+    }
+  });
+
+  it("produces a spec that passes schema validation when approvalRequired is true", () => {
+    const bundle: LocalPatchValidationBundle = {
+      repoPath: "/tmp/repo",
+      baselineRef: "HEAD",
+      candidateSource: { kind: "branch", value: "fix/bug-123" },
+      reproduceCommands: ["npm test"],
+      verificationCommands: ["npm test"],
+      reviewInstructions: "Approve.",
+      approvalRequired: true,
+    };
+
+    const result = validateHarnessSpec(buildPatchValidationHarnessSpec(bundle));
+    expect(result.valid, (result as any).errors?.join(", ")).toBe(true);
+  });
+
+  it("produces a spec that passes schema validation when approvalRequired is false", () => {
+    const bundle: LocalPatchValidationBundle = {
+      repoPath: "/tmp/repo",
+      baselineRef: "HEAD",
+      candidateSource: { kind: "patchFile", value: "/patches/fix.patch" },
+      reproduceCommands: ["npm test"],
+      verificationCommands: ["npm test"],
+      reviewInstructions: "No approval.",
+      approvalRequired: false,
+    };
+
+    const result = validateHarnessSpec(buildPatchValidationHarnessSpec(bundle));
+    expect(result.valid, (result as any).errors?.join(", ")).toBe(true);
+  });
+
+  it("baseline reproduce tool guards the checkout so a bad ref fails fast", () => {
+    const bundle: LocalPatchValidationBundle = {
+      repoPath: "/tmp/repo",
+      baselineRef: "HEAD",
+      candidateSource: { kind: "branch", value: "fix/bug-123" },
+      reproduceCommands: ["npm test"],
+      verificationCommands: ["npm test"],
+      reviewInstructions: "Approve.",
+      approvalRequired: false,
+    };
+
+    const spec = buildPatchValidationHarnessSpec(bundle);
+    const baselineNode = spec.graph.nodes.find(n => n.id === "run-baseline");
+    expect(baselineNode).toBeDefined();
+    expect(baselineNode!.kind).toBe("tool");
+    const script = (baselineNode as any).args[1] as string;
+    expect(script).toMatch(/git checkout.*\|\|\s*exit 1/);
+  });
+
+  it("apply candidate tool emits JSON failure payload when baseline checkout fails", () => {
+    const bundle: LocalPatchValidationBundle = {
+      repoPath: "/tmp/repo",
+      baselineRef: "HEAD",
+      candidateSource: { kind: "patchFile", value: "/patches/fix.patch" },
+      reproduceCommands: ["npm test"],
+      verificationCommands: ["npm test"],
+      reviewInstructions: "No approval.",
+      approvalRequired: false,
+    };
+
+    const spec = buildPatchValidationHarnessSpec(bundle);
+    const applyNode = spec.graph.nodes.find(n => n.id === "apply-candidate");
+    expect(applyNode).toBeDefined();
+    expect(applyNode!.kind).toBe("tool");
+    const script = (applyNode as any).args[1] as string;
+    expect(script).toMatch(/baseline checkout failed/);
+    expect(script).toMatch(/"applied":false/);
+  });
+
+  it("summarise node prompt requests only a summary, not an approved field", () => {
+    const bundle: LocalPatchValidationBundle = {
+      repoPath: "/tmp/repo",
+      baselineRef: "HEAD",
+      candidateSource: { kind: "branch", value: "fix/bug-123" },
+      reproduceCommands: ["npm test"],
+      verificationCommands: ["npm test"],
+      reviewInstructions: "Review carefully.",
+      approvalRequired: true,
+    };
+
+    const spec = buildPatchValidationHarnessSpec(bundle);
+    const summariseNode = spec.graph.nodes.find(n => n.id === "summarise");
+    expect(summariseNode).toBeDefined();
+    expect(summariseNode!.kind).toBe("llm");
+    const prompt = (summariseNode as any).prompt as string;
+    expect(prompt).toMatch(/summary/i);
+    expect(prompt).not.toMatch(/\bapproved\b/);
+  });
+
+  it("throws when reproduceCommands is empty", () => {
+    const bundle: LocalPatchValidationBundle = {
+      repoPath: "/tmp/repo",
+      baselineRef: "HEAD",
+      candidateSource: { kind: "branch", value: "fix/bug-123" },
+      reproduceCommands: [],
+      verificationCommands: ["npm test"],
+      reviewInstructions: "Approve.",
+      approvalRequired: false,
+    };
+
+    expect(() => buildPatchValidationHarnessSpec(bundle)).toThrow(
+      "Patch validation requires at least one reproduce command",
+    );
+  });
+
+  it("human approval prompt explicitly references the prior summarise step output", () => {
+    const bundle: LocalPatchValidationBundle = {
+      repoPath: "/tmp/repo",
+      baselineRef: "HEAD",
+      candidateSource: { kind: "branch", value: "fix/bug-123" },
+      reproduceCommands: ["npm test"],
+      verificationCommands: ["npm test"],
+      reviewInstructions: "Approve only if regression-free.",
+      approvalRequired: true,
+    };
+
+    const spec = buildPatchValidationHarnessSpec(bundle);
+    const humanNode = spec.graph.nodes.find(n => n.id === "human-approve");
+    expect(humanNode).toBeDefined();
+    expect(humanNode!.kind).toBe("human");
+    const prompt = (humanNode as any).prompt as string;
+    expect(prompt).toMatch(/summarise/);
+    expect(prompt).toMatch(/summarise\.summary/);
+  });
+
+  it("throws when verificationCommands is empty", () => {
+    const bundle: LocalPatchValidationBundle = {
+      repoPath: "/tmp/repo",
+      baselineRef: "HEAD",
+      candidateSource: { kind: "branch", value: "fix/bug-123" },
+      reproduceCommands: ["npm test"],
+      verificationCommands: [],
+      reviewInstructions: "Approve.",
+      approvalRequired: false,
+    };
+
+    expect(() => buildPatchValidationHarnessSpec(bundle)).toThrow(
+      "Patch validation requires at least one verification command",
+    );
+  });
+});
+
+describe("buildPatchValidationHarnessSpec compiled workflow", () => {
+  const cleanups: Array<() => void> = [];
+
+  afterEach(() => {
+    while (cleanups.length > 0) {
+      cleanups.pop()?.();
+    }
+  });
+
+  it("runs to validated-fix when a branch candidate fixes the bug", async () => {
+    const fixture = createPatchValidationFixture();
+    cleanups.push(fixture.cleanup);
+
+    const spec = buildPatchValidationHarnessSpec(fixture.bundle);
+    const compiled = compileHarnessSpec(spec);
+    const result = await runCompiledWorkflow(compiled, fixture.bundle, {});
+
+    expect(result.status).toBe("completed");
+    expect(result.terminalNodeId).toBe("validated-fix");
+
+    const baselineOutput = result.outputs["run-baseline"] as { reproduced: boolean };
+    expect(baselineOutput.reproduced).toBe(true);
+
+    const candidateOutput = result.outputs["run-candidate-reproduce"] as { reproduced: boolean };
+    expect(candidateOutput.reproduced).toBe(false);
+
+    const verificationOutput = result.outputs["run-verification"] as { passed: boolean };
+    expect(verificationOutput.passed).toBe(true);
+  });
+
+  it("runs to validated-fix when a patch-file candidate fixes the bug", async () => {
+    const fixture = createPatchValidationFixture({ candidateKind: "patchFile" });
+    cleanups.push(fixture.cleanup);
+
+    const spec = buildPatchValidationHarnessSpec(fixture.bundle);
+    const compiled = compileHarnessSpec(spec);
+    const result = await runCompiledWorkflow(compiled, fixture.bundle, {});
+
+    expect(result.status).toBe("completed");
+    expect(result.terminalNodeId).toBe("validated-fix");
+
+    const baselineOutput = result.outputs["run-baseline"] as { reproduced: boolean };
+    expect(baselineOutput.reproduced).toBe(true);
+
+    const candidateOutput = result.outputs["run-candidate-reproduce"] as { reproduced: boolean };
+    expect(candidateOutput.reproduced).toBe(false);
+
+    const verificationOutput = result.outputs["run-verification"] as { passed: boolean };
+    expect(verificationOutput.passed).toBe(true);
+  });
+});

package/test/reference/PrReviewMerge.failures.test.ts

@@ -0,0 +1,121 @@
+import { execFileSync } from "node:child_process";
+import { afterEach, describe, expect, it } from "vitest";
+import { buildPrReviewMergeHarnessSpec } from "../../src/reference/pr-review-merge.js";
+import { compileHarnessSpec } from "../../src/compiler/compile.js";
+import { createFixtureRepo } from "../helpers/createFixtureRepo.js";
+import { runCompiledWorkflow } from "../helpers/runCompiledWorkflow.js";
+
+describe("buildPrReviewMergeHarnessSpec failures", () => {
+  const cleanups: Array<() => void> = [];
+
+  afterEach(() => {
+    while (cleanups.length > 0) {
+      cleanups.pop()?.();
+    }
+  });
+
+  it("routes verification failures to the rejection terminal", async () => {
+    const fixture = createFixtureRepo({
+      verificationCommands: ['node -e "process.exit(1)"'],
+    });
+    cleanups.push(fixture.cleanup);
+
+    const compiled = compileHarnessSpec(buildPrReviewMergeHarnessSpec(fixture.bundle));
+    const result = await runCompiledWorkflow(compiled, fixture.bundle, {
+      llmResult: {
+        approved: true,
+      },
+      humanResponse: {
+        approved: true,
+      },
+    });
+
+    expect(result.status).toBe("completed");
+    expect(result.terminalNodeId).toBe("reject-verification");
+  });
+
+  it("routes merge conflicts to the conflict terminal", async () => {
+    const fixture = createFixtureRepo({
+      createMergeConflict: true,
+    });
+    cleanups.push(fixture.cleanup);
+
+    const compiled = compileHarnessSpec(buildPrReviewMergeHarnessSpec(fixture.bundle));
+    const result = await runCompiledWorkflow(compiled, fixture.bundle, {
+      llmResult: {
+        approved: true,
+      },
+      humanResponse: {
+        approved: true,
+      },
+    });
+
+    expect(result.status).toBe("completed");
+    expect(result.terminalNodeId).toBe("merge-conflict");
+
+    const currentBranch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: fixture.bundle.repoPath,
+      encoding: "utf8",
+    }).trim();
+    expect(currentBranch).toBe(fixture.bundle.targetBranch);
+  });
+
+  it("routes both-added merge conflicts to the conflict terminal", async () => {
+    const fixture = createFixtureRepo({
+      createMergeConflict: true,
+      mergeConflictMode: "both_added",
+    });
+    cleanups.push(fixture.cleanup);
+
+    const compiled = compileHarnessSpec(buildPrReviewMergeHarnessSpec(fixture.bundle));
+    const result = await runCompiledWorkflow(compiled, fixture.bundle, {
+      llmResult: {
+        approved: true,
+      },
+      humanResponse: {
+        approved: true,
+      },
+    });
+
+    expect(result.status).toBe("completed");
+    expect(result.terminalNodeId).toBe("merge-conflict");
+  });
+
+  it("surfaces retry exhaustion when post-merge verification keeps failing", async () => {
+    const fixture = createFixtureRepo({
+      createPostMergeFailureMarker: true,
+    });
+    cleanups.push(fixture.cleanup);
+
+    const compiled = compileHarnessSpec(buildPrReviewMergeHarnessSpec(fixture.bundle));
+
+    await expect(
+      runCompiledWorkflow(compiled, fixture.bundle, {
+        llmResult: {
+          approved: true,
+        },
+        humanResponse: {
+          approved: true,
+        },
+      }),
+    ).rejects.toThrow(/retryable post-merge failure|Verification retry exhausted|post-merge/i);
+  });
+
+  it("routes human rejection to the rejection terminal", async () => {
+    const fixture = createFixtureRepo();
+    cleanups.push(fixture.cleanup);
+
+    const compiled = compileHarnessSpec(buildPrReviewMergeHarnessSpec(fixture.bundle));
+    const result = await runCompiledWorkflow(compiled, fixture.bundle, {
+      llmResult: {
+        approved: true,
+      },
+      humanResponse: {
+        approved: false,
+      },
+    });
+
+    expect(result.status).toBe("completed");
+    expect(result.terminalNodeId).toBe("reject-human");
+  });
+});

package/test/reference/PrReviewMerge.test.ts

@@ -0,0 +1,55 @@
+import { execFileSync } from "node:child_process";
+import { afterEach, describe, expect, it } from "vitest";
+import { buildPrReviewMergeHarnessSpec } from "../../src/reference/pr-review-merge.js";
+import { compileHarnessSpec } from "../../src/compiler/compile.js";
+import { createFixtureRepo } from "../helpers/createFixtureRepo.js";
+import { runCompiledWorkflow } from "../helpers/runCompiledWorkflow.js";
+
+describe("buildPrReviewMergeHarnessSpec", () => {
+  const cleanups: Array<() => void> = [];
+
+  afterEach(() => {
+    while (cleanups.length > 0) {
+      cleanups.pop()?.();
+    }
+  });
+
+  it("builds and runs the happy-path simulated PR review + merge workflow", async () => {
+    const fixture = createFixtureRepo();
+    cleanups.push(fixture.cleanup);
+
+    const spec = buildPrReviewMergeHarnessSpec(fixture.bundle);
+    const compiled = compileHarnessSpec(spec);
+    const result = await runCompiledWorkflow(compiled, fixture.bundle, {
+      llmResult: {
+        approved: true,
+        summary: "Looks good to merge.",
+      },
+      humanResponse: {
+        approved: true,
+      },
+    });
+
+    expect(spec.graph.nodes.map(node => node.kind)).toEqual(
+      expect.arrayContaining(["tool", "llm", "human", "condition", "merge", "subworkflow"]),
+    );
+    expect(result.status).toBe("completed");
+    expect(result.terminalNodeId).toBe("complete-success");
+    expect(result.result).toEqual({
+      name: "complete-success",
+      input: {},
+    });
+
+    const currentBranch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: fixture.bundle.repoPath,
+      encoding: "utf8",
+    }).trim();
+    expect(currentBranch).toBe(fixture.bundle.targetBranch);
+
+    const mergedFile = execFileSync("git", ["show", `${fixture.bundle.targetBranch}:app.txt`], {
+      cwd: fixture.bundle.repoPath,
+      encoding: "utf8",
+    });
+    expect(mergedFile).toContain("feature change");
+  });
+});