@@ -4,6 +4,7 @@
 import { describe, expect, it } from 'vitest'
 import type { ForkDependentReconfig } from '@/lib/api/contracts/workspace-fork'
 import {
+  applyDependentRepick,
   dependentKey,
   effectiveCopyDependentValue,
   effectiveDependentValue,
@@ -100,6 +101,74 @@ describe('effectiveCopyDependentValue', () => {
   })
 })
 
+describe('applyDependentRepick', () => {
+  it('clears direct and transitive descendants without touching unrelated fields', () => {
+    const site = field({
+      subBlockKey: 'siteId',
+      currentValue: 'site-old',
+      providesContextKey: 'siteId',
+    })
+    const drive = field({
+      subBlockKey: 'driveId',
+      currentValue: 'drive-old',
+      providesContextKey: 'driveId',
+      consumesContextKeys: ['siteId'],
+    })
+    const spreadsheet = field({
+      subBlockKey: 'spreadsheetId',
+      currentValue: 'spreadsheet-old',
+      providesContextKey: 'spreadsheetId',
+      consumesContextKeys: ['driveId'],
+    })
+    const sheet = field({
+      subBlockKey: 'sheetName',
+      currentValue: 'Sheet1',
+      consumesContextKeys: ['spreadsheetId'],
+    })
+    const unrelated = field({ subBlockKey: 'label', currentValue: 'keep-me' })
+    const previous = {
+      [dependentKey(drive)]: 'drive-repicked',
+      [dependentKey(spreadsheet)]: 'spreadsheet-repicked',
+      [dependentKey(sheet)]: 'Sheet2',
+      [dependentKey(unrelated)]: 'still-keep-me',
+    }
+
+    const next = applyDependentRepick(
+      previous,
+      site,
+      [site, drive, spreadsheet, sheet, unrelated],
+      'site-new'
+    )
+
+    expect(next).toEqual({
+      [dependentKey(site)]: 'site-new',
+      [dependentKey(drive)]: '',
+      [dependentKey(spreadsheet)]: '',
+      [dependentKey(sheet)]: '',
+      [dependentKey(unrelated)]: 'still-keep-me',
+    })
+    expect(effectiveDependentValue(drive, next, false)).toBe('')
+    expect(effectiveCopyDependentValue(sheet, next)).toBe('')
+  })
+
+  it('only changes the selected field when it provides no selector context', () => {
+    const leaf = field({ subBlockKey: 'issueKey', currentValue: 'ISSUE-1' })
+    const unrelated = field({ subBlockKey: 'label', currentValue: 'keep-me' })
+
+    expect(
+      applyDependentRepick(
+        { [dependentKey(unrelated)]: 'still-keep-me' },
+        leaf,
+        [leaf, unrelated],
+        'ISSUE-2'
+      )
+    ).toEqual({
+      [dependentKey(leaf)]: 'ISSUE-2',
+      [dependentKey(unrelated)]: 'still-keep-me',
+    })
+  })
+})
+
 describe('isDependentConfigurationActionable', () => {
   it('hides stored values when the mapped parent is unchanged', () => {
     expect(
 
@@ -5,6 +5,40 @@ export function dependentKey(dependent: ForkDependentReconfig): string {
   return `${dependent.targetWorkflowId}:${dependent.targetBlockId}:${dependent.subBlockKey}`
 }
 
+/**
+ * Store a dependent re-pick and clear every selector transitively scoped by it. Empty-string
+ * overrides are intentional: an absent override means "fall back to the stored value", while a
+ * changed provider makes every stored descendant stale for both mapped and copied parents.
+ */
+export function applyDependentRepick(
+  reconfig: Record<string, string>,
+  changedField: ForkDependentReconfig,
+  blockFields: ForkDependentReconfig[],
+  value: string
+): Record<string, string> {
+  const changedKey = dependentKey(changedField)
+  const nextState = { ...reconfig, [changedKey]: value }
+  if (!changedField.providesContextKey) return nextState
+
+  const pendingContextKeys = [changedField.providesContextKey]
+  const visitedFields = new Set([changedKey])
+  for (let index = 0; index < pendingContextKeys.length; index += 1) {
+    const contextKey = pendingContextKeys[index]
+    if (!contextKey) continue
+
+    for (const field of blockFields) {
+      const fieldKey = dependentKey(field)
+      if (visitedFields.has(fieldKey) || !field.consumesContextKeys.includes(contextKey)) continue
+
+      visitedFields.add(fieldKey)
+      nextState[fieldKey] = ''
+      if (field.providesContextKey) pendingContextKeys.push(field.providesContextKey)
+    }
+  }
+
+  return nextState
+}
+
 /**
  * The value sent + displayed for a dependent: the user's in-session re-pick if present, else the
  * stored value (`currentValue`). Blank when the parent target changed in-session, since the old
 
@@ -34,6 +34,7 @@ import {
 import { forkRefKey } from '@/ee/workspace-forking/components/fork-sync/copy-reconciliation'
 import { DependentFieldSelector } from '@/ee/workspace-forking/components/fork-sync/dependent-field-selector'
 import {
+  applyDependentRepick,
   type DependentConfigurationState,
   dependentKey,
   effectiveCopyDependentValue,
@@ -162,28 +163,6 @@ function blockChainState(
   return { providedValues, providedContextKeys }
 }
 
-/** Store a re-pick and invalidate in-block children chained off the changed field. */
-function applyDependentRepick(
-  setReconfig: Dispatch<SetStateAction<Record<string, string>>>,
-  field: ForkDependentReconfig,
-  blockFields: ForkDependentReconfig[],
-  value: string
-) {
-  setReconfig((prev) => {
-    const nextState = { ...prev, [dependentKey(field)]: value }
-    // A changed parent invalidates its children's stale re-picks.
-    const providedKey = field.providesContextKey
-    if (providedKey) {
-      for (const sibling of blockFields) {
-        if (sibling.consumesContextKeys.includes(providedKey)) {
-          delete nextState[dependentKey(sibling)]
-        }
-      }
-    }
-    return nextState
-  })
-}
-
 interface DependentSelectorProps {
   field: ForkDependentReconfig
   block: DependentBlock
@@ -241,7 +220,9 @@ function DependentSelector({
       }}
       enabled={parentValue !== '' && ready}
       value={effectiveValue(field)}
-      onChange={(value) => applyDependentRepick(setReconfig, field, block.fields, value)}
+      onChange={(value) =>
+        setReconfig((current) => applyDependentRepick(current, field, block.fields, value))
+      }
       title={field.title}
     />
   )
 
@@ -20,10 +20,19 @@ const blockWith = (subBlocks: SubBlockConfig[]): BlockConfig =>
 
 const sourceState = (
   blockType: string,
-  subBlocks: Record<string, { value: unknown }>
+  subBlocks: Record<string, { value: unknown }>,
+  data?: Record<string, unknown>
 ): WorkflowState =>
   ({
-    blocks: { 'block-1': { id: 'block-1', type: blockType, name: 'Block', subBlocks } },
+    blocks: {
+      'block-1': {
+        id: 'block-1',
+        type: blockType,
+        name: 'Block',
+        subBlocks,
+        ...(data && { data }),
+      },
+    },
     edges: [],
     loops: {},
     parallels: {},
@@ -325,6 +334,67 @@ describe('collectForkDependentReconfigs', () => {
     expect(sheet?.context.spreadsheetId).toBe('ss-src')
   })
 
+  it('uses the persisted canonical mode when building a dependent selector context', () => {
+    vi.mocked(getBlock).mockReturnValue(
+      blockWith([
+        { id: 'credential', title: 'Credential', type: 'oauth-input' },
+        { id: 'domain', title: 'Domain', type: 'short-input' },
+        {
+          id: 'projectId',
+          title: 'Project',
+          type: 'project-selector',
+          canonicalParamId: 'projectId',
+          mode: 'basic',
+          selectorKey: 'jira.projects',
+          dependsOn: ['credential', 'domain'],
+        },
+        {
+          id: 'manualProjectId',
+          title: 'Project ID',
+          type: 'short-input',
+          canonicalParamId: 'projectId',
+          mode: 'advanced',
+          dependsOn: ['credential', 'domain'],
+        },
+        {
+          id: 'issueKey',
+          title: 'Issue',
+          type: 'file-selector',
+          selectorKey: 'jira.issues',
+          dependsOn: ['credential', 'domain', 'projectId'],
+          required: true,
+        },
+      ])
+    )
+    const states = new Map<string, WorkflowState>([
+      [
+        'wf-src',
+        sourceState(
+          'jira',
+          {
+            credential: { value: 'cred-src' },
+            domain: { value: 'example.atlassian.net' },
+            projectId: { value: 'project-basic-stale' },
+            manualProjectId: { value: 'project-advanced' },
+            issueKey: { value: 'ADV-1' },
+          },
+          { canonicalModes: { projectId: 'advanced' } }
+        ),
+      ],
+    ])
+
+    const result = collectForkDependentReconfigs([replaceItem], states, resolve)
+
+    expect(result).toHaveLength(1)
+    expect(result[0]).toMatchObject({
+      subBlockKey: 'issueKey',
+      context: {
+        domain: 'example.atlassian.net',
+        projectId: 'project-advanced',
+      },
+    })
+  })
+
   it('emits a credential-dependent selector nested inside a tool-input tool', () => {
     vi.mocked(getBlock).mockImplementation((type) => {
       if (type === 'agent') return blockWith([{ id: 'tools', title: 'Tools', type: 'tool-input' }])
 
@@ -109,7 +109,9 @@ function emitAnchoredDependents(params: EmitAnchoredParams): void {
     chaining,
     out,
   } = params
-  const fullContext = buildSelectorContextFromBlock(contextBlockType, contextSubBlocks)
+  const fullContext = buildSelectorContextFromBlock(contextBlockType, contextSubBlocks, {
+    canonicalModes,
+  })
   const canonicalIndex = buildCanonicalIndex(config.subBlocks)
   const gates = createCanonicalModeGates(config.subBlocks, values, canonicalModes)
   const configById = new Map(config.subBlocks.filter((cfg) => cfg.id).map((cfg) => [cfg.id, cfg]))