fix(workflow-builder): Try/Run refuse an unrunnable graph; honest preview copy

Three findings from the walkthrough, all the same shape — the canvas asserting
one thing while the run does another.

D-11 (14.8) — a graph with validation errors was still runnable. A deleted
`dyn.*` lineage is diagnosed at author time (red Deleted badge, "not
registered") and the run then dies at dynamicNode.resolveLineage. Try and Run
now refuse while errorCount > 0. Warnings are advisory and deliberately do NOT
block.

D-16 (9.12) — with unsaved edits, Try ran the PREVIOUSLY SAVED graph and said
nothing. Measured live: the rename landed on the canvas, the editor reported
dirty, and after Try no version existed and the server still held the old
label. Try and Run now refuse while dirty. Chose this over auto-saving because
auto-save mints a version on every dirty Try, which changes what version
history means.

Both funnel through one `runBlockedReason`, which doubles as the tooltip — a
button can never be disabled here without saying why. The existing
"Save the workflow first" string is reused verbatim so its assertions elsewhere
keep passing.

D-12 (14.9) — a succeeded node with no cache row always reported `evicted` and
offered "Re-run to repopulate". For a `@deterministic:false` dynamic node that
is untrue twice: nothing expired (it is never cached, §3.3) and re-running can
never repopulate it. New `not-cached` reason with its own copy, no Re-run
button, naming the actual cause and the fix. No backend work was needed — the
catalog already ships `nonCacheable`; it just was not being read.

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

Author: alex-struk

apps/frontend/src/features/workflow-builder/WorkflowEditorV2Page.test.tsx

@@ -40,6 +40,7 @@ const {
   capturedCreateDto,
   capturedPaletteProps,
   catalogEntriesRef,
+  validationRef,
   capturedRunDrawerProps,
   capturedSettingsPanelProps,
   capturedValidationDrawerProps,
@@ -66,6 +67,16 @@ const {
     // The merged activity catalog, mutable so a test can model the entry
     // arriving AFTER a publish (which is when `onAddDynamicNode` fires).
     catalogEntriesRef: { current: [] as Array<Record<string, unknown>> },
+    // D-11: mutable so a test can put the graph into an error state.
+    validationRef: {
+      current: {
+        errorCount: 0,
+        warningCount: 0,
+        isPending: false,
+        errorsByNode: new Map(),
+        errors: [] as Array<Record<string, unknown>>,
+      },
+    },
     // US-148 — the Run drawer stub captures its props so the trigger
     // tests can verify `openMode` was set correctly by whichever
     // top-bar button opened the drawer.
@@ -243,13 +254,7 @@ vi.mock("./dynamic-nodes", () => ({
 }));
 
 vi.mock("./validation/useGraphValidation", () => ({
-  useGraphValidation: () => ({
-    errorCount: 0,
-    warningCount: 0,
-    isPending: false,
-    errorsByNode: new Map(),
-    errors: [],
-  }),
+  useGraphValidation: () => validationRef.current,
 }));
 
 // US-153 — the Run-history drawer body calls `useWorkflowRuns`, which
@@ -3253,3 +3258,125 @@ describe("WorkflowEditorV2Page — 14.8 dynamic node drops after a publish", ()
     expect(added).toBeDefined();
   });
 });
+
+/**
+ * D-11 + D-16 — Try and Run must refuse a graph the run would not honour.
+ *
+ * Both were found walking the plan and are the same bug wearing two hats: the
+ * canvas asserted one thing and the run did another.
+ *
+ *   D-11 (14.8) — a workflow whose `dyn.*` lineage is deleted is diagnosed
+ *   correctly (red Deleted badge, "not registered" error) and Try stayed
+ *   enabled. The run then failed at `dynamicNode.resolveLineage` — knowable at
+ *   author time, which is what "fail before the run" asks for.
+ *
+ *   D-16 (9.12) — with unsaved edits, Try ran the PREVIOUSLY SAVED graph.
+ *   Measured live: the rename landed on the canvas, the editor reported dirty,
+ *   and after Try no version existed and the server still held the old label.
+ *   The author watched badges light up for a graph they were not looking at.
+ */
+describe("WorkflowEditorV2Page — D-11/D-16 Try and Run refuse an unrunnable graph", () => {
+  beforeEach(() => {
+    capturedCanvasProps.current = null;
+    capturedPaletteProps.current = null;
+    validationRef.current = {
+      errorCount: 0,
+      warningCount: 0,
+      isPending: false,
+      errorsByNode: new Map(),
+      errors: [],
+    };
+    existingWorkflowRef.current = {
+      id: "wf-1",
+      name: "WF",
+      description: "",
+      slug: "wf",
+      version: 1,
+      workflowVersionId: "v-head",
+      config: buildTemplateConfig({ positions: "all" }),
+    };
+  });
+
+  afterEach(() => {
+    validationRef.current = {
+      errorCount: 0,
+      warningCount: 0,
+      isPending: false,
+      errorsByNode: new Map(),
+      errors: [],
+    };
+    existingWorkflowRef.current = null;
+  });
+
+  it("enables Try and Run on a clean, saved, valid graph", async () => {
+    renderEditPage("wf-1");
+    await waitFor(() => {
+      expect(capturedCanvasProps.current?.config).toBeDefined();
+    });
+    expect(screen.getByTestId("try-button")).toBeEnabled();
+    expect(screen.getByTestId("run-this-workflow-button")).toBeEnabled();
+  });
+
+  it("D-11 — disables Try and Run while the graph has validation errors", async () => {
+    validationRef.current = {
+      errorCount: 1,
+      warningCount: 0,
+      isPending: false,
+      errorsByNode: new Map(),
+      errors: [
+        {
+          path: "nodes.a.activityType",
+          message: 'Activity type "dyn.gone" is not registered',
+          severity: "error",
+        },
+      ],
+    };
+    renderEditPage("wf-1");
+    await waitFor(() => {
+      expect(capturedCanvasProps.current?.config).toBeDefined();
+    });
+    expect(screen.getByTestId("try-button")).toBeDisabled();
+    expect(screen.getByTestId("run-this-workflow-button")).toBeDisabled();
+  });
+
+  it("D-11 — a warning alone does NOT disable them", async () => {
+    validationRef.current = {
+      errorCount: 0,
+      warningCount: 3,
+      isPending: false,
+      errorsByNode: new Map(),
+      errors: [],
+    };
+    renderEditPage("wf-1");
+    await waitFor(() => {
+      expect(capturedCanvasProps.current?.config).toBeDefined();
+    });
+    expect(screen.getByTestId("try-button")).toBeEnabled();
+    expect(screen.getByTestId("run-this-workflow-button")).toBeEnabled();
+  });
+
+  it("D-16 — disables Try and Run once there are unsaved edits", async () => {
+    renderEditPage("wf-1");
+    await waitFor(() => {
+      expect(capturedCanvasProps.current?.config).toBeDefined();
+    });
+    expect(screen.getByTestId("try-button")).toBeEnabled();
+
+    const onConfigChange = capturedCanvasProps.current?.onConfigChange as (
+      c: GraphWorkflowConfig,
+    ) => void;
+    const live = capturedCanvasProps.current?.config as GraphWorkflowConfig;
+    act(() => {
+      onConfigChange({
+        ...live,
+        nodes: {
+          ...live.nodes,
+          b: { ...(live.nodes.b as ActivityNode), label: "EDITED-NOT-SAVED" },
+        },
+      });
+    });
+
+    expect(screen.getByTestId("try-button")).toBeDisabled();
+    expect(screen.getByTestId("run-this-workflow-button")).toBeDisabled();
+  });
+});

apps/frontend/src/features/workflow-builder/WorkflowEditorV2Page.tsx

@@ -762,6 +762,33 @@ function WorkflowEditorV2PageBody({ mode }: WorkflowEditorV2PageProps) {
   // session. Reuses the dirty signal above — no second source of truth.
   useUnsavedGuard({ isDirty, isDirtyNow: hasUnsavedChanges });
 
+  /**
+   * Why Try / Run are unavailable, or `null` when they are. Doubles as the
+   * tooltip, so the button can never be disabled without saying why.
+   *
+   * D-11 and D-16 are the same defect wearing two hats — the canvas asserting
+   * one thing while the run does another:
+   *
+   *   - **D-11**: a graph with validation errors was still runnable. A deleted
+   *     `dyn.*` lineage is diagnosed at author time (red Deleted badge,
+   *     "not registered") and the run then dies at
+   *     `dynamicNode.resolveLineage`. The plan's own invariant is "a state the
+   *     runtime cannot satisfy is reported at author time" — so refuse here.
+   *     Warnings are advisory and deliberately do NOT block.
+   *   - **D-16**: with unsaved edits, Try ran the PREVIOUSLY SAVED graph and
+   *     said nothing. Refusing while dirty keeps version history meaningful
+   *     (the alternative, auto-saving, mints a version on every Try) and makes
+   *     "what you see is what runs" true again.
+   */
+  const runBlockedReason: string | null =
+    !isEditMode || !workflowId
+      ? "Save the workflow first"
+      : validation.errorCount > 0
+        ? `Fix ${validation.errorCount} validation ${validation.errorCount === 1 ? "error" : "errors"} first — this graph cannot run as it stands`
+        : isDirty
+          ? "Save your changes first — a run always executes the saved graph, not the canvas"
+          : null;
+
   // Hydrate state when the workflow loads in edit mode.
   // Run auto-layout when the loaded config carries no node positions — e.g.
   // seeded workflows (docs-md/workflows/templates/*.json) and any
@@ -1414,18 +1441,15 @@ function WorkflowEditorV2PageBody({ mode }: WorkflowEditorV2PageProps) {
             Save
           </Button>
           {tryButtonVisible && (
-            <Tooltip
-              label="Save the workflow first"
-              disabled={isEditMode && !!workflowId}
-            >
+            <Tooltip label={runBlockedReason ?? "Run this graph now"}>
               <Button
                 variant="filled"
                 color="blue"
                 leftSection={<IconBolt size={14} />}
                 onClick={() => setRunDrawerMode("try")}
                 size="xs"
                 data-testid="try-button"
-                disabled={!isEditMode || !workflowId}
+                disabled={runBlockedReason !== null}
               >
                 Try
               </Button>
@@ -1437,11 +1461,9 @@ function WorkflowEditorV2PageBody({ mode }: WorkflowEditorV2PageProps) {
             onClick={() => setRunDrawerMode("run")}
             size="xs"
             data-testid="run-this-workflow-button"
-            disabled={!isEditMode || !workflowId}
+            disabled={runBlockedReason !== null}
             title={
-              !isEditMode || !workflowId
-                ? "Save the workflow first to enable Run."
-                : "Open the run-trigger panel for this workflow"
+              runBlockedReason ?? "Open the run-trigger panel for this workflow"
             }
           >
             Run this workflow

apps/frontend/src/features/workflow-builder/canvas/WorkflowEditorCanvas.tsx

@@ -666,10 +666,14 @@ const ActivityNodeRenderer = memo(
     // lineage was soft-deleted) render a red "Deleted" pill instead.
     const isDynamic = data.activityType.startsWith("dyn.");
     const catalog = useActivityCatalog();
+    const catalogEntry = catalog.entries.find(
+      (e) => e.activityType === data.activityType,
+    );
     const isMissingFromCatalog =
-      isDynamic &&
-      !catalog.isLoading &&
-      !catalog.entries.some((e) => e.activityType === data.activityType);
+      isDynamic && !catalog.isLoading && catalogEntry === undefined;
+    // D-12: a `@deterministic:false` dynamic node is never written to the
+    // output cache, so its empty preview is "not cached", not "evicted".
+    const neverCached = catalogEntry?.nonCacheable === true;
     // Node-level flow handles: the unnamed left target + the `id="out"`
     // right source keep today's connect gesture AND anchor everything the
     // wire projection doesn't route to a per-port dot. Source handles are
@@ -821,7 +825,11 @@ const ActivityNodeRenderer = memo(
           onOutputHandleEnter={data.onOutputHandleEnter}
           onOutputHandleLeave={data.onOutputHandleLeave}
         />
-        <NodePreviewOverlay nodeId={id} outputs={data.previewOutputs} />
+        <NodePreviewOverlay
+          nodeId={id}
+          outputs={data.previewOutputs}
+          neverCached={neverCached}
+        />
       </div>
     );
   },

apps/frontend/src/features/workflow-builder/preview/PreviewWidget.tsx

@@ -102,6 +102,14 @@ export interface PreviewWidgetProps {
    * so they stay silent instead of showing a misleading "cache evicted" alert.
    */
   producesOutput?: boolean;
+  /**
+   * D-12 — true when this node's output is never cached at all (a dynamic node
+   * whose script is `@deterministic:false`, surfaced by the catalog as
+   * `nonCacheable`). Without it a green run reported "cache evicted — re-run to
+   * repopulate", blaming a TTL that never applied and offering a recovery that
+   * cannot work.
+   */
+  neverCached?: boolean;
 }
 
 /**
@@ -120,6 +128,7 @@ export function PreviewWidget({
   outputs,
   nodeStatus,
   producesOutput = true,
+  neverCached = false,
 }: PreviewWidgetProps): ReactNode {
   const { data, isLoading, error } = useActivityOutputPreview(
     workflowId,
@@ -170,6 +179,7 @@ export function PreviewWidget({
       runFinished: isReplay && hasRun,
       producesOutput,
       hasActiveRun: hasRun,
+      neverCached,
     });
     const copy = describeNoOutput(reason);
 
@@ -271,6 +281,14 @@ export interface NodePreviewOverlayProps {
    * output-cache row). Defaults to `true`.
    */
   producesOutput?: boolean;
+  /**
+   * D-12 — true when this node's output is never cached at all (a dynamic node
+   * whose script is `@deterministic:false`, surfaced by the catalog as
+   * `nonCacheable`). Without it a green run reported "cache evicted — re-run to
+   * repopulate", blaming a TTL that never applied and offering a recovery that
+   * cannot work.
+   */
+  neverCached?: boolean;
 }
 
 /**
@@ -284,6 +302,7 @@ export function NodePreviewOverlay({
   nodeId,
   outputs,
   producesOutput = true,
+  neverCached = false,
 }: NodePreviewOverlayProps): ReactNode {
   const ctx = useOptionalRunState();
   if (!ctx) {
@@ -316,6 +335,7 @@ export function NodePreviewOverlay({
       outputs={outputs}
       nodeStatus={ctx.nodeStatuses[nodeId]?.status}
       producesOutput={producesOutput}
+      neverCached={neverCached}
     />
   );
 }

apps/frontend/src/features/workflow-builder/preview/no-output-state.test.ts

@@ -112,3 +112,55 @@ describe("describeNoOutput", () => {
     ).toThrowError(/unhandled variant/);
   });
 });
+
+/**
+ * D-12 — a succeeded node with no cache row was always reported as `evicted`,
+ * offering a Re-run to "repopulate" it. For a `@deterministic:false` dynamic
+ * node that is untrue twice over: nothing was evicted (it was never cached),
+ * and re-running can never repopulate it, because §3.3 says such scripts must
+ * re-execute every run and are deliberately not cached.
+ *
+ * Measured live on the Part-14 demo before it was tagged deterministic: a green
+ * run, and the widget reading "Preview unavailable — cache evicted. Re-run to
+ * repopulate."
+ */
+describe("noOutputReasonForNode — D-12 never-cached vs evicted", () => {
+  const base = {
+    runFinished: true,
+    producesOutput: true,
+    hasActiveRun: true,
+  } as const;
+
+  it("reports `not-cached` for a succeeded node that is never cached", () => {
+    expect(
+      noOutputReasonForNode({
+        ...base,
+        status: "succeeded",
+        neverCached: true,
+      }),
+    ).toBe("not-cached");
+  });
+
+  it("still reports `evicted` for a succeeded node that IS cacheable", () => {
+    expect(
+      noOutputReasonForNode({
+        ...base,
+        status: "succeeded",
+        neverCached: false,
+      }),
+    ).toBe("evicted");
+  });
+
+  it("never-cached does not mask a failure", () => {
+    expect(
+      noOutputReasonForNode({ ...base, status: "failed", neverCached: true }),
+    ).toBe("failed");
+  });
+
+  it("offers no Re-run for `not-cached`, and says why rather than blaming an eviction", () => {
+    const copy = describeNoOutput("not-cached");
+    expect(copy.offersRerun).toBe(false);
+    expect(copy.message).toMatch(/non-deterministic/i);
+    expect(copy.message).not.toMatch(/evict/i);
+  });
+});