fix(dashboard): replay enabled state derived from marking, drop REPLAY chip

Two related issues on the EnactmentDetail replay flow:

1. Enabled-edge highlight during replay was wrong
   The previous fix (f94e507) made the highlight "sticky" — accumulated
   across replay steps. User says that's still wrong: at version v the
   diagram should show edges/transitions actually enabled AT v's
   derived marking, not the live count and not a cumulative union.

   Backend: derive_replay/2 now calls
   EnabledBindingElements.Computation.list(transition, runtime_cpnet,
   markings_map) for each transition against the derived marking and
   returns enabled_transitions in the :replay_to_version reply. The
   public surface CLAUDE.md names ("Given marking + transition,
   enumerates every firing binding. Core Petri-net semantics");
   composed with Runner.RuntimeCpnet.from_definition/1 + markings map
   keyed by Place.name(). Same shape BindingInspector already uses.
   No new private reach.

   Frontend: stickyEnabledEdgeIds state + union effect deleted.
   ReplayToVersionReply gains enabled_transitions?: readonly string[].
   replayEnabledTransitions state populates from each reply; derived
   into replayEnabledEdgeIds (p_to_t arcs whose transition is in the
   set). Live mode passes enabledEdgeIds=undefined so NetDiagram's
   internal enabled_count>0 path runs; replay passes the derived set
   exactly.

2. REPLAY chip in page header dropped
   The "REPLAY · v6" chip was redundant now that TimelineScrubber's
   own status line ("Replay · v6 of v7") and the new jump-to-live
   button (c0117f6) make the replay state self-evident. StateBadge's
   replay branch removed, the page no longer threads replayState
   into the byline.

Tests:
- enactment_detail_store_test: SimpleSequenceWorkflow case asserts
  v=0 → enabled_transitions == ["pass"]; v=1 → []; the single
  transition flips disabled after firing.
- EnactmentDetailPage.test: NetDiagram stub forwards enabledEdgeIds
  as data-enabled-edges ("live" sentinel when undefined). New cases
  pin live=undefined-sentinel; replay reply wires through to the
  prop; empty enabled set renders "[]". The REPLAY-chip test
  rewritten as a negative-presence assertion.

mix 175/176 (1 pre-existing telemetry-bridge flake reproduces on
baseline); pnpm typecheck + 169/169 vitest + build clean;
lib/coloured_flow byte-identical.

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

Author: fahchen

dashboard/lib/coloured_flow_dashboard_web/stores/enactment_detail_store.ex

@@ -129,6 +129,7 @@ defmodule ColouredFlowDashboardWeb.Stores.EnactmentDetailStore do
   use Musubi.Store, root: true
 
   alias ColouredFlow.Definition.ColouredPetriNet
+  alias ColouredFlow.EnabledBindingElements.Computation, as: EnabledBindingElements
   alias ColouredFlow.Enactment.BindingElement
   alias ColouredFlow.Enactment.Marking
   alias ColouredFlow.Enactment.Occurrence
@@ -138,6 +139,7 @@ defmodule ColouredFlowDashboardWeb.Stores.EnactmentDetailStore do
   alias ColouredFlow.Runner.Enactment.CatchingUp
   alias ColouredFlow.Runner.Enactment.Snapshot
   alias ColouredFlow.Runner.Enactment.Workitem, as: RunnerWorkitem
+  alias ColouredFlow.Runner.RuntimeCpnet
   alias ColouredFlow.Runner.Storage
   alias ColouredFlow.Runner.Storage.Schemas
   alias ColouredFlow.Runner.Worklist.WorkitemStream
@@ -256,6 +258,7 @@ defmodule ColouredFlowDashboardWeb.Stores.EnactmentDetailStore do
     reply do
       field :code, :ok | :invalid_version | :runner_error
       field :markings, list(ColouredFlowDashboardWeb.Views.MarkingRow.t())
+      field :enabled_transitions, list(String.t())
       field :replay_state, ColouredFlowDashboardWeb.Views.ReplayState.t() | nil
       field :available_max_version, integer() | nil
       field :snapshot_floor, integer() | nil
@@ -465,7 +468,7 @@ defmodule ColouredFlowDashboardWeb.Stores.EnactmentDetailStore do
     case coerce_version(version_raw) do
       {:ok, version} ->
         case derive_replay(socket, version) do
-          {:ok, marking_rows, replay_state, marking_index} ->
+          {:ok, marking_rows, enabled_transitions, replay_state, marking_index} ->
             socket =
               socket
               |> assign(:replay_marking_index, marking_index)
@@ -475,6 +478,7 @@ defmodule ColouredFlowDashboardWeb.Stores.EnactmentDetailStore do
             reply = %{
               code: :ok,
               markings: marking_rows,
+              enabled_transitions: enabled_transitions,
               replay_state: replay_state,
               available_max_version: socket.assigns.summary.version_range.max,
               snapshot_floor: current_snapshot_floor(socket.assigns.enactment_id)
@@ -485,7 +489,12 @@ defmodule ColouredFlowDashboardWeb.Stores.EnactmentDetailStore do
           {:error, reason, info} ->
             reply =
               Map.merge(
-                %{code: :invalid_version, markings: [], replay_state: nil},
+                %{
+                  code: :invalid_version,
+                  markings: [],
+                  enabled_transitions: [],
+                  replay_state: nil
+                },
                 replay_error_fields(reason, info, socket)
               )
 
@@ -496,6 +505,7 @@ defmodule ColouredFlowDashboardWeb.Stores.EnactmentDetailStore do
         reply = %{
           code: :invalid_version,
           markings: [],
+          enabled_transitions: [],
           replay_state: nil,
           available_max_version: socket.assigns.summary.version_range.max,
           snapshot_floor: current_snapshot_floor(socket.assigns.enactment_id)
@@ -717,11 +727,12 @@ defmodule ColouredFlowDashboardWeb.Stores.EnactmentDetailStore do
         {:error, :above_max, %{available_max_version: available_max}}
 
       true ->
-        do_derive_replay(enactment_id, target_version)
+        cpnet = cached_cpnet(enactment_id, socket.assigns.flow_cache)
+        do_derive_replay(enactment_id, target_version, cpnet)
     end
   end
 
-  defp do_derive_replay(enactment_id, target_version) do
+  defp do_derive_replay(enactment_id, target_version, cpnet) do
     # Pick the nearest base ≤ target_version. The persisted snapshot is the
     # fast path for target ≥ snapshot_version; for any earlier target we
     # MUST start from `Storage.get_initial_markings/1` and replay 1..target
@@ -747,17 +758,37 @@ defmodule ColouredFlowDashboardWeb.Stores.EnactmentDetailStore do
     {_steps, derived} = CatchingUp.apply(initial_markings, occurrences)
     marking_rows = Enum.map(derived, &marking_row/1)
     marking_index = build_marking_index(marking_rows)
+    enabled_transitions = compute_enabled_transitions(cpnet, derived)
 
     replay_state = %ReplayState{
       version: target_version,
       derived_at: DateTime.to_iso8601(DateTime.utc_now())
     }
 
-    {:ok, marking_rows, replay_state, marking_index}
+    {:ok, marking_rows, enabled_transitions, replay_state, marking_index}
   rescue
     error -> {:error, :runner_error, %{message: Exception.message(error)}}
   end
 
+  # Enabled-transition set at the derived marking. Delegates to
+  # `ColouredFlow.EnabledBindingElements.Computation.list/3` (public surface
+  # named in the main repo's CLAUDE.md) so the dashboard does not duplicate
+  # engine semantics. Returns transition names whose enabled-binding-elements
+  # set is non-empty against `markings`.
+  defp compute_enabled_transitions(nil, _markings), do: []
+
+  defp compute_enabled_transitions(%ColouredPetriNet{} = cpnet, markings)
+       when is_list(markings) do
+    runtime_cpnet = RuntimeCpnet.from_definition(cpnet)
+    markings_map = Map.new(markings, fn %Marking{place: p} = m -> {p, m} end)
+
+    for transition <- cpnet.transitions,
+        EnabledBindingElements.list(transition, runtime_cpnet, markings_map) != [],
+        do: to_string(transition.name)
+  rescue
+    _error -> []
+  end
+
   defp replay_error_fields(:above_max, %{available_max_version: max}, socket) do
     %{
       available_max_version: max,

dashboard/test/coloured_flow_dashboard_web/stores/enactment_detail_store_test.exs

@@ -926,6 +926,11 @@ defmodule ColouredFlowDashboardWeb.Stores.EnactmentDetailStoreTest do
 
       refute Enum.any?(reply.markings, fn row -> to_string(row.place) == "output" end)
 
+      # `pass` is enabled at v=0 against the initial marking — the runner's
+      # `EnabledBindingElements.list/3` is the source of truth, so the reply
+      # carries the engine-derived set, not the live `enabled_count`.
+      assert reply.enabled_transitions == ["pass"]
+
       # Summary.replay_state mirrors the reply so the SPA can flip into
       # replay chrome.
       summary = Musubi.Testing.assigns(page).summary
@@ -944,6 +949,12 @@ defmodule ColouredFlowDashboardWeb.Stores.EnactmentDetailStoreTest do
 
       refute Enum.any?(reply.markings, fn row -> to_string(row.place) == "input" end)
 
+      # At v=1 the only token has moved to `:output`, so `pass` has no input
+      # binding and the engine reports no enabled transition. Asserts the
+      # replay reply tracks the derived marking — not the live counts which
+      # might still see `pass` enabled across a different enactment.
+      assert reply.enabled_transitions == []
+
       # The diagram derived view picks up the same place counts so the
       # token badges agree with the Markings tab in replay mode.
       diagram = Musubi.Testing.assigns(page).diagram

dashboard/ui/src/generated/musubi.d.ts

@@ -140,6 +140,7 @@ declare namespace Musubi {
           reply: {
             code: "ok" | "invalid_version" | "runner_error"
             markings: ColouredFlowDashboardWeb.Views.MarkingRow[]
+            enabled_transitions: string[]
             replay_state: ColouredFlowDashboardWeb.Views.ReplayState | null
             available_max_version: number | null
             snapshot_floor: number | null

dashboard/ui/src/routes/EnactmentDetailPage.test.tsx

@@ -131,16 +131,23 @@ vi.mock("../components/NetDiagram", () => ({
   default: ({
     onSelectTransition,
     firingEdgeIds,
-    firingDurationMs
+    firingDurationMs,
+    enabledEdgeIds
   }: {
     onSelectTransition?: (name: string) => void
     firingEdgeIds?: ReadonlySet<string>
     firingDurationMs?: number
+    enabledEdgeIds?: ReadonlySet<string>
   }) => (
     <div
       data-testid="net-diagram-stub"
       data-firing-edges={JSON.stringify([...(firingEdgeIds ?? [])].sort())}
       data-firing-duration={String(firingDurationMs ?? "")}
+      data-enabled-edges={
+        enabledEdgeIds === undefined
+          ? "live"
+          : JSON.stringify([...enabledEdgeIds].sort())
+      }
     >
       <button
         type="button"
@@ -857,22 +864,86 @@ describe("EnactmentDetailPage", () => {
       }
     })
 
-    it("renders the REPLAY chip + Markings replay banner when summary.replay_state is set", () => {
+    it("renders the Markings replay banner when summary.replay_state is set, without a separate page-header REPLAY pill", () => {
       const restore = mutateReplay(
         { version: 1, derived_at: "2026-05-29T01:00:00Z" },
         { min: 0, max: 3 }
       )
       try {
         renderRoute(<EnactmentDetailPage />)
-        const chip = screen.getByTestId("state-badge-replay")
-        expect(chip.textContent).toMatch(/REPLAY/)
-        expect(chip.textContent).toMatch(/v1/)
+        // The page-header REPLAY pill was dropped — TimelineScrubber's own
+        // status line + the jump-to-live button now signal replay mode.
+        expect(screen.queryByTestId("state-badge-replay")).toBeNull()
         expect(screen.getByTestId("markings-replay-banner")).toBeDefined()
       } finally {
         restore()
       }
     })
 
+    it("live mode passes undefined enabledEdgeIds so NetDiagram uses its internal enabled_count derivation", () => {
+      renderRoute(<EnactmentDetailPage />)
+      expect(
+        screen.getByTestId("net-diagram-stub").dataset.enabledEdges
+      ).toBe("live")
+    })
+
+    it("replay_to_version reply's enabled_transitions wires straight into NetDiagram's enabledEdgeIds", async () => {
+      replayToVersionMock.mockResolvedValueOnce({
+        code: "ok",
+        markings: [],
+        enabled_transitions: ["approve"],
+        replay_state: { version: 1, derived_at: "2026-05-29T01:00:00Z" },
+        available_max_version: 3,
+        snapshot_floor: 0
+      })
+      const restore = mutateReplay(
+        { version: 1, derived_at: "2026-05-29T01:00:00Z" },
+        { min: 0, max: 3 }
+      )
+      try {
+        renderRoute(<EnactmentDetailPage />)
+        await act(async () => {
+          fireEvent.click(screen.getByTestId("timeline-step-back"))
+        })
+        await waitFor(() => {
+          const value = screen.getByTestId("net-diagram-stub").dataset.enabledEdges
+          // Only the p_to_t arc of `approve` lights up — the seed diagram has
+          // exactly one such edge (`pending → approve` at index 0).
+          expect(value).toBe(JSON.stringify(["arc-p_to_t-pending-approve-0"]))
+        })
+      } finally {
+        restore()
+      }
+    })
+
+    it("an empty enabled_transitions clears the replay edge highlight", async () => {
+      replayToVersionMock.mockResolvedValueOnce({
+        code: "ok",
+        markings: [],
+        enabled_transitions: [],
+        replay_state: { version: 0, derived_at: "2026-05-29T01:00:00Z" },
+        available_max_version: 3,
+        snapshot_floor: 0
+      })
+      const restore = mutateReplay(
+        { version: 1, derived_at: "2026-05-29T01:00:00Z" },
+        { min: 0, max: 3 }
+      )
+      try {
+        renderRoute(<EnactmentDetailPage />)
+        await act(async () => {
+          fireEvent.click(screen.getByTestId("timeline-step-back"))
+        })
+        await waitFor(() => {
+          expect(
+            screen.getByTestId("net-diagram-stub").dataset.enabledEdges
+          ).toBe("[]")
+        })
+      } finally {
+        restore()
+      }
+    })
+
     it("populates firingEdgeIds when version advances + clears after the firing duration", async () => {
       vi.useFakeTimers()
       const mut = sampleSnapshot as unknown as {