@@ -106,3 +106,45 @@ describe('parseFolderScope', () => {
     expect(isTableInFolderScope({ folderId: 'archive' }, FOLDERS, null)).toBe(true)
   })
 })
+
+/*
+ * The clearing rule the component applies when a scope change hides the current
+ * selection. Expressed here as the predicate the effect guards on, so the
+ * "don't clear a table that merely has not loaded" case is pinned.
+ */
+describe('a selection hidden by a scope change', () => {
+  const TABLES = [
+    { id: 'in-scope', folderId: 'q3' },
+    { id: 'out-of-scope', folderId: 'archive' },
+  ]
+
+  function shouldClear(tableId: string, scope: string): boolean {
+    const loaded = TABLES.some((t) => t.id === tableId)
+    if (!loaded) return false
+    const segments = parseFolderScope(scope)
+    return !TABLES.filter((t) => isTableInFolderScope(t, FOLDERS, segments)).some(
+      (t) => t.id === tableId
+    )
+  }
+
+  it('clears a loaded table the new scope excludes', () => {
+    expect(shouldClear('out-of-scope', '/Reports')).toBe(true)
+  })
+
+  it('keeps a table the scope still admits', () => {
+    expect(shouldClear('in-scope', '/Reports')).toBe(false)
+  })
+
+  it('keeps everything when the scope is cleared', () => {
+    expect(shouldClear('out-of-scope', '')).toBe(false)
+  })
+
+  it('never clears a table that is not in the loaded list', () => {
+    /* Still loading, or deleted - clearing there would destroy a valid config. */
+    expect(shouldClear('not-loaded', '/Reports')).toBe(false)
+  })
+
+  it('never clears on a scope that cannot be parsed', () => {
+    expect(shouldClear('out-of-scope', 'Reports')).toBe(false)
+  })
+})
@@ -1,6 +1,6 @@
 'use client'
 
-import { useCallback, useMemo } from 'react'
+import { useCallback, useEffect, useMemo } from 'react'
 import { Combobox, type ComboboxOption } from '@sim/emcn'
 import { useParams } from 'next/navigation'
 import { formatDisplayText } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/formatted-text'
@@ -76,6 +76,31 @@ export function TableSelector({
   const value = isPreview ? previewValue : storeValue
   const tableId = typeof value === 'string' ? value : null
 
+  const scoped = useMemo(() => {
+    /* Decode the scope once for the whole list rather than per row. */
+    const scopeSegments = parseFolderScope(folderScopePath)
+    return scopeSegments?.length
+      ? tables.filter((table) => isTableInFolderScope(table, tableFolders, scopeSegments))
+      : tables
+  }, [tables, tableFolders, folderScopePath])
+
+  /*
+   * Narrowing the folder must not leave a selection the picker no longer shows.
+   * Filtering alone would render the placeholder while the block kept running
+   * against the hidden table — the config would say one thing and the run do
+   * another. Dropping the value makes the empty picker true.
+   *
+   * Only a table that IS loaded and IS out of scope is cleared. A table absent
+   * from the list is a different situation (still loading, or deleted) and
+   * clearing there would destroy a valid config over a transient cache state.
+   */
+  useEffect(() => {
+    if (isPreview || disabled || isLoading || !tableId) return
+    if (!tables.some((table) => table.id === tableId)) return
+    if (scoped.some((table) => table.id === tableId)) return
+    setStoreValue('')
+  }, [isPreview, disabled, isLoading, tableId, tables, scoped, setStoreValue])
+
   /**
    * Two tables can share a name in different folders, so a colliding name is
    * suffixed with its folder path. Table names are lowercased for display (the
@@ -84,11 +109,6 @@ export function TableSelector({
    * disambiguated too. The folder path keeps its authored casing.
    */
   const options = useMemo<ComboboxOption[]>(() => {
-    /* Decode the scope once for the whole list rather than per row. */
-    const scopeSegments = parseFolderScope(folderScopePath)
-    const scoped = scopeSegments?.length
-      ? tables.filter((table) => isTableInFolderScope(table, tableFolders, scopeSegments))
-      : tables
     const duplicateNames = collectDuplicateNames(scoped.map((table) => table.name.toLowerCase()))
     return scoped.map((table) => ({
       label: disambiguateLabelByFolder(
@@ -99,7 +119,7 @@ export function TableSelector({
       ),
       value: table.id,
     }))
-  }, [tables, tableFolders, folderScopePath])
+  }, [scoped, tableFolders])
 
   const handleChange = useCallback(
     (selectedValue: string) => {
 
@@ -258,3 +258,92 @@ describe('table_v2 names every operation on the canvas', () => {
     }
   })
 })
+
+/*
+ * A block used as an Agent tool is handed the TOOL's schema, not this block's
+ * subblock ids, so a model answers with `path` / `folderPath` while the canvas
+ * stores `folderRef` / `moveTargetRef`. Reading only the canvas id dropped the
+ * model's answer — and on move the tool's root fallback then turned "move into
+ * /Reports" into "move to the root", silently.
+ */
+describe('table_v2 keeps the destination a model asked for', () => {
+  it('moves the table where the model said, not to the workspace root', () => {
+    const params = paramsFor('move', { tableId: 'table-1', folderPath: '/Reports' })
+
+    expect(params.folderPath).toBe('/Reports')
+    expect(tableMoveSchemas.body.safeParse(params).success).toBe(true)
+  })
+
+  it('lets the canvas destination win when the author picked one', () => {
+    const params = paramsFor('move', {
+      tableId: 'table-1',
+      moveTargetRef: '/Archive',
+      folderPath: '/Reports',
+    })
+
+    expect(params.folderPath).toBe('/Archive')
+  })
+
+  it('still reads an unset canvas destination as the workspace root', () => {
+    /* No model answer either, so the tool's root fallback is the only signal. */
+    expect(paramsFor('move', { tableId: 'table-1', moveTargetRef: '' }).folderPath).toBeUndefined()
+  })
+
+  it.each([
+    ['list_folders', { path: '/Reports' }, 'path'],
+    ['create_folder', { path: '/Reports/Q3' }, 'path'],
+    ['delete_folder', { path: '/Reports' }, 'path'],
+    ['restore_folder', { path: '/Reports/Q3' }, 'path'],
+  ] as const)('carries a model-supplied path through %s', (operation, modelParams, field) => {
+    expect(paramsFor(operation, modelParams)[field]).toBe(modelParams.path)
+  })
+
+  it('carries both ends of a model-driven folder move', () => {
+    const params = paramsFor('update_folder', {
+      path: '/Reports/Q3',
+      destinationPath: '/Archive/Q3',
+    })
+
+    expect(params).toMatchObject({ path: '/Reports/Q3', destinationPath: '/Archive/Q3' })
+    expect(tableUpdateFolderSchemas.body.safeParse(params).success).toBe(true)
+  })
+
+  it('keeps composing from the canvas when the author picked a source folder', () => {
+    /* Canvas mode still moves to the root when no destination parent is set. */
+    const params = paramsFor('update_folder', {
+      folderRef: '/Reports/Q3',
+      destinationParentRef: '',
+      destinationPath: '/Ignored/Q3',
+    })
+
+    expect(params).toMatchObject({ path: '/Reports/Q3', destinationPath: '/Q3' })
+  })
+
+  it('carries model-supplied listing options', () => {
+    const params = paramsFor('list_folders', {
+      path: '/Reports',
+      recursive: true,
+      depth: 2,
+      search: 'Q3',
+      limit: 25,
+    })
+
+    expect(params).toMatchObject({ recursive: true, depth: 2, search: 'Q3', limit: 25 })
+    expect(tableListFoldersSchemas.body.safeParse(params).success).toBe(true)
+  })
+
+  it('never takes the delete cascade from a model', () => {
+    /*
+     * `recursive` is user-only on the tool param AND on the subblock, so a model
+     * answer must not reach the use case even if one is somehow present.
+     */
+    const params = paramsFor('delete_folder', { path: '/Reports', recursive: true })
+
+    expect(params.recursive).toBe(false)
+  })
+
+  it('marks the delete cascade user-only on the subblock, not just the tool', () => {
+    /* The block's own schema is what an Agent tool surface is built from. */
+    expect(subBlock('deleteFolderRecursive')?.paramVisibility).toBe('user-only')
+  })
+})
@@ -74,6 +74,12 @@ interface TableBlockParams {
   folderSearch?: string
   folderLimit?: string
   deleteFolderRecursive?: unknown
+  /* Model-supplied tool params, present when the block runs as an Agent tool. */
+  path?: string
+  destinationPath?: string
+  search?: string
+  depth?: string
+  limit?: string
 }
 
 /**
@@ -202,13 +208,40 @@ function folderPathPrefix(parentPath: string | undefined): string {
   return parentPath && parentPath !== ROOT_FOLDER_PATH ? parentPath : ''
 }
 
+/**
+ * The canvas value if the author set one, else the value the model supplied.
+ *
+ * A block used as an Agent tool is handed the TOOL's schema, not this block's
+ * subblock ids (`createLLMToolSchema(toolConfig, ...)` in `providers/utils.ts`),
+ * so a model answers with `path` / `folderPath` while the canvas stores
+ * `folderRef` / `moveTargetRef`. Reading only the canvas id drops the model's
+ * answer — and on move the tool then substitutes the workspace root, turning
+ * "move into /Reports" into "move to the root". Same precedent as `columns`
+ * above.
+ */
+function canvasOrModel<T>(canvas: T | undefined, model: T | undefined): T | undefined {
+  return canvas !== undefined ? canvas : model
+}
+
+/** A switch the author never touched arrives empty; only then does the model's answer count. */
+function switchOrModel(canvas: unknown, model: unknown): boolean {
+  const authored = canvas !== undefined && canvas !== null && canvas !== ''
+  return switchValue(authored ? canvas : model)
+}
+
 const paramTransformers: Record<string, (params: TableBlockParams) => ParsedParams> = {
   list_folders: (params) => ({
-    path: folderRefPath(params.folderRef),
-    recursive: switchValue(params.folderRecursive),
-    depth: parseOptionalNumberInput(params.folderDepth, 'Max Depth', { integer: true, min: 1 }),
-    search: optionalText(params.folderSearch),
-    limit: parseOptionalNumberInput(params.folderLimit, 'Limit', { integer: true, min: 1 }),
+    path: canvasOrModel(folderRefPath(params.folderRef), optionalText(params.path)),
+    recursive: switchOrModel(params.folderRecursive, params.recursive),
+    depth: canvasOrModel(
+      parseOptionalNumberInput(params.folderDepth, 'Max Depth', { integer: true, min: 1 }),
+      parseOptionalNumberInput(params.depth, 'Max Depth', { integer: true, min: 1 })
+    ),
+    search: canvasOrModel(optionalText(params.folderSearch), optionalText(params.search)),
+    limit: canvasOrModel(
+      parseOptionalNumberInput(params.folderLimit, 'Limit', { integer: true, min: 1 }),
+      parseOptionalNumberInput(params.limit, 'Limit', { integer: true, min: 1 })
+    ),
   }),
 
   /*
@@ -221,7 +254,10 @@ const paramTransformers: Record<string, (params: TableBlockParams) => ParsedPara
     const name = optionalText(params.folderName)
     const parentPrefix = folderPathPrefix(folderRefPath(params.createParentRef))
     return {
-      path: name ? `${parentPrefix}/${encodeFolderPathSegment(name)}` : undefined,
+      path: canvasOrModel(
+        name ? `${parentPrefix}/${encodeFolderPathSegment(name)}` : undefined,
+        optionalText(params.path)
+      ),
     }
   },
 
@@ -233,27 +269,43 @@ const paramTransformers: Record<string, (params: TableBlockParams) => ParsedPara
    * and is not offered here.
    */
   update_folder: (params) => {
-    const sourcePath = folderRefPath(params.folderRef)
-    const segment = sourcePath?.split('/').pop()
-    const parentPrefix = folderPathPrefix(folderRefPath(params.destinationParentRef))
+    const canvasSource = folderRefPath(params.folderRef)
+    if (canvasSource) {
+      /*
+       * Canvas mode: the destination is composed, because the path the folder
+       * WILL have does not exist yet and cannot be picked. An unset parent is
+       * the workspace root, which is a real destination, not a missing one.
+       */
+      const segment = canvasSource.split('/').pop()
+      const parentPrefix = folderPathPrefix(folderRefPath(params.destinationParentRef))
+      return {
+        path: canvasSource,
+        destinationPath: segment ? `${parentPrefix}/${segment}` : undefined,
+      }
+    }
+    /* Agent mode: the model addresses both ends directly. */
     return {
-      path: sourcePath,
-      destinationPath: segment ? `${parentPrefix}/${segment}` : undefined,
+      path: optionalText(params.path),
+      destinationPath: optionalText(params.destinationPath),
     }
   },
 
   delete_folder: (params) => ({
-    path: folderRefPath(params.folderRef),
+    path: canvasOrModel(folderRefPath(params.folderRef), optionalText(params.path)),
+    /*
+     * No model fallback: the cascade is `user-only` on both the tool param and
+     * the subblock, so a model must never be able to supply it.
+     */
     recursive: switchValue(params.deleteFolderRecursive),
   }),
 
   restore_folder: (params) => ({
-    path: optionalText(params.restoreFolderPath),
+    path: canvasOrModel(optionalText(params.restoreFolderPath), optionalText(params.path)),
   }),
 
   move: (params) => ({
     tableId: params.tableId,
-    folderPath: folderRefPath(params.moveTargetRef),
+    folderPath: canvasOrModel(folderRefPath(params.moveTargetRef), optionalText(params.folderPath)),
   }),
 
   insert_row: (params) => ({