diff --git a/CHANGELOG.md b/CHANGELOG.md
index d5a2806ee0..b771b11b47 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -62,6 +62,8 @@ and this project adheres to
 
 ### Fixed
 
+- 500 error when navigating from collaborative editor to full history page
+  [#3941](https://github.com/OpenFn/lightning/pull/3941)
 - Duplicate `isReadOnly` declaration in TriggerForm that was blocking asset
   builds [#3976](https://github.com/OpenFn/lightning/issues/3976)
 - Run duration and status alignment drift in history view
diff --git a/assets/js/collaborative-editor/components/diagram/CollaborativeWorkflowDiagram.tsx b/assets/js/collaborative-editor/components/diagram/CollaborativeWorkflowDiagram.tsx
index 7fc8bc94b5..ced33d7cfe 100644
--- a/assets/js/collaborative-editor/components/diagram/CollaborativeWorkflowDiagram.tsx
+++ b/assets/js/collaborative-editor/components/diagram/CollaborativeWorkflowDiagram.tsx
@@ -18,10 +18,13 @@ import {
   useRunSteps,
 } from '../../hooks/useHistory';
 import { useIsNewWorkflow } from '../../hooks/useSessionContext';
+import { useVersionMismatch } from '../../hooks/useVersionMismatch';
+import { useVersionSelect } from '../../hooks/useVersionSelect';
 import { useNodeSelection } from '../../hooks/useWorkflow';
 import type { Run } from '../../types/history';
 
 import MiniHistory from './MiniHistory';
+import { VersionMismatchBanner } from './VersionMismatchBanner';
 import CollaborativeWorkflowDiagramImpl from './WorkflowDiagram';
 
 interface CollaborativeWorkflowDiagramProps {
@@ -72,14 +75,31 @@ export function CollaborativeWorkflowDiagram({
   // Use hook to get run steps with automatic subscription management
   const currentRunSteps = useRunSteps(selectedRunId);
 
-  // Update URL when run selection changes
-  const handleRunSelect = useCallback((run: Run) => {
-    setSelectedRunId(run.id);
+  // Detect version mismatch for warning banner
+  const versionMismatch = useVersionMismatch(selectedRunId);
 
-    const url = new URL(window.location.href);
-    url.searchParams.set('run', run.id);
-    window.history.pushState({}, '', url.toString());
-  }, []);
+  // Get version selection handler
+  const handleVersionSelect = useVersionSelect();
+
+  // Update URL when run selection changes
+  const handleRunSelect = useCallback(
+    (run: Run) => {
+      setSelectedRunId(run.id);
+
+      // Find the workorder that contains this run
+      const workorder = history.find(wo => wo.runs.some(r => r.id === run.id));
+
+      // Switch to the version this run was executed on
+      if (workorder) {
+        handleVersionSelect(workorder.version);
+      }
+
+      const url = new URL(window.location.href);
+      url.searchParams.set('run', run.id);
+      window.history.pushState({}, '', url.toString());
+    },
+    [history, handleVersionSelect]
+  );
 
   // Clear URL parameter when deselecting run
   const handleDeselectRun = useCallback(() => {
@@ -133,6 +153,15 @@ export function CollaborativeWorkflowDiagram({
   return (
     <div ref={containerRef} className={className}>
       <ReactFlowProvider>
+        {/* Version mismatch warning when viewing latest but run used older version */}
+        {versionMismatch && (
+          <VersionMismatchBanner
+            runVersion={versionMismatch.runVersion}
+            currentVersion={versionMismatch.currentVersion}
+            className="absolute top-0 left-0 right-0 z-10"
+          />
+        )}
+
         <CollaborativeWorkflowDiagramImpl
           selection={currentNode.id}
           onSelectionChange={selectNode}
diff --git a/assets/js/collaborative-editor/components/diagram/MiniHistory.tsx b/assets/js/collaborative-editor/components/diagram/MiniHistory.tsx
index ef22cf7453..9dd81af1eb 100644
--- a/assets/js/collaborative-editor/components/diagram/MiniHistory.tsx
+++ b/assets/js/collaborative-editor/components/diagram/MiniHistory.tsx
@@ -29,7 +29,14 @@ import React, { useState } from 'react';
 import { relativeLocale } from '../../../hooks';
 import { duration } from '../../../utils/duration';
 import truncateUid from '../../../utils/truncateUID';
+import { useProject } from '../../hooks/useSessionContext';
+import { useWorkflowState } from '../../hooks/useWorkflow';
 import type { Run, WorkOrder } from '../../types/history';
+import {
+  navigateToRun,
+  navigateToWorkOrderHistory,
+  navigateToWorkflowHistory,
+} from '../../utils/navigation';
 
 // Extended types with selection state for UI
 type RunWithSelection = Run & { selected?: boolean };
@@ -102,6 +109,10 @@ export default function MiniHistory({
   const [expandedWorder, setExpandedWorder] = useState('');
   const now = new Date();
 
+  // Get project and workflow IDs from state for navigation
+  const project = useProject();
+  const workflow = useWorkflowState(state => state.workflow);
+
   // Clear expanded work order when panel collapses
   React.useEffect(() => {
     if (collapsed) {
@@ -131,49 +142,30 @@ export default function MiniHistory({
   const gotoHistory = (e: React.MouseEvent | React.KeyboardEvent) => {
     e.preventDefault();
     e.stopPropagation();
-    const currentUrl = new URL(window.location.href);
-    const nextUrl = new URL(currentUrl);
-    const paths = nextUrl.pathname.split('/');
-    const wIdx = paths.indexOf('w');
-    const workflowPaths = paths.splice(wIdx, paths.length - wIdx);
-    nextUrl.pathname = paths.join('/') + `/history`;
-    nextUrl.search = `?filters[workflow_id]=${
-      workflowPaths[workflowPaths.length - 1]
-    }`;
-    window.location.assign(nextUrl.toString());
+
+    if (project?.id && workflow?.id) {
+      navigateToWorkflowHistory(project.id, workflow.id);
+    }
   };
 
-  const navigateToWorkorderHistory = (
+  const handleNavigateToWorkorderHistory = (
     e: React.MouseEvent,
     workorderId: string
   ) => {
     e.preventDefault();
     e.stopPropagation();
-    const currentUrl = new URL(window.location.href);
-    const nextUrl = new URL(currentUrl);
-    const paths = nextUrl.pathname.split('/');
-    const projectIndex = paths.indexOf('projects');
-    const projectId = projectIndex !== -1 ? paths[projectIndex + 1] : null;
 
-    if (projectId) {
-      nextUrl.pathname = `/projects/${projectId}/history`;
-      nextUrl.search = `?filters[workorder_id]=${workorderId}`;
-      window.location.assign(nextUrl.toString());
+    if (project?.id) {
+      navigateToWorkOrderHistory(project.id, workorderId);
     }
   };
 
-  const navigateToRunView = (e: React.MouseEvent, runId: string) => {
+  const handleNavigateToRunView = (e: React.MouseEvent, runId: string) => {
     e.preventDefault();
     e.stopPropagation();
-    const currentUrl = new URL(window.location.href);
-    const nextUrl = new URL(currentUrl);
-    const paths = nextUrl.pathname.split('/');
-    const projectIndex = paths.indexOf('projects');
-    const projectId = projectIndex !== -1 ? paths[projectIndex + 1] : null;
 
-    if (projectId) {
-      nextUrl.pathname = `/projects/${projectId}/runs/${runId}`;
-      window.location.assign(nextUrl.toString());
+    if (project?.id) {
+      navigateToRun(project.id, runId);
     }
   };
 
@@ -342,7 +334,7 @@ export default function MiniHistory({
                       <button
                         type="button"
                         onClick={e =>
-                          navigateToWorkorderHistory(e, workorder.id)
+                          handleNavigateToWorkorderHistory(e, workorder.id)
                         }
                         className="link-uuid"
                         title={workorder.id}
@@ -420,7 +412,7 @@ export default function MiniHistory({
                           )}
                           <button
                             type="button"
-                            onClick={e => navigateToRunView(e, run.id)}
+                            onClick={e => handleNavigateToRunView(e, run.id)}
                             className="link-uuid"
                             title={run.id}
                             aria-label={`View full details for run ${truncateUid(run.id)}`}
diff --git a/assets/js/collaborative-editor/components/diagram/VersionMismatchBanner.tsx b/assets/js/collaborative-editor/components/diagram/VersionMismatchBanner.tsx
new file mode 100644
index 0000000000..121297bfff
--- /dev/null
+++ b/assets/js/collaborative-editor/components/diagram/VersionMismatchBanner.tsx
@@ -0,0 +1,45 @@
+/**
+ * VersionMismatchBanner - Warning when viewing latest workflow but selected run used older version
+ *
+ * Displays when:
+ * - A run is selected
+ * - Viewing "latest" workflow (not a specific snapshot)
+ * - The run was executed on a different version than currently displayed
+ *
+ * This prevents confusion when the workflow structure has changed since the run executed.
+ */
+
+import { cn } from '#/utils/cn';
+
+interface VersionMismatchBannerProps {
+  runVersion: number;
+  currentVersion: number;
+  className?: string;
+}
+
+export function VersionMismatchBanner({
+  runVersion,
+  currentVersion,
+  className,
+}: VersionMismatchBannerProps) {
+  return (
+    <div
+      className={cn(
+        'w-full bg-yellow-50 text-yellow-700 justify-center flex items-center gap-x-2 px-6 py-2.5 sm:px-3.5',
+        className
+      )}
+      role="alert"
+      aria-live="polite"
+    >
+      <span
+        className="hero-exclamation-triangle h-5 w-5 inline-block"
+        aria-hidden="true"
+      />
+      <p className="text-sm leading-6">
+        This run was executed on version {runVersion}, but you're viewing
+        version {currentVersion}. Steps shown may not match the current workflow
+        structure.
+      </p>
+    </div>
+  );
+}
diff --git a/assets/js/collaborative-editor/hooks/useVersionMismatch.ts b/assets/js/collaborative-editor/hooks/useVersionMismatch.ts
new file mode 100644
index 0000000000..ea379a0fa5
--- /dev/null
+++ b/assets/js/collaborative-editor/hooks/useVersionMismatch.ts
@@ -0,0 +1,64 @@
+/**
+ * useVersionMismatch - Detects when viewing latest workflow but selected run used older version
+ *
+ * Returns version mismatch info when:
+ * - A run is selected
+ * - Viewing "latest" workflow (not a specific snapshot)
+ * - The run was executed on a different version than currently displayed
+ *
+ * This prevents confusion when the workflow structure has changed since the run executed.
+ */
+
+import { useMemo } from 'react';
+
+import { useHistory } from './useHistory';
+import { useLatestSnapshotLockVersion } from './useSessionContext';
+import { useWorkflowState } from './useWorkflow';
+
+interface VersionMismatch {
+  runVersion: number;
+  currentVersion: number;
+}
+
+export function useVersionMismatch(
+  selectedRunId: string | null
+): VersionMismatch | null {
+  const history = useHistory();
+  const workflow = useWorkflowState(state => state.workflow);
+  const latestSnapshotLockVersion = useLatestSnapshotLockVersion();
+
+  return useMemo(() => {
+    if (
+      !selectedRunId ||
+      !workflow ||
+      !workflow.lock_version ||
+      !latestSnapshotLockVersion
+    ) {
+      return null;
+    }
+
+    const workflowLockVersion = workflow.lock_version;
+
+    // Find the work order that contains the selected run
+    const selectedWorkOrder = history.find(wo =>
+      wo.runs.some(run => run.id === selectedRunId)
+    );
+
+    if (!selectedWorkOrder) {
+      return null;
+    }
+
+    // Show warning when viewing a different version than the run used
+    const runUsedDifferentVersion =
+      selectedWorkOrder.version !== workflowLockVersion;
+
+    if (runUsedDifferentVersion) {
+      return {
+        runVersion: selectedWorkOrder.version,
+        currentVersion: workflowLockVersion,
+      };
+    }
+
+    return null;
+  }, [selectedRunId, workflow, latestSnapshotLockVersion, history]);
+}
diff --git a/assets/js/collaborative-editor/utils/navigation.ts b/assets/js/collaborative-editor/utils/navigation.ts
new file mode 100644
index 0000000000..231bc6ef33
--- /dev/null
+++ b/assets/js/collaborative-editor/utils/navigation.ts
@@ -0,0 +1,79 @@
+/**
+ * Navigation utilities for the collaborative editor
+ *
+ * Provides clean, testable navigation functions that build URLs from IDs
+ * rather than parsing existing URLs. Uses URLSearchParams for query string
+ * construction to avoid brittle string concatenation.
+ *
+ * **Important**: These utilities are for navigating to pages OUTSIDE the
+ * collaborative editor (e.g., history page, run detail pages). For URL changes
+ * within the collaborative editor itself, use the `useURLState` hook instead
+ * to update query parameters without full page reloads.
+ *
+ * @see {@link ../hooks/use-url-state.ts} for in-editor URL state management
+ */
+
+/**
+ * Navigate to the history page filtered by workflow ID
+ *
+ * @param projectId - The project UUID
+ * @param workflowId - The workflow UUID
+ *
+ * @example
+ * navigateToWorkflowHistory('proj-123', 'wf-456')
+ * // Navigates to: /projects/proj-123/history?filters[workflow_id]=wf-456
+ */
+export function navigateToWorkflowHistory(
+  projectId: string,
+  workflowId: string
+): void {
+  const url = new URL(window.location.origin);
+  url.pathname = `/projects/${projectId}/history`;
+
+  const params = new URLSearchParams();
+  params.set('filters[workflow_id]', workflowId);
+  url.search = params.toString();
+
+  window.location.assign(url.toString());
+}
+
+/**
+ * Navigate to the history page filtered by work order ID
+ *
+ * @param projectId - The project UUID
+ * @param workOrderId - The work order UUID
+ *
+ * @example
+ * navigateToWorkOrderHistory('proj-123', 'wo-789')
+ * // Navigates to: /projects/proj-123/history?filters[workorder_id]=wo-789
+ */
+export function navigateToWorkOrderHistory(
+  projectId: string,
+  workOrderId: string
+): void {
+  const url = new URL(window.location.origin);
+  url.pathname = `/projects/${projectId}/history`;
+
+  const params = new URLSearchParams();
+  params.set('filters[workorder_id]', workOrderId);
+  url.search = params.toString();
+
+  window.location.assign(url.toString());
+}
+
+/**
+ * Navigate to a specific run detail page
+ *
+ * @param projectId - The project UUID
+ * @param runId - The run UUID
+ *
+ * @example
+ * navigateToRun('proj-123', 'run-456')
+ * // Navigates to: /projects/proj-123/runs/run-456
+ */
+export function navigateToRun(projectId: string, runId: string): void {
+  const url = new URL(window.location.origin);
+  url.pathname = `/projects/${projectId}/runs/${runId}`;
+
+  window.location.assign(url.toString());
+}
diff --git a/assets/js/workflow-diagram/util/ensure-node-position.ts b/assets/js/workflow-diagram/util/ensure-node-position.ts
index 3255ce8fed..12513bdc74 100644
--- a/assets/js/workflow-diagram/util/ensure-node-position.ts
+++ b/assets/js/workflow-diagram/util/ensure-node-position.ts
@@ -1,4 +1,4 @@
-import type { Flow, Positions } from "./types";
+import type { Flow, Positions } from './types';
 
 export const ensureNodePosition = (
   model: Flow.Model,
@@ -40,7 +40,15 @@ export const ensureNodePosition = (
       };
       return true;
     } else {
-      console.warn("WARNING: could not auto-calculate position for ", node.id);
+      // Only warn if positions map has data but we still couldn't find a parent
+      // Empty positions on initial render is expected before layout runs
+      const hasPositions = Object.keys(positions).length > 0;
+      if (hasPositions) {
+        console.warn(
+          'WARNING: could not auto-calculate position for ',
+          node.id
+        );
+      }
       node.position = { x: 0, y: 0 };
     }
   }
diff --git a/assets/test/collaborative-editor/components/diagram/MiniHistory.test.tsx b/assets/test/collaborative-editor/components/diagram/MiniHistory.test.tsx
index d3d9fd8d07..79826bcde1 100644
--- a/assets/test/collaborative-editor/components/diagram/MiniHistory.test.tsx
+++ b/assets/test/collaborative-editor/components/diagram/MiniHistory.test.tsx
@@ -40,9 +40,31 @@ vi.mock('../../../../js/hooks', () => ({
   relativeLocale: {},
 }));
 
+// Mock session context hooks to provide project ID
+vi.mock('../../../../js/collaborative-editor/hooks/useSessionContext', () => ({
+  useProject: () => ({
+    id: 'test-project-id',
+    name: 'Test Project',
+  }),
+}));
+
+// Mock workflow hooks to provide workflow ID
+vi.mock('../../../../js/collaborative-editor/hooks/useWorkflow', () => ({
+  useWorkflowState: (selector: any) => {
+    const state = {
+      workflow: {
+        id: 'test-workflow-id',
+        name: 'Test Workflow',
+      },
+    };
+    return typeof selector === 'function' ? selector(state) : state;
+  },
+}));
+
 // Mock window.location for navigation tests
 const mockLocationAssign = vi.fn();
 const mockLocation = {
+  origin: 'http://localhost',
   href: 'http://localhost/projects/test-project-id/w/test-workflow-id',
   pathname: '/projects/test-project-id/w/test-workflow-id',
   assign: mockLocationAssign,
@@ -56,6 +78,7 @@ Object.defineProperty(window, 'location', {
 describe('MiniHistory', () => {
   beforeEach(() => {
     // Reset location and mock before each test
+    mockLocation.origin = 'http://localhost';
     mockLocation.href =
       'http://localhost/projects/test-project-id/w/test-workflow-id';
     mockLocation.pathname = '/projects/test-project-id/w/test-workflow-id';
@@ -630,7 +653,10 @@ describe('MiniHistory', () => {
       expect(mockLocationAssign).toHaveBeenCalledOnce();
       const calledUrl = mockLocationAssign.mock.calls[0][0];
       expect(calledUrl).toContain('/history');
-      expect(calledUrl).toContain('filters[workflow_id]=test-workflow-id');
+      // URLSearchParams encodes square brackets, so we need to decode or check the encoded version
+      expect(decodeURIComponent(calledUrl)).toContain(
+        'filters[workflow_id]=test-workflow-id'
+      );
     });
 
     test('view history button supports keyboard navigation', () => {
@@ -677,7 +703,8 @@ describe('MiniHistory', () => {
       expect(mockLocationAssign).toHaveBeenCalledOnce();
       const calledUrl = mockLocationAssign.mock.calls[0][0];
       expect(calledUrl).toContain('/projects/test-project-id/history');
-      expect(calledUrl).toContain(
+      // URLSearchParams encodes square brackets, so we need to decode or check the encoded version
+      expect(decodeURIComponent(calledUrl)).toContain(
         'filters[workorder_id]=e2107d46-cf29-4930-b11b-cbcfcf83549d'
       );
     });
diff --git a/assets/test/collaborative-editor/hooks/useVersionMismatch.test.tsx b/assets/test/collaborative-editor/hooks/useVersionMismatch.test.tsx
new file mode 100644
index 0000000000..6bb1aecafa
--- /dev/null
+++ b/assets/test/collaborative-editor/hooks/useVersionMismatch.test.tsx
@@ -0,0 +1,211 @@
+/**
+ * useVersionMismatch Hook Tests
+ *
+ * Tests the logic for detecting when a user is viewing the latest workflow
+ * but a selected run was executed on an older version.
+ */
+
+import { renderHook } from '@testing-library/react';
+import { describe, expect, test, vi } from 'vitest';
+
+import { useVersionMismatch } from '../../../js/collaborative-editor/hooks/useVersionMismatch';
+
+// Mock the dependency hooks
+vi.mock('../../../js/collaborative-editor/hooks/useHistory', () => ({
+  useHistory: vi.fn(),
+}));
+
+vi.mock('../../../js/collaborative-editor/hooks/useSessionContext', () => ({
+  useLatestSnapshotLockVersion: vi.fn(),
+}));
+
+vi.mock('../../../js/collaborative-editor/hooks/useWorkflow', () => ({
+  useWorkflowState: vi.fn(),
+}));
+
+import { useHistory } from '../../../js/collaborative-editor/hooks/useHistory';
+import { useLatestSnapshotLockVersion } from '../../../js/collaborative-editor/hooks/useSessionContext';
+import { useWorkflowState } from '../../../js/collaborative-editor/hooks/useWorkflow';
+
+describe('useVersionMismatch', () => {
+  test('returns mismatch when viewing latest and run used older version', () => {
+    // Arrange
+    const mockWorkflow = { id: 'wf-1', lock_version: 28 };
+    const mockHistory = [
+      {
+        id: 'wo-1',
+        version: 22, // Run executed on v22
+        runs: [{ id: 'run-1', state: 'success' }],
+      },
+    ];
+
+    vi.mocked(useWorkflowState).mockReturnValue(mockWorkflow);
+    vi.mocked(useLatestSnapshotLockVersion).mockReturnValue(28);
+    vi.mocked(useHistory).mockReturnValue(mockHistory);
+
+    // Act
+    const { result } = renderHook(() => useVersionMismatch('run-1'));
+
+    // Assert
+    expect(result.current).toEqual({
+      runVersion: 22,
+      currentVersion: 28,
+    });
+  });
+
+  test('returns null when viewing snapshot that matches run version', () => {
+    // Arrange: Viewing v22 snapshot, run also v22
+    const mockWorkflow = { id: 'wf-1', lock_version: 22 };
+    const mockHistory = [
+      {
+        id: 'wo-1',
+        version: 22,
+        runs: [{ id: 'run-1', state: 'success' }],
+      },
+    ];
+
+    vi.mocked(useWorkflowState).mockReturnValue(mockWorkflow);
+    vi.mocked(useLatestSnapshotLockVersion).mockReturnValue(28); // Latest is v28
+    vi.mocked(useHistory).mockReturnValue(mockHistory);
+
+    // Act
+    const { result } = renderHook(() => useVersionMismatch('run-1'));
+
+    // Assert: No mismatch because viewing v22 snapshot (not latest)
+    expect(result.current).toBeNull();
+  });
+
+  test('returns null when no run is selected', () => {
+    // Arrange
+    const mockWorkflow = { id: 'wf-1', lock_version: 28 };
+    const mockHistory = [
+      {
+        id: 'wo-1',
+        version: 22,
+        runs: [{ id: 'run-1', state: 'success' }],
+      },
+    ];
+
+    vi.mocked(useWorkflowState).mockReturnValue(mockWorkflow);
+    vi.mocked(useLatestSnapshotLockVersion).mockReturnValue(28);
+    vi.mocked(useHistory).mockReturnValue(mockHistory);
+
+    // Act: No run selected
+    const { result } = renderHook(() => useVersionMismatch(null));
+
+    // Assert
+    expect(result.current).toBeNull();
+  });
+
+  test('returns null when workflow is null', () => {
+    // Arrange
+    const mockHistory = [
+      {
+        id: 'wo-1',
+        version: 22,
+        runs: [{ id: 'run-1', state: 'success' }],
+      },
+    ];
+
+    vi.mocked(useWorkflowState).mockReturnValue(null);
+    vi.mocked(useLatestSnapshotLockVersion).mockReturnValue(28);
+    vi.mocked(useHistory).mockReturnValue(mockHistory);
+
+    // Act
+    const { result } = renderHook(() => useVersionMismatch('run-1'));
+
+    // Assert
+    expect(result.current).toBeNull();
+  });
+
+  test('returns null when latest snapshot version is null', () => {
+    // Arrange
+    const mockWorkflow = { id: 'wf-1', lock_version: 28 };
+    const mockHistory = [
+      {
+        id: 'wo-1',
+        version: 22,
+        runs: [{ id: 'run-1', state: 'success' }],
+      },
+    ];
+
+    vi.mocked(useWorkflowState).mockReturnValue(mockWorkflow);
+    vi.mocked(useLatestSnapshotLockVersion).mockReturnValue(null);
+    vi.mocked(useHistory).mockReturnValue(mockHistory);
+
+    // Act
+    const { result } = renderHook(() => useVersionMismatch('run-1'));
+
+    // Assert
+    expect(result.current).toBeNull();
+  });
+
+  test('returns null when selected run is not found in history', () => {
+    // Arrange
+    const mockWorkflow = { id: 'wf-1', lock_version: 28 };
+    const mockHistory = [
+      {
+        id: 'wo-1',
+        version: 22,
+        runs: [{ id: 'run-1', state: 'success' }],
+      },
+    ];
+
+    vi.mocked(useWorkflowState).mockReturnValue(mockWorkflow);
+    vi.mocked(useLatestSnapshotLockVersion).mockReturnValue(28);
+    vi.mocked(useHistory).mockReturnValue(mockHistory);
+
+    // Act: Looking for non-existent run
+    const { result } = renderHook(() => useVersionMismatch('run-999'));
+
+    // Assert
+    expect(result.current).toBeNull();
+  });
+
+  test('returns mismatch when versions differ even by small amount', () => {
+    // Arrange: v29 vs v30 (still a mismatch)
+    const mockWorkflow = { id: 'wf-1', lock_version: 30 };
+    const mockHistory = [
+      {
+        id: 'wo-1',
+        version: 29,
+        runs: [{ id: 'run-1', state: 'success' }],
+      },
+    ];
+
+    vi.mocked(useWorkflowState).mockReturnValue(mockWorkflow);
+    vi.mocked(useLatestSnapshotLockVersion).mockReturnValue(30);
+    vi.mocked(useHistory).mockReturnValue(mockHistory);
+
+    // Act
+    const { result } = renderHook(() => useVersionMismatch('run-1'));
+
+    // Assert
+    expect(result.current).toEqual({
+      runVersion: 29,
+      currentVersion: 30,
+    });
+  });
+
+  test('returns null when viewing latest and run also used latest version', () => {
+    // Arrange: Both at v28
+    const mockWorkflow = { id: 'wf-1', lock_version: 28 };
+    const mockHistory = [
+      {
+        id: 'wo-1',
+        version: 28, // Same version
+        runs: [{ id: 'run-1', state: 'success' }],
+      },
+    ];
+
+    vi.mocked(useWorkflowState).mockReturnValue(mockWorkflow);
+    vi.mocked(useLatestSnapshotLockVersion).mockReturnValue(28);
+    vi.mocked(useHistory).mockReturnValue(mockHistory);
+
+    // Act
+    const { result } = renderHook(() => useVersionMismatch('run-1'));
+
+    // Assert: No mismatch when versions match
+    expect(result.current).toBeNull();
+  });
+});
diff --git a/assets/test/collaborative-editor/utils/navigation.test.ts b/assets/test/collaborative-editor/utils/navigation.test.ts
new file mode 100644
index 0000000000..b56c875d11
--- /dev/null
+++ b/assets/test/collaborative-editor/utils/navigation.test.ts
@@ -0,0 +1,198 @@
+/**
+ * Tests for navigation utilities
+ *
+ * These utilities provide clean, testable navigation functions that build URLs
+ * from IDs rather than parsing existing URLs.
+ */
+
+import { describe, expect, test, vi, beforeEach, afterEach } from 'vitest';
+
+import {
+  navigateToRun,
+  navigateToWorkOrderHistory,
+  navigateToWorkflowHistory,
+} from '../../../js/collaborative-editor/utils/navigation';
+
+describe('navigation utilities', () => {
+  // Save original window.location
+  const originalLocation = window.location;
+
+  beforeEach(() => {
+    // Mock window.location
+    delete (window as any).location;
+    window.location = {
+      ...originalLocation,
+      origin: 'https://example.com',
+      assign: vi.fn(),
+    } as any;
+  });
+
+  afterEach(() => {
+    // Restore original window.location
+    window.location = originalLocation;
+    vi.restoreAllMocks();
+  });
+
+  describe('navigateToWorkflowHistory', () => {
+    test('builds correct URL with project and workflow IDs', () => {
+      const projectId = 'proj-123';
+      const workflowId = 'wf-456';
+
+      navigateToWorkflowHistory(projectId, workflowId);
+
+      expect(window.location.assign).toHaveBeenCalledWith(
+        'https://example.com/projects/proj-123/history?filters%5Bworkflow_id%5D=wf-456'
+      );
+    });
+
+    test('uses URLSearchParams for query string encoding', () => {
+      const projectId = 'proj-123';
+      const workflowId = 'wf-with-special-chars-&-=';
+
+      navigateToWorkflowHistory(projectId, workflowId);
+
+      const assignCall = vi.mocked(window.location.assign).mock.calls[0][0];
+      const url = new URL(assignCall);
+
+      // Verify URLSearchParams encoded the special characters
+      expect(url.searchParams.get('filters[workflow_id]')).toBe(
+        'wf-with-special-chars-&-='
+      );
+    });
+
+    test('constructs clean pathname from origin', () => {
+      const projectId = 'proj-123';
+      const workflowId = 'wf-456';
+
+      navigateToWorkflowHistory(projectId, workflowId);
+
+      const assignCall = vi.mocked(window.location.assign).mock.calls[0][0];
+      const url = new URL(assignCall);
+
+      expect(url.origin).toBe('https://example.com');
+      expect(url.pathname).toBe('/projects/proj-123/history');
+    });
+  });
+
+  describe('navigateToWorkOrderHistory', () => {
+    test('builds correct URL with project and work order IDs', () => {
+      const projectId = 'proj-abc';
+      const workOrderId = 'wo-xyz';
+
+      navigateToWorkOrderHistory(projectId, workOrderId);
+
+      expect(window.location.assign).toHaveBeenCalledWith(
+        'https://example.com/projects/proj-abc/history?filters%5Bworkorder_id%5D=wo-xyz'
+      );
+    });
+
+    test('uses correct filter parameter name', () => {
+      const projectId = 'proj-123';
+      const workOrderId = 'wo-456';
+
+      navigateToWorkOrderHistory(projectId, workOrderId);
+
+      const assignCall = vi.mocked(window.location.assign).mock.calls[0][0];
+      const url = new URL(assignCall);
+
+      // Should use 'workorder_id' not 'workflow_id'
+      expect(url.searchParams.get('filters[workorder_id]')).toBe('wo-456');
+      expect(url.searchParams.has('filters[workflow_id]')).toBe(false);
+    });
+
+    test('handles UUID format correctly', () => {
+      const projectId = '550e8400-e29b-41d4-a716-446655440000';
+      const workOrderId = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+
+      navigateToWorkOrderHistory(projectId, workOrderId);
+
+      const assignCall = vi.mocked(window.location.assign).mock.calls[0][0];
+      const url = new URL(assignCall);
+
+      expect(url.pathname).toBe(
+        '/projects/550e8400-e29b-41d4-a716-446655440000/history'
+      );
+      expect(url.searchParams.get('filters[workorder_id]')).toBe(
+        '6ba7b810-9dad-11d1-80b4-00c04fd430c8'
+      );
+    });
+  });
+
+  describe('navigateToRun', () => {
+    test('builds correct URL with project and run IDs', () => {
+      const projectId = 'proj-123';
+      const runId = 'run-789';
+
+      navigateToRun(projectId, runId);
+
+      expect(window.location.assign).toHaveBeenCalledWith(
+        'https://example.com/projects/proj-123/runs/run-789'
+      );
+    });
+
+    test('does not include query parameters', () => {
+      const projectId = 'proj-123';
+      const runId = 'run-456';
+
+      navigateToRun(projectId, runId);
+
+      const assignCall = vi.mocked(window.location.assign).mock.calls[0][0];
+      const url = new URL(assignCall);
+
+      expect(url.search).toBe('');
+      expect(url.pathname).toBe('/projects/proj-123/runs/run-456');
+    });
+
+    test('constructs pathname correctly', () => {
+      const projectId = 'proj-abc';
+      const runId = 'run-xyz';
+
+      navigateToRun(projectId, runId);
+
+      const assignCall = vi.mocked(window.location.assign).mock.calls[0][0];
+      const url = new URL(assignCall);
+
+      // Should be /projects/:projectId/runs/:runId
+      expect(url.pathname).toBe('/projects/proj-abc/runs/run-xyz');
+    });
+
+    test('handles UUID format correctly', () => {
+      const projectId = '550e8400-e29b-41d4-a716-446655440000';
+      const runId = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+
+      navigateToRun(projectId, runId);
+
+      const assignCall = vi.mocked(window.location.assign).mock.calls[0][0];
+
+      expect(assignCall).toBe(
+        'https://example.com/projects/550e8400-e29b-41d4-a716-446655440000/runs/6ba7b810-9dad-11d1-80b4-00c04fd430c8'
+      );
+    });
+  });
+
+  describe('integration scenarios', () => {
+    test('all functions use window.location.assign for navigation', () => {
+      navigateToWorkflowHistory('p1', 'w1');
+      navigateToWorkOrderHistory('p1', 'wo1');
+      navigateToRun('p1', 'r1');
+
+      expect(window.location.assign).toHaveBeenCalledTimes(3);
+    });
+
+    test('all functions build absolute URLs', () => {
+      navigateToWorkflowHistory('p1', 'w1');
+      const call1 = vi.mocked(window.location.assign).mock.calls[0][0];
+
+      navigateToWorkOrderHistory('p1', 'wo1');
+      const call2 = vi.mocked(window.location.assign).mock.calls[1][0];
+
+      navigateToRun('p1', 'r1');
+      const call3 = vi.mocked(window.location.assign).mock.calls[2][0];
+
+      // All should start with the origin
+      expect(call1).toMatch(/^https:\/\/example\.com\//);
+      expect(call2).toMatch(/^https:\/\/example\.com\//);
+      expect(call3).toMatch(/^https:\/\/example\.com\//);
+    });
+  });
+});
diff --git a/lib/lightning_web/live/run_live/components.ex b/lib/lightning_web/live/run_live/components.ex
index 99484a90b3..ea9e8334fe 100644
--- a/lib/lightning_web/live/run_live/components.ex
+++ b/lib/lightning_web/live/run_live/components.ex
@@ -757,10 +757,13 @@ defmodule LightningWeb.RunLive.Components do
   defp humanize_workflow(filter, workflows) do
     case filter do
       %{workflow_id: workflow_id} ->
-        {workflow, _id} =
-          Enum.find(workflows, fn {_name, id} -> id == workflow_id end)
+        case Enum.find(workflows, fn {_name, id} -> id == workflow_id end) do
+          {workflow, _id} ->
+            "for #{workflow} workflow"
 
-        "for #{workflow} workflow"
+          nil ->
+            ""
+        end
 
       _other ->
         ""
diff --git a/test/lightning_web/live/run_live/components_test.exs b/test/lightning_web/live/run_live/components_test.exs
index b5a41b686c..f3dcd4c16b 100644
--- a/test/lightning_web/live/run_live/components_test.exs
+++ b/test/lightning_web/live/run_live/components_test.exs
@@ -621,4 +621,32 @@ defmodule LightningWeb.RunLive.ComponentsTest do
     )
     |> Enum.any?()
   end
+
+  describe "bulk_rerun_modal/1" do
+    test "handles missing workflow in humanize_search_params" do
+      workflow = insert(:simple_workflow)
+      workflows = [{"Test Workflow", workflow.id}]
+
+      filters = %Lightning.WorkOrders.SearchParams{
+        workflow_id: Ecto.UUID.generate()
+      }
+
+      html =
+        render_component(&Components.bulk_rerun_modal/1,
+          id: "bulk-rerun-modal",
+          show: true,
+          all_selected?: true,
+          selected_count: 5,
+          page_number: 1,
+          pages: 2,
+          total_entries: 10,
+          filters: filters,
+          workflows: workflows
+        )
+
+      assert html =~ "Run Selected Work Orders"
+      assert html =~ "You've selected all 5 work orders"
+      refute html =~ "for #{workflow.name} workflow"
+    end
+  end
 end