@@ -113,46 +113,72 @@ also accepts its singular form: for example, `sim table list`,
 spellings.
 
 ```bash
-sim workflows list [--folder <id>] [--deployed] [--limit <n>]
+sim workflows ls [--folder </path>] [--search <text>] [--limit <n>]
+sim workflows list [--folder </path>] [--deployed-only] [--limit <n>]
 sim workflows get <id>
+sim workflows mv <id> --folder </path>
 sim workflows deploy|undeploy|rollback <id>
 
 sim logs list [--level error] [--workflow <id>…] [--trigger <name>…] [--start <date>]
 sim logs get <id>
 sim logs execution <executionId>
 
-sim tables list
+sim tables ls [--folder </path>] [--search <text>] [--limit <n>]
+sim tables list [--folder </path>]
 sim tables get <tableId>
+sim tables mv <tableId> --folder </path>
 sim tables columns <tableId>
 sim tables rows list <tableId> [--limit <n>]
 sim tables rows query <tableId> [--filter <json>] [--sort <json>] [--limit <n>]
 sim tables upsert <tableId> --data <json>
 sim tables rows batch-delete <tableId> (--row <id>… | --filter <json>) --yes
 
-sim files list
-sim files create --name <name> [--content <value>] [--encoding utf-8|base64]
-sim files upload <path> [--name <name>] [--folder-id <id>]
+sim files ls [--folder </path>] [--search <text>] [--limit <n>]
+sim files list [--folder </path>]
+sim files get <fileId>
+sim files create --name <name> [--folder </path>] [--content <value>] [--encoding utf-8|base64]
+sim files upload <path> [--name <name>] [--folder </path>]
 sim files download <fileId> [-o <path>]
-sim files move [--file-ids <id>…] [--folder-ids <id>…] [--target-folder-id <id>]
-sim files batch-archive [--file-ids <id>…] [--folder-ids <id>…] --yes
+sim files mv --file-ids <id>… [--to </path>]
+sim files batch-delete --file-ids <id>… --yes
 sim files delete <fileId>
 
-sim knowledge list
+sim knowledge ls [--folder </path>] [--search <text>] [--limit <n>]
+sim knowledge list [--folder </path>]
 sim knowledge get <id>
+sim knowledge mv <id> --folder </path>
 sim knowledge documents <id> [--search <text>]
 sim knowledge documents upload <id> <path> [--tag <value>...]
 sim knowledge search --query <text> --kb <id>… [--search-mode vector|hybrid]
 ```
 
+`ls` is a directory view: it combines the resources at `--folder` with that
+folder's direct child folders. Its `ref` column is the resource ID or canonical
+folder path to pass to the next command. Use `list` when you want resources only,
+or `folders ls` when you want folders only.
+
+Each folder-backed resource has the same path commands:
+
+```bash
+sim tables folders ls --parent /Reports
+sim tables folders create /Reports/Quarterly
+sim tables folders mv /Reports/Quarterly /Archive/Quarterly
+sim tables folders delete /Archive/Quarterly --recursive false --yes
+```
+
+Replace `tables` with `files`, `workflows`, or `knowledge`. Paths are canonical,
+start with `/`, and use `/` for root. A slash that belongs to a folder name is
+percent-encoded as `%2F` rather than treated as a separator.
+
 ### List inputs
 
 Primitive lists take space-separated values. Prefix a path with `@` to read
 one value per line, or use `@-` to read the list from stdin.
 
 ```bash
-sim files move --file-ids file_1 file_2 --target-folder-id folder_1
-sim files move --file-ids @file-ids.txt --target-folder-id folder_1
-printf 'file_1\nfile_2\n' | sim files move --file-ids @- --target-folder-id folder_1
+sim files mv --file-ids file_1 file_2 --to /Archive
+sim files mv --file-ids @file-ids.txt --to /Archive
+printf 'file_1\nfile_2\n' | sim files mv --file-ids @- --to /Archive
 ```
 
 Arrays of objects remain JSON inputs because they cannot be represented as a
 
@@ -83,8 +83,7 @@ describe('files upload', () => {
             size: 5,
             type: 'text/plain',
             key: 'workspace/ws_local/notes.txt',
-            folderId: null,
-            folderPath: null,
+            folderPath: '/',
             uploadedBy: 'user_1',
             uploadedAt: '2026-08-04T19:00:00.000Z',
             updatedAt: '2026-08-04T19:00:00.000Z',
@@ -96,7 +95,7 @@ describe('files upload', () => {
     const logged: string[] = []
     vi.spyOn(console, 'log').mockImplementation((line: string) => logged.push(line))
 
-    await program().parseAsync(['node', 'sim', 'file', 'upload', path])
+    await program().parseAsync(['node', 'sim', 'file', 'upload', path, '--folder', '/Reports'])
 
     expect(fetchMock).toHaveBeenCalledWith(
       'https://storage.example/file',
@@ -106,6 +105,19 @@ describe('files upload', () => {
         body: expect.any(Blob),
       })
     )
+    expect(mockRequest.mock.calls[0]).toEqual([
+      '/api/v2/files/uploads',
+      {
+        method: 'POST',
+        body: {
+          workspaceId: 'ws_local',
+          name: 'notes.txt',
+          contentType: 'text/plain',
+          size: 5,
+          folderPath: '/Reports',
+        },
+      },
+    ])
     expect(mockRequest.mock.calls[1]).toEqual([
       '/api/v2/files/uploads/upload_1/complete',
       {
 
@@ -12,43 +12,41 @@ export function attachFileUpload(files: Command): void {
   files
     .command('upload <path>')
     .description('Upload a file to the workspace')
-    .option('--folder-id <id>', 'Target folder (defaults to the workspace root)')
+    .option('--folder <path>', 'Canonical destination folder path (defaults to /)')
     .option('--name <name>', 'Store it under a different name')
-    .action(
-      async (path: string, options: { folderId?: string; name?: string }, command: Command) => {
-        const { client, profile } = clientFrom(command)
-        const workspaceId = client.requireWorkspace()
-        const { name, size } = await localFile(path, options.name)
+    .action(async (path: string, options: { folder?: string; name?: string }, command: Command) => {
+      const { client, profile } = clientFrom(command)
+      const workspaceId = client.requireWorkspace()
+      const { name, size } = await localFile(path, options.name)
 
-        const created = await client.request<CreateFileUploadResponse>('/api/v2/files/uploads', {
-          method: 'POST',
-          body: {
-            workspaceId,
-            name,
-            contentType: contentTypeFor(name),
-            size,
-            ...(options.folderId ? { folderId: options.folderId } : {}),
-          },
-        })
-        const { session, uploadToken, transfer } = created.data
-        const completed = await finishUploadSession<CompleteFileUploadResponse['data']>(
-          client,
+      const created = await client.request<CreateFileUploadResponse>('/api/v2/files/uploads', {
+        method: 'POST',
+        body: {
           workspaceId,
-          {
-            basePath: `/api/v2/files/uploads/${encodeURIComponent(session.id)}`,
-            uploadToken,
-            transfer,
-            size,
-          },
-          path
-        )
-
-        printProtocolResult(profile.output, {
-          id: completed.file?.id ?? session.id,
           name,
+          contentType: contentTypeFor(name),
+          size,
+          ...(options.folder ? { folderPath: options.folder } : {}),
+        },
+      })
+      const { session, uploadToken, transfer } = created.data
+      const completed = await finishUploadSession<CompleteFileUploadResponse['data']>(
+        client,
+        workspaceId,
+        {
+          basePath: `/api/v2/files/uploads/${encodeURIComponent(session.id)}`,
+          uploadToken,
+          transfer,
           size,
-          status: 'uploaded',
-        })
-      }
-    )
+        },
+        path
+      )
+
+      printProtocolResult(profile.output, {
+        id: completed.file?.id ?? session.id,
+        name,
+        size,
+        status: 'uploaded',
+      })
+    })
 }
@@ -2,6 +2,7 @@ import { Command } from 'commander'
 import { attachFileDownload } from './files-download.js'
 import { attachFileUpload } from './files-upload.js'
 import { attachKnowledgeDocumentUpload } from './knowledge-document-upload.js'
+import { attachResourceList } from './resource-ls.js'
 import { attachTableImport } from './tables-import.js'
 
 function group(program: Command, name: string): Command {
@@ -17,6 +18,31 @@ export function attachProtocolCommands(program: Command): void {
   const files = group(program, 'files')
   attachFileUpload(files)
   attachFileDownload(files)
-  attachKnowledgeDocumentUpload(group(group(program, 'knowledge'), 'documents'))
-  attachTableImport(group(program, 'tables'))
+  attachResourceList(files, {
+    kind: 'file',
+    resources: 'listFiles',
+    folders: 'listFileFolders',
+  })
+
+  const knowledge = group(program, 'knowledge')
+  attachKnowledgeDocumentUpload(group(knowledge, 'documents'))
+  attachResourceList(knowledge, {
+    kind: 'knowledge',
+    resources: 'listKnowledgeBases',
+    folders: 'listKnowledgeFolders',
+  })
+
+  const tables = group(program, 'tables')
+  attachTableImport(tables)
+  attachResourceList(tables, {
+    kind: 'table',
+    resources: 'listTables',
+    folders: 'listTableFolders',
+  })
+
+  attachResourceList(group(program, 'workflows'), {
+    kind: 'workflow',
+    resources: 'listWorkflows',
+    folders: 'listWorkflowFolders',
+  })
 }
@@ -0,0 +1,127 @@
+import { Command } from 'commander'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { buildGeneratedCommands } from '../../runtime/build.js'
+import { attachProtocolCommands } from './index.js'
+
+const { mockRequest, output } = vi.hoisted(() => ({
+  mockRequest: vi.fn(),
+  output: { format: 'json' },
+}))
+
+vi.mock('../../context.js', () => ({
+  clientFrom: () => ({
+    client: { request: mockRequest, requireWorkspace: () => 'ws_local' },
+    profile: {
+      workspaceId: 'ws_local',
+      output: output.format,
+      name: 'default',
+      apiKey: 'k',
+      endpoint: 'https://sim.example',
+    },
+  }),
+}))
+
+function program(): Command {
+  const root = new Command('sim').exitOverride()
+  for (const group of buildGeneratedCommands()) root.addCommand(group)
+  attachProtocolCommands(root)
+  return root
+}
+
+beforeEach(() => {
+  vi.restoreAllMocks()
+  mockRequest.mockReset()
+  output.format = 'json'
+})
+
+describe('resource ls', () => {
+  it('is available for every folder-backed resource', () => {
+    for (const resource of ['files', 'knowledge', 'tables', 'workflows']) {
+      const group = program().commands.find((command) => command.name() === resource)
+      expect(group?.commands.some((command) => command.name() === 'ls')).toBe(true)
+    }
+  })
+
+  it('combines child folders and resources in one directory listing', async () => {
+    mockRequest.mockImplementation(async (path: string) => {
+      if (path === '/api/v2/tables/folders') {
+        return {
+          data: [
+            {
+              name: 'Archive',
+              path: '/Reports/Archive',
+              parentPath: '/Reports',
+              createdAt: '2026-08-01T00:00:00.000Z',
+              updatedAt: '2026-08-02T00:00:00.000Z',
+            },
+          ],
+          nextCursor: null,
+        }
+      }
+      if (path === '/api/v2/tables') {
+        return {
+          data: [
+            {
+              id: 'tbl_1',
+              name: 'Revenue',
+              folderPath: '/Reports',
+              updatedAt: '2026-08-03T00:00:00.000Z',
+            },
+          ],
+          nextCursor: null,
+        }
+      }
+      throw new Error(`Unexpected path: ${path}`)
+    })
+    const logged: string[] = []
+    vi.spyOn(console, 'log').mockImplementation((line: string) => logged.push(line))
+
+    await program().parseAsync([
+      'node',
+      'sim',
+      'table',
+      'ls',
+      '--folder',
+      '/Reports',
+      '--search',
+      'r',
+    ])
+
+    expect(mockRequest).toHaveBeenCalledWith('/api/v2/tables/folders', {
+      query: {
+        workspaceId: 'ws_local',
+        parentPath: '/Reports',
+        search: 'r',
+        sortBy: 'name',
+        sortOrder: 'asc',
+      },
+    })
+    expect(mockRequest).toHaveBeenCalledWith('/api/v2/tables', {
+      query: {
+        workspaceId: 'ws_local',
+        folderPath: '/Reports',
+        search: 'r',
+        sortBy: 'name',
+        sortOrder: 'asc',
+        limit: 100,
+        cursor: null,
+      },
+    })
+    expect(JSON.parse(logged[0])).toEqual([
+      {
+        kind: 'folder',
+        name: 'Archive',
+        ref: '/Reports/Archive',
+        folderPath: '/Reports',
+        updatedAt: '2026-08-02T00:00:00.000Z',
+      },
+      {
+        kind: 'table',
+        name: 'Revenue',
+        ref: 'tbl_1',
+        folderPath: '/Reports',
+        updatedAt: '2026-08-03T00:00:00.000Z',
+      },
+    ])
+  })
+})