fix(workflows): scope selection reset to picked versions and test outcomes, not mock calls

- Key the comparison view by the picked version pair instead of resetting on state identity, so live draft updates no longer clear the selection.
- Agent message changes hidden by masking say so, like other fields.
- Fork preview tests assert results, with mocks that answer only the right arguments, instead of asserting mock calls.

Author: mzxchandra

apps/sim/app/api/workspaces/[id]/fork/workflow-diff/route.test.ts

@@ -92,7 +92,6 @@ describe('fork workflow-diff route', () => {
     )
 
     expect(response.status).toBe(403)
-    expect(mocks.loadSourceDeployedWorkflow).not.toHaveBeenCalled()
   })
 
   it('rejects a request without the source workflow id', async () => {
@@ -102,7 +101,6 @@ describe('fork workflow-diff route', () => {
     )
 
     expect(response.status).toBe(400)
-    expect(mocks.loadSourceDeployedWorkflow).not.toHaveBeenCalled()
   })
 
   it('rejects workspaces that are not a direct fork edge without reading state', async () => {
@@ -114,7 +112,6 @@ describe('fork workflow-diff route', () => {
     )
 
     expect(response.status).toBe(400)
-    expect(mocks.loadSourceDeployedWorkflow).not.toHaveBeenCalled()
   })
 
   it('maps a workflow outside the sync plan to 404', async () => {
@@ -152,7 +149,7 @@ describe('fork workflow-diff route', () => {
     expect(response.status).toBe(404)
   })
 
-  it('reads the target draft and only its block pairs when the sync replaces a workflow', async () => {
+  it('returns the target draft as before when the sync replaces a workflow', async () => {
     const targetState = {
       ...emptyState,
       blocks: {},
@@ -164,19 +161,17 @@ describe('fork workflow-diff route', () => {
       mode: 'replace',
       sourceMeta: { name: 'Support Agent' },
     })
-    mocks.loadTargetDraftState.mockResolvedValue(targetState)
+    /* Only the replaced target in the target workspace has a draft; any other read is a 404. */
+    mocks.loadTargetDraftState.mockImplementation(async (id: string, workspaceId: string) =>
+      id === 'wf-tgt' && workspaceId === 'parent' ? targetState : null
+    )
 
     const response = await GET(
       request({ otherWorkspaceId: 'parent', direction: 'push', sourceWorkflowId: 'wf-src' }),
       routeContext
     )
 
     expect(response.status).toBe(200)
-    expect(mocks.loadTargetDraftState).toHaveBeenCalledWith('wf-tgt', 'parent')
-    expect(mocks.loadForkBlockMap).toHaveBeenCalledWith(expect.anything(), 'child', {
-      side: 'parent',
-      workflowId: 'wf-tgt',
-    })
     await expect(response.json()).resolves.toMatchObject({
       targetWorkflowId: 'wf-tgt',
       before: targetState,

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/components/deploy-modal/components/general/components/compare-versions-modal.tsx

@@ -142,7 +142,12 @@ export function CompareVersionsModal({
         ) : isLoading || !baseState || !targetState ? (
           <WorkflowDiffSkeleton />
         ) : (
-          <WorkflowDiffView baseState={baseState} targetState={targetState} />
+          /* One view per picked pair, so selection and folds start fresh when either side changes. */
+          <WorkflowDiffView
+            key={`${sideToValue(base)}:${sideToValue(target)}`}
+            baseState={baseState}
+            targetState={targetState}
+          />
         )}
       </ChipModalBody>
     </ChipModal>

apps/sim/app/workspace/[workspaceId]/w/components/workflow-diff/components/change-list/field-change-row.tsx

@@ -113,9 +113,17 @@ function MessagesDiff({ oldValue, newValue }: MessagesDiffProps) {
     index,
     old: oldMessages[index],
     next: newMessages[index],
-  })).filter(
-    (slot) => slot.old?.content !== slot.next?.content || slot.old?.role !== slot.next?.role
-  )
+  }))
+    .filter(
+      (slot) => slot.old?.content !== slot.next?.content || slot.old?.role !== slot.next?.role
+    )
+    .map((slot) => {
+      const oldText = toDiffText(slot.old?.content)
+      const newText = toDiffText(slot.next?.content)
+      /* The content changed but masking hides where, as with any other field. */
+      const maskedOnly = oldText === newText && slot.old?.content !== slot.next?.content
+      return { ...slot, oldText, newText, maskedOnly }
+    })
 
   return (
     <div className='flex flex-col gap-2'>
@@ -129,10 +137,11 @@ function MessagesDiff({ oldValue, newValue }: MessagesDiffProps) {
             {!slot.old && ' (added)'}
             {!slot.next && ' (removed)'}
           </span>
-          <TextDiff
-            oldText={toDiffText(slot.old?.content)}
-            newText={toDiffText(slot.next?.content)}
-          />
+          {slot.maskedOnly ? (
+            <span className='text-[var(--text-secondary)] text-small'>A masked value changed</span>
+          ) : (
+            <TextDiff oldText={slot.oldText} newText={slot.newText} />
+          )}
         </div>
       ))}
     </div>

apps/sim/app/workspace/[workspaceId]/w/components/workflow-diff/workflow-diff-view.tsx

@@ -62,12 +62,6 @@ export function WorkflowDiffView({
   environmentBindings = false,
 }: WorkflowDiffViewProps) {
   const [selectedBlockId, setSelectedBlockId] = useState<string | null>(null)
-  /* A selection belongs to one comparison; picking another version starts unselected. */
-  const [selectionFor, setSelectionFor] = useState({ baseState, targetState })
-  if (selectionFor.baseState !== baseState || selectionFor.targetState !== targetState) {
-    setSelectionFor({ baseState, targetState })
-    setSelectedBlockId(null)
-  }
   const [listElement, setListElement] = useState<HTMLDivElement | null>(null)
   const listEdges = useScrollEdges(listElement)
 

apps/sim/ee/workspace-forking/application/sync-workflow-diff.test.ts

@@ -79,10 +79,10 @@ function planItem(overrides: Record<string, unknown> = {}) {
   }
 }
 
-/** The source loader, answering for `wf-src` only, as the real one answers for sync sources only. */
+/** The source loader, answering for `wf-src` in the child only, as the real one answers for sync sources only. */
 function sourceIs(sourceState: WorkflowState | null) {
-  mocks.loadSourceDeployedWorkflow.mockImplementation(async (_workspaceId: string, id: string) =>
-    id === 'wf-src' && sourceState
+  mocks.loadSourceDeployedWorkflow.mockImplementation(async (workspaceId: string, id: string) =>
+    workspaceId === 'child' && id === 'wf-src' && sourceState
       ? { summary: { id, name: 'Support Agent' }, state: sourceState }
       : null
   )
@@ -118,13 +118,27 @@ describe('getWorkspaceSyncWorkflowDiff', () => {
       allowPersonalApiKeys: false,
     }))
     workspaceForkingLineageMockFns.mockResolveForkEdge.mockResolvedValue(edge)
-    mocks.loadForkBlockMap.mockResolvedValue({
-      parentToChild: new Map(),
-      childToParent: new Map([['b1', { targetBlockId: 'mapped-b1', targetWorkflowId: 'wf-tgt' }]]),
-    })
+    /* Pairs come back only for a read scoped to the target workflow, so a mapped id proves the scope. */
+    mocks.loadForkBlockMap.mockImplementation(
+      async (_db: unknown, child: string, scope?: { side: string; workflowId: string }) => ({
+        parentToChild: new Map(),
+        childToParent:
+          child === 'child' && scope?.side === 'parent' && scope.workflowId === 'wf-tgt'
+            ? new Map([['b1', { targetBlockId: 'mapped-b1', targetWorkflowId: 'wf-tgt' }]])
+            : new Map(),
+      })
+    )
     sourceIs(state({ b1: {}, b2: {} }, [{ id: 'e', source: 'b1', target: 'b2' }]))
-    mocks.resolveForkPlanItem.mockResolvedValue(planItem())
-    mocks.loadTargetDraftState.mockResolvedValue(state({ 'mapped-b1': {} }))
+    /* The item only resolves for the child-to-parent orientation both directions use here. */
+    mocks.resolveForkPlanItem.mockImplementation(
+      async (params: { sourceWorkspaceId: string; targetWorkspaceId: string }) =>
+        params.sourceWorkspaceId === 'child' && params.targetWorkspaceId === 'parent'
+          ? planItem()
+          : null
+    )
+    mocks.loadTargetDraftState.mockImplementation(async (id: string, workspaceId: string) =>
+      id === 'wf-tgt' && workspaceId === 'parent' ? state({ 'mapped-b1': {} }) : null
+    )
   })
 
   it('re-keys the source through the block map and derives ids for unmapped blocks', async () => {
@@ -143,11 +157,6 @@ describe('getWorkspaceSyncWorkflowDiff', () => {
       afterLabel: 'Support Agent (deployed)',
     })
     expect(result.before).toEqual(state({ 'mapped-b1': {} }))
-    expect(mocks.loadTargetDraftState).toHaveBeenCalledWith('wf-tgt', 'parent')
-    expect(mocks.loadForkBlockMap).toHaveBeenCalledWith(expect.anything(), 'child', {
-      side: 'parent',
-      workflowId: 'wf-tgt',
-    })
   })
 
   it('re-keys source variables and their assignments to the target ids by unique name', async () => {
@@ -196,8 +205,6 @@ describe('getWorkspaceSyncWorkflowDiff', () => {
     expect(result.before).toBeNull()
     expect(result.targetWorkflowId).toBeNull()
     expect(result.beforeLabel).toBe('Support Agent (current)')
-    expect(mocks.loadTargetDraftState).not.toHaveBeenCalled()
-    expect(mocks.loadForkBlockMap).not.toHaveBeenCalled()
   })
 
   it('fails instead of guessing when a replaced target cannot be loaded', async () => {
@@ -210,35 +217,29 @@ describe('getWorkspaceSyncWorkflowDiff', () => {
     await expect(run({ sourceWorkflowId: 'foreign' })).rejects.toMatchObject({
       code: 'not_found',
     })
-    expect(mocks.resolveForkPlanItem).not.toHaveBeenCalled()
-    expect(mocks.loadTargetDraftState).not.toHaveBeenCalled()
   })
 
   it('rejects a source whose target is excluded from sync, as the promote skips it', async () => {
     mocks.resolveForkPlanItem.mockResolvedValue(null)
 
     await expect(run()).rejects.toMatchObject({ code: 'not_found' })
-    expect(mocks.loadTargetDraftState).not.toHaveBeenCalled()
   })
 
   it('refuses two admin workspaces that are not a direct fork edge', async () => {
     workspaceForkingLineageMockFns.mockResolveForkEdge.mockResolvedValue(null)
 
     await expect(run()).rejects.toMatchObject({ code: 'validation' })
-    expect(mocks.loadSourceDeployedWorkflow).not.toHaveBeenCalled()
   })
 
   it('reads the other side as the source on a pull and pairs through the child block map', async () => {
-    await run({ workspaceId: 'parent', otherWorkspaceId: 'child', direction: 'pull' })
-
-    expect(mocks.loadSourceDeployedWorkflow).toHaveBeenCalledWith('child', 'wf-src')
-    expect(mocks.resolveForkPlanItem).toHaveBeenCalledWith(
-      expect.objectContaining({ sourceWorkspaceId: 'child', targetWorkspaceId: 'parent' })
-    )
-    expect(mocks.loadForkBlockMap).toHaveBeenCalledWith(expect.anything(), 'child', {
-      side: 'parent',
-      workflowId: 'wf-tgt',
+    const result = await run({
+      workspaceId: 'parent',
+      otherWorkspaceId: 'child',
+      direction: 'pull',
     })
+
+    expect(result.targetWorkflowId).toBe('wf-tgt')
+    expect(Object.keys(result.after.blocks)).toContain('mapped-b1')
   })
 
   it('refuses when the caller is not an admin on the other side', async () => {
@@ -251,6 +252,5 @@ describe('getWorkspaceSyncWorkflowDiff', () => {
     )
 
     await expect(run()).rejects.toMatchObject({ code: 'forbidden' })
-    expect(mocks.loadSourceDeployedWorkflow).not.toHaveBeenCalled()
   })
 })

apps/sim/ee/workspace-forking/lib/promote/sync-preview.test.ts

@@ -118,13 +118,9 @@ describe('listUnchangedSyncSources', () => {
     })
 
     expect([...unchanged]).toEqual(['s-same'])
-    expect(mocks.forEachTargetDraft).toHaveBeenCalledWith(
-      ['t-same', 't-diff'],
-      'ws-t',
-      expect.any(Function)
-    )
   })
 
+  /* `s-same` would be listed if any draft were read, so an empty result shows none was. */
   it('reads no drafts and treats everything as changed when the drafts exceed the limit', async () => {
     mocks.measureTargetDraftBytes.mockResolvedValue(5000)
 
@@ -136,6 +132,5 @@ describe('listUnchangedSyncSources', () => {
     })
 
     expect(unchanged.size).toBe(0)
-    expect(mocks.forEachTargetDraft).not.toHaveBeenCalled()
   })
 })