Mark the pipeline step that actually failed and retire stale test results (#7852)

# Description of Changes

`PolicyRun.currentStep` is a 1-based cursor (0 before the run starts).
`PipelineBuilder` compared it against the graph's 0-based step index, so
the badges landed one node late.

Test a corrupt PDF through Rotate → Split: the rotate call is the one
that returns 400, but the graph puts a green tick on Rotate and the
error control on Split, and the strip reads "Failed after 1 of 2 steps"
when no step completed.

The same arithmetic is why a node added after a successful test shows as
done before it has ever run: run state is derived positionally and
nothing retires a result when the chain changes.

**Changes**

- `stepRunState` converts the cursor to a 0-based index before
comparing.
- The failed summary reports steps that actually completed, not the
cursor.
- A test result is cleared when the step chain it ran against is edited,
so badges cannot certify a chain that was never executed.

**Before:** step 1 fails → step 1 shows done, step 2 shows failed,
"Failed after 1 of 2 steps".

**After:** step 1 fails → step 1 shows failed, step 2 shows nothing,
"Failed after 0 of 2 steps".

Three cases added to `PipelineBuilder.test.tsx` covering a first-step
failure, a mid-chain run, and editing the chain after a passing test.
All three fail on `main` and pass here.

---

## Checklist

### General

- [x] I have read the [Contribution
Guidelines](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/CONTRIBUTING.md)
- [x] I have read the [Stirling-PDF Developer
Guide](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/DeveloperGuide.md)
(if applicable)
- [x] I have performed a self-review of my own code
- [x] Every comment I added says something the code does not
([guide](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/devGuide/CODE_COMMENTS.md))
- [x] My changes generate no new warnings

### Testing (if applicable)

- [x] `npx vitest run src/portal` passes: 90 files, 583 tests
- [x] `tsc --noEmit` (proprietary variant), `oxlint --max-warnings=0`
and `oxfmt --check` all clean

Co-authored-by: James Brunton <jbrunton96@gmail.com>

Author: Frooodle

frontend/editor/src/portal/views/PipelineBuilder.test.tsx

@@ -34,13 +34,17 @@ const savePipeline = vi.fn();
 const deletePipeline = vi.fn();
 const triggerPipeline = vi.fn();
 const fetchRun = vi.fn();
+const runPipelineTest = vi.fn();
+const fetchRunOutput = vi.fn();
 vi.mock("@portal/api/pipelines", () => ({
   fetchPipeline: (id: string) => fetchPipeline(id),
   fetchTriggers: () => fetchTriggers(),
   savePipeline: (policy: unknown) => savePipeline(policy),
   deletePipeline: (id: string) => deletePipeline(id),
   triggerPipeline: (id: string) => triggerPipeline(id),
   fetchRun: (runId: string) => fetchRun(runId),
+  runPipelineTest: (...args: unknown[]) => runPipelineTest(...args),
+  fetchRunOutput: (...args: unknown[]) => fetchRunOutput(...args),
 }));
 
 const uploadPipelineAsset = vi.fn();
@@ -331,6 +335,8 @@ describe("PipelineBuilder", () => {
     deletePipeline.mockReset();
     triggerPipeline.mockReset();
     fetchRun.mockReset();
+    runPipelineTest.mockReset();
+    runPipelineTest.mockResolvedValue({ runId: "run-test-1" });
     fetchSources.mockReset();
     fetchPipeline.mockResolvedValue(POLICY);
     fetchTriggers.mockResolvedValue([]);
@@ -889,6 +895,76 @@ describe("PipelineBuilder", () => {
     ).toBeInTheDocument();
   });
 
+  function twoStepPolicy(): Policy {
+    return {
+      ...POLICY,
+      steps: [
+        { operation: "/api/v1/misc/compress-pdf", parameters: {} },
+        { operation: "/api/v1/misc/extract-images", parameters: {} },
+      ] as unknown as Policy["steps"],
+    };
+  }
+
+  async function runTestWith(view: Record<string, unknown>) {
+    fetchRun.mockResolvedValue({
+      runId: "run-test-1",
+      stepCount: 2,
+      outputs: [],
+      error: null,
+      ...view,
+    });
+    renderBuilder("/processor/pipelines/plc-1");
+    await screen.findByText("portal.pipelines.builder.testRun");
+    const picker = document.querySelector<HTMLInputElement>(
+      'input[type="file"][accept="application/pdf"]',
+    );
+    if (!picker) throw new Error("test-run file input not rendered");
+    fireEvent.change(picker, {
+      target: {
+        files: [new File(["x"], "in.pdf", { type: "application/pdf" })],
+      },
+    });
+    await waitFor(() => expect(runPipelineTest).toHaveBeenCalledTimes(1));
+  }
+
+  it("blames the step that actually failed, not the one after it", async () => {
+    fetchPipeline.mockResolvedValue(twoStepPolicy());
+
+    await runTestWith({ status: "FAILED", currentStep: 1, error: "boom" });
+
+    await screen.findByLabelText("portal.pipelines.graph.showError");
+    expect(screen.queryByText("portal.pipelines.graph.run.done")).toBeNull();
+  });
+
+  it("marks only the steps that finished before the one still running", async () => {
+    fetchPipeline.mockResolvedValue(twoStepPolicy());
+
+    await runTestWith({ status: "RUNNING", currentStep: 2 });
+
+    await waitFor(() =>
+      expect(
+        screen.getAllByText("portal.pipelines.graph.run.done"),
+      ).toHaveLength(1),
+    );
+  });
+
+  it("retires a test result once the chain it ran against changes", async () => {
+    fetchPipeline.mockResolvedValue(twoStepPolicy());
+
+    await runTestWith({ status: "COMPLETED", currentStep: 2 });
+    await waitFor(() =>
+      expect(
+        screen.getAllByText("portal.pipelines.graph.run.done"),
+      ).toHaveLength(2),
+    );
+
+    await addTool("OCR");
+
+    await waitFor(() =>
+      expect(screen.queryByText("portal.pipelines.graph.run.done")).toBeNull(),
+    );
+  });
+
   it("uploads a step's supporting file and saves it as an asset binding", async () => {
     renderBuilder("/processor/pipelines/new");
 

frontend/editor/src/portal/views/PipelineBuilder.tsx

@@ -725,6 +725,18 @@ export function PipelineBuilder() {
   }, [seeded, snapshot]);
   const dirty = baseline.current !== null && baseline.current !== snapshot;
 
+  const stepsSignature = JSON.stringify(stepSnapshot);
+  const testedStepsSignature = useRef<string | null>(null);
+  useEffect(() => {
+    if (
+      testedStepsSignature.current !== null &&
+      testedStepsSignature.current !== stepsSignature
+    ) {
+      testedStepsSignature.current = null;
+      setTestRun(null);
+    }
+  }, [stepsSignature]);
+
   // Each validity condition is defined exactly once here, then consumed both by the graph (which
   // flags each end) and by the blocker list below.
   const sourceChosen = input.sourceId !== "";
@@ -956,6 +968,7 @@ export function PipelineBuilder() {
     if (testing) return;
     setTesting(true);
     setTestRun(null);
+    testedStepsSignature.current = stepsSignature;
     setRunResult(null);
     try {
       const { steps: testSteps, assets } = buildTestSteps();
@@ -1167,8 +1180,9 @@ export function PipelineBuilder() {
   // the cursor itself is whatever the run currently is.
   function stepRunState(index: number): GraphStepContent["runState"] {
     if (!testRun) return undefined;
-    if (index < testRun.currentStep) return "done";
-    if (index > testRun.currentStep) return undefined;
+    const activeIndex = testRun.currentStep - 1;
+    if (index < activeIndex) return "done";
+    if (index > activeIndex) return undefined;
     if (testRun.status === "FAILED") return "failed";
     if (testRun.status === "COMPLETED") return "done";
     return "running";
@@ -1205,7 +1219,10 @@ export function PipelineBuilder() {
               : testRun.status === "COMPLETED"
                 ? ("completed" as const)
                 : ("running" as const),
-          completedSteps: testRun.currentStep,
+          completedSteps:
+            testRun.status === "FAILED"
+              ? Math.max(0, testRun.currentStep - 1)
+              : testRun.currentStep,
           stepCount: testRun.stepCount,
           error: testRun.error,
           outputs: testRun.outputs ?? [],