#6 Fix replayed runs showing the unresolved default workflow (read the LAST stage event)

Opening a stored run drew the full, unresolved workflow with every condition visible
(like edit mode), not the resolved lit path the run actually took. Root cause: a live
run upserts each stage node in place (one event), but the STORED trace keeps BOTH the
"running" event (empty data) and the "done" event (which carries the workflow + steps +
verdict) under the same stepId. `readRunGraph`/`readMatchContext` used Array.find, which
returned the FIRST (running, empty) approval/matching event → no workflow, no verdict →
the graph fell back to the generic default and never resolved.

Read the LAST matching event instead (a small findLastEvent helper; Array.findLast needs
a newer lib target). Applied to the approval, matching, and investigation reads. Now a
replayed run resolves the same path + statuses a live run shows.

Verified against the real stored trace on prod: the done approval event (seq 8) carries
the workflow; find grabbed the empty seq-3 one, findLast grabs seq 8.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: DylanMerigaud

components/dashboard.tsx

@@ -62,6 +62,21 @@ import { usePipelineRun } from "@/lib/use-pipeline-run";
  * an append-only audit row (the Recent runs panel below the queue lists them,
  * replayable). A nightly reset clears those, so every morning starts pristine.
  */
+/** The LAST trace event matching a predicate. A live run upserts a stage in place (one
+    event), but a stored/replayed trace keeps the running (often empty) AND the done
+    (data-carrying) event for a stage, in order, so we must read the last, not the first.
+    (Local helper rather than Array.findLast, which needs a newer lib target.) */
+const findLastEvent = (
+  trace: TraceEvent[],
+  pred: (e: TraceEvent) => boolean,
+): TraceEvent | undefined => {
+  for (let i = trace.length - 1; i >= 0; i--) {
+    const e = trace[i];
+    if (e && pred(e)) return e;
+  }
+  return undefined;
+};
+
 /**
  * Pull the intake (extraction) node out of the trace and shape it for the reveal.
  * The intake step carries `{ document }` while reading and `{ extracted, matches }`
@@ -101,7 +116,13 @@ const readIntake = (
 const readRunGraph = (
   trace: TraceEvent[],
 ): { workflow: TApprovalWorkflow; statuses: StepStatuses } | null => {
-  const approval = trace.find(
+  // findLast, not find: a live run upserts the approval node in place (one event), but
+  // a STORED/replayed trace keeps both the "running" event (empty data) AND the "done"
+  // event (which carries the workflow + steps) under the same stepId. `find` grabbed the
+  // running one → no workflow → the graph fell back to the full unresolved default. Take
+  // the LAST approval event so replay resolves the same lit path a live run shows.
+  const approval = findLastEvent(
+    trace,
     (e) => e.stage === "approval" && e.kind === "step",
   );
   if (!approval || !isRecord(approval.data)) return null;
@@ -149,7 +170,10 @@ const isBlockedRun = (
   approvalData: Record<string, unknown>,
 ): boolean => {
   if (approvalData["outcome"] === "blocked") return true;
-  const matching = trace.find(
+  // findLast: the stored trace keeps the running (empty) + done matching events; the
+  // verdict is on the done one.
+  const matching = findLastEvent(
+    trace,
     (e) => e.stage === "matching" && e.kind === "step",
   );
   return isRecord(matching?.data) && matching.data["verdict"] === "duplicate";
@@ -164,7 +188,10 @@ type Recommendation = {
   rationale: string | null;
 };
 const readRecommendation = (trace: TraceEvent[]): Recommendation | null => {
-  const inv = trace.find((e) => e.stage === "investigation" && e.data != null);
+  const inv = findLastEvent(
+    trace,
+    (e) => e.stage === "investigation" && e.data != null,
+  );
   if (!inv || !isRecord(inv.data)) return null;
   const rec = inv.data["recommendation"];
   const verdict =
@@ -187,7 +214,9 @@ const readRecommendation = (trace: TraceEvent[]): Recommendation | null => {
     the extras, rather than strict-parsing the whole event (which would reject it). */
 const MatchResultLoose = MatchResult.passthrough();
 const readMatchContext = (trace: TraceEvent[]): InvoiceContext | undefined => {
-  const matching = trace.find(
+  // findLast: the done matching event (with the MatchResult) follows the running one.
+  const matching = findLastEvent(
+    trace,
     (e) => e.stage === "matching" && e.kind === "step",
   );
   if (!matching || !isRecord(matching.data)) return undefined;