feat: keyboard coverage -- register the rest of Atlas's toolbar/board actions as commands (#211)

Registers every previously click-only Atlas action (Auto-arrange, Import,
Export, Add from folder, the two space-share actions, the lens, select-all,
and the selection tray's Delete/Group) into the shared command registry so
the palette and Shortcuts Help overlay stop being incomplete. Two new
Command fields make this legal without breaking existing dispatch:

- hintOnly: the command's real keydown handling lives in a dedicated
  listener (Cmd+A select-all, Delete/G over a live selection) rather than
  the generic dispatcher, which would otherwise preventDefault a native
  browser shortcut or has no access to the live selection it needs.
- paletteHidden: excludes an action needing a live on-screen target
  (Delete selection, Group into a new area) from the palette while it
  stays reachable via HotkeyHint chips, ContextMenu items, and the
  Shortcuts Help overlay.

Cmd+A select-all is a new capability (useAtlasSelectAll.ts), gated by
app/useKeymapDispatch.ts's new Listener 5 the same way the existing
undo-delete listener guards Cmd+Z. The two context-menu items that already
existed (Group into new area, Delete) now carry commandId so their rows
show the same hint chip the palette/overlay do.

Split shared/commands.ts's own settings-deep-link commands out to a new
settingsCommands.ts to stay under the file-length cap once the new
Command fields' doc comments and the Atlas command spread landed.


Claude-Session: https://claude.ai/code/session_01FW5GkkAG8du7tNdYLk2zSd

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: alicoding

frontend/e2e/atlas-select-group.spec.ts

@@ -330,3 +330,71 @@ test('atlas shift-click select: toggle membership, group via member right-click,
     rmSync(dir, { recursive: true, force: true })
   }
 })
+
+// atlas.selectAll's own ⌘A (shared/atlasBoardCommands.ts, app/useKeymapDispatch.ts's
+// Listener 5): a dedicated, editable-target-guarded listener, not the
+// generic dispatcher -- proves both halves in one flow, native
+// select-all-text inside the jump dialog's own input stays untouched,
+// and a real board-level press selects every card.
+// eslint-disable-next-line no-empty-pattern -- this test needs `testInfo` (the second arg), not any fixture.
+test('atlas select-all (Cmd+A): guarded inside an editable field, selects every card on the board otherwise', async ({}, testInfo) => {
+  const idx = testInfo.parallelIndex
+  const dir = mkdtempSync(path.join(tmpdir(), `mill-e2e-atlas-select-all-${idx}-`))
+  const settingsPath = path.join(dir, 'settings.json')
+  const executionDbPath = path.join(dir, 'execution.db')
+  const backupDir = path.join(dir, 'backups')
+  const port = ATLAS_SELECT_GROUP_SERVER_BASE_PORT + idx
+  const mcpPort = ATLAS_SELECT_GROUP_MCP_BASE_PORT + idx
+
+  let server: SpawnedServer | undefined
+  const browser = await chromium.launch()
+  try {
+    server = await spawnMillServer({ port, mcpPort, settingsPath, executionDbPath, backupDir })
+    const page = await browser.newPage()
+    await page.goto(`${server.baseURL}/`)
+    await page.getByRole('link', { name: 'Atlas' }).click()
+    const board = page.getByTestId('atlas-board')
+    await expect(board).toBeVisible()
+    await zoomOutLight(page)
+
+    const popover = page.getByTestId('atlas-placement-popover')
+    await armAndPlaceTopicCard(page, board, popover, 0.25, 0.05, 'ZzA2eSelAllA')
+    await armAndPlaceTopicCard(page, board, popover, 0.55, 0.05, 'ZzA2eSelAllB')
+
+    const selected = page.locator('.react-flow__node.selected')
+
+    // Editable-target guard: Cmd+A inside the jump dialog's own search
+    // input is native browser select-all-text, never board select-all.
+    await page.keyboard.press('Meta+k')
+    const jumpInput = page.getByTestId('atlas-jump-input')
+    await expect(jumpInput).toBeFocused()
+    await jumpInput.press('Meta+a')
+    await expect(selected).toHaveCount(0)
+    await page.keyboard.press('Escape')
+
+    // Real dispatch: Cmd+A on the board selects EVERY top-level card at
+    // this level -- the seeded root ("My space") already carries 3
+    // (Example area, Getting started, Scratchpad; internal/domain/atlas/builtin.go),
+    // plus the 2 just placed.
+    await page.keyboard.press('Meta+a')
+    await expect(selected).toHaveCount(5)
+    const selectionTray = page.getByTestId('atlas-selection-tray')
+    await expect(selectionTray).toBeVisible()
+    await expect(page.getByTestId('atlas-selection-count')).toHaveText('5 selected')
+
+    // Cleanup (testing.md's within-file discipline): quick delete +
+    // clock-controlled toast expiry, same pattern this file's other
+    // test already uses.
+    await page.clock.install()
+    await page.keyboard.press('Delete')
+    await expect(noteCard(page, 'ZzA2eSelAllA')).toHaveCount(0)
+    await expect(noteCard(page, 'ZzA2eSelAllB')).toHaveCount(0)
+    const undoToast = page.getByTestId('atlas-undo-toast')
+    await expect(undoToast).toBeVisible()
+    await page.clock.fastForward('00:11')
+    await expect(undoToast).toHaveCount(0)
+  } finally {
+    await server?.stop()
+    rmSync(dir, { recursive: true, force: true })
+  }
+})

frontend/e2e/atlas.spec.ts

@@ -217,6 +217,29 @@ test('arrange is an action: dragging persists a position, Auto-arrange re-seats
   await expect.poll(async () => adaNode.evaluate((el) => (el as HTMLElement).style.transform), { timeout: 10_000 }).toBe(before)
 })
 
+// atlas.arrange (shared/atlasBoardCommands.ts): the palette path runs
+// the SAME arrange action the toolbar button above does -- proven by
+// the same transform-changes-to-a-translate assertion, not a second
+// reload-persistence check (already covered above).
+test('Auto-arrange from the command palette runs the same action as the toolbar button', async ({ page }) => {
+  await page.goto('/')
+  await page.getByRole('link', { name: 'Atlas' }).click()
+  await groupCard(page, 'Example area').getByTestId('atlas-group-header').click()
+  await expect(page.getByTestId('atlas-breadcrumb')).toContainText('Example area')
+
+  const adaNode = page.locator('.react-flow__node').filter({ has: page.locator('[aria-label="Flip Ada Lovelace"]') })
+  await expect(adaNode).toBeVisible()
+
+  await page.keyboard.press('Meta+/')
+  const palette = page.getByRole('dialog', { name: 'Command palette' })
+  await expect(palette).toBeVisible()
+  await palette.getByRole('combobox').fill('Auto-arrange')
+  await palette.getByRole('option', { name: 'Auto-arrange' }).click()
+  await expect(palette).toHaveCount(0)
+
+  await expect.poll(async () => (await adaNode.evaluate((el) => (el as HTMLElement).style.transform)) ?? '').toContain('translate')
+})
+
 test('create a child card, edit + persist it via the flip-then-Open overlay, then delete it', async ({ page }) => {
   const title = 'ZzE2eAtlasChildCard'
   await page.goto('/')

frontend/e2e/command-palette.spec.ts

@@ -223,3 +223,50 @@ test('a workflow row shows its own hotkey-trigger combo inline; a non-hotkey tri
   await clickRowAction(page, workflowRow(page, manualLabel), 'Delete')
   await expect(workflowRow(page, manualLabel)).toHaveCount(0)
 })
+
+// shared/atlasBoardCommands.ts's new Atlas commands: every palette-
+// visible one is actually reachable by searching its exact label.
+test('every new Atlas command is reachable from the palette by its label', async ({ page }) => {
+  await page.goto('/')
+  await page.getByRole('link', { name: 'Atlas' }).click()
+  await expect(page.getByTestId('atlas-board')).toBeVisible()
+
+  const labels = [
+    'Select all',
+    'Auto-arrange',
+    'Open lens',
+    'Import atlas',
+    'Export atlas',
+    'Add cards from a folder',
+    'Copy space as context',
+    'Copy space links',
+  ]
+  for (const label of labels) {
+    await page.keyboard.press('Meta+/')
+    await expect(paletteDialog(page)).toBeVisible()
+    await paletteDialog(page).getByRole('combobox').fill(label)
+    await expect(paletteDialog(page).getByRole('option', { name: label })).toBeVisible()
+    await page.keyboard.press('Escape')
+  }
+})
+
+// atlas.delete.selection/atlas.group.selection are paletteHidden --
+// they need a live, on-screen selection the palette can't supply, so
+// they're excluded here even though the Shortcuts Help overlay still
+// lists their hint chips (help-overlay.spec.ts).
+test('Delete selection and Group into a new area are excluded from the palette (paletteHidden)', async ({ page }) => {
+  await page.goto('/')
+  await page.getByRole('link', { name: 'Atlas' }).click()
+  await expect(page.getByTestId('atlas-board')).toBeVisible()
+
+  await page.keyboard.press('Meta+/')
+  await expect(paletteDialog(page)).toBeVisible()
+
+  await paletteDialog(page).getByRole('combobox').fill('Delete selection')
+  await expect(paletteDialog(page).getByRole('option', { name: 'Delete selection' })).toHaveCount(0)
+
+  await paletteDialog(page).getByRole('combobox').fill('Group into a new area')
+  await expect(paletteDialog(page).getByRole('option', { name: 'Group into a new area' })).toHaveCount(0)
+
+  await page.keyboard.press('Escape')
+})

frontend/e2e/help-overlay.spec.ts

@@ -99,3 +99,31 @@ test('"Rebind in Settings" in the overlay footer navigates to Settings and close
   await expect(page.getByTestId('settings-view')).toBeVisible()
   await expect(page.locator('[data-testid="keymap-list"]')).toBeVisible()
 })
+
+// shared/atlasBoardCommands.ts's new Atlas commands: hintOnly ones
+// still render their own real hint chip here (atlas.selectAll's ⌘A,
+// atlas.delete.selection's ⌫, atlas.group.selection's G); palette-only
+// commands with no default binding (atlas.arrange, atlas.import) are
+// deliberately absent -- same "unbound stays out of the overlay"
+// behavior atlas.matrix/atlas.coverage already have.
+test('the overlay shows hint chips for the new Atlas commands, and omits unbound palette-only ones', async ({ page }) => {
+  await page.goto('/')
+  await page.getByRole('link', { name: 'Atlas' }).click()
+  await expect(page.getByTestId('atlas-view')).toBeVisible()
+
+  await page.keyboard.press('?')
+  const dialog = helpDialog(page)
+  await expect(dialog).toBeVisible()
+
+  const selectAllRow = dialog.locator('[data-command-id="atlas.selectAll"]')
+  await expect(selectAllRow).toContainText('Select all')
+  await expect(selectAllRow).toContainText('⌘A')
+
+  await expect(dialog.locator('[data-command-id="atlas.delete.selection"]')).toContainText('⌫')
+  await expect(dialog.locator('[data-command-id="atlas.group.selection"]')).toContainText('G')
+
+  await expect(dialog.locator('[data-command-id="atlas.arrange"]')).toHaveCount(0)
+  await expect(dialog.locator('[data-command-id="atlas.import"]')).toHaveCount(0)
+
+  await page.keyboard.press('Escape')
+})

frontend/src/app/CommandPalette.tsx

@@ -305,13 +305,13 @@ export function CommandPalette() {
 
   const allEntries = useMemo<PaletteEntry[]>(() => {
     if (restState) {
-      const surfaceCommands = COMMANDS.filter((c) => c.surface?.includes(viewKind)).map(commandEntry)
+      const surfaceCommands = COMMANDS.filter((c) => c.surface?.includes(viewKind) && !c.paletteHidden).map(commandEntry)
       const navCommands = COMMANDS.filter((c) => isNavCommandId(c.id)).map(commandEntry)
       const topWorkflows = sortWorkflowsByPinnedAndFrecency(workflows ?? [], mostUsedRank, pinnedWorkflowIds).slice(0, REST_STATE_WORKFLOW_LIMIT)
       return [...surfaceCommands, ...navCommands, ...topWorkflows.flatMap(workflowEntries), ...workTabs.flatMap(tabEntries)]
     }
     return [
-      ...COMMANDS.filter((c) => !c.surface || c.surface.includes(viewKind)).map(commandEntry),
+      ...COMMANDS.filter((c) => (!c.surface || c.surface.includes(viewKind)) && !c.paletteHidden).map(commandEntry),
       ...sortWorkflowsByPinnedAndFrecency(workflows ?? [], mostUsedRank, pinnedWorkflowIds).flatMap(workflowEntries),
       ...workTabs.flatMap(tabEntries),
     ]

frontend/src/app/useKeymapDispatch.ts

@@ -112,4 +112,24 @@ export function useKeymapDispatch(): void {
     window.addEventListener('keydown', onKeyDown)
     return () => window.removeEventListener('keydown', onKeyDown)
   }, [])
+
+  // Listener 5, atlas.selectAll's own ⌘A (shared/atlasBoardCommands.ts):
+  // same reasoning as Listener 4 above -- ⌘A is ALSO the native
+  // select-all-text combo, so a generic dispatchCommandForEvent match
+  // (which preventDefaults unconditionally) would break it inside any
+  // Atlas input. Gated the same way Listener 3 gates bare C/N/A: atlas
+  // surface only, no open dialog, never an editable target.
+  useEffect(() => {
+    const onKeyDown = (e: KeyboardEvent) => {
+      if (!e.metaKey || e.ctrlKey || e.altKey || e.shiftKey) return
+      if (e.key.toUpperCase() !== 'A') return
+      if (useAppStore.getState().view.kind !== 'atlas') return
+      if (isEditableTarget(e.target)) return
+      if (document.querySelector('[role="dialog"]')) return
+      e.preventDefault()
+      findCommand('atlas.selectAll')?.run()
+    }
+    window.addEventListener('keydown', onKeyDown)
+    return () => window.removeEventListener('keydown', onKeyDown)
+  }, [])
 }

frontend/src/atlas/AtlasBoard.tsx

@@ -23,6 +23,7 @@ import { useAtlasCreation, type AtlasGroupRequest, type AtlasPlacementRequest, t
 import { useAtlasAreaDraw } from './useAtlasAreaDraw'
 import { useAtlasDragFiling, type FrameBox } from './useAtlasDragFiling'
 import { useAtlasSelection } from './useAtlasSelection'
+import { useAtlasSelectAll } from './useAtlasSelectAll'
 import { useAtlasSelectionTray } from './useAtlasSelectionTray'
 import { useAtlasSlotDrag } from './useAtlasSlotDrag'
 import { AtlasSlotDragLine } from './AtlasSlotDragLine'
@@ -309,6 +310,8 @@ function AtlasBoardInner({ cards, allCards, kinds, links, linkKinds, notes, pare
     setNodes(sel.length > 0 ? allNodes.map((n) => (sel.includes(n.id) ? { ...n, selected: true } : n)) : allNodes)
   }, [allNodes, setNodes, selection.selectedIDsRef])
 
+  useAtlasSelectAll({ cards, notes, setNodes })
+
   const { trayRef, hasSelection: haveSelection, onGroup: onTrayGroup, onDelete: onTrayDelete } = useAtlasSelectionTray({ selectedCards: selection.selectedCards, selectedNotes: selection.selectedNotes, clearSelection: selection.clearSelection, setNodes, onDeleteSelection, onGroupSelection, onUnflip: () => setFlippedID(null) })
 
   // Every re-root (drill in, breadcrumb out, jump) settles the new

frontend/src/atlas/AtlasFolderImport.tsx

@@ -9,6 +9,7 @@ import type { FolderScanEntry, FolderScanResult } from '../shared/bindings'
 import { refreshAtlas } from './atlasStore'
 import { folderScanEntryDepth, groupFolderScanEntries, type FolderScanGroup } from './atlasFolderScanGrouping'
 import { useAtlasFolderImportRequestStore } from './atlasFolderImportRequest'
+import { useUISignalStore } from '../shared/uiSignalStore'
 import runbookStyles from '../shared/ListCard.module.css'
 import styles from './AtlasFolderImport.module.css'
 
@@ -94,6 +95,18 @@ export function AtlasFolderImport({ viewedID, kinds }: { viewedID: string; kinds
     // eslint-disable-next-line react-hooks/exhaustive-deps -- keyed on the request's own token, scanRoot reads current kinds/viewedID via closure at fire time same as every other request-token effect in atlas/
   }, [folderImportRequest])
 
+  // atlas.addFromFolder's own signal (shared/atlasBoardCommands.ts): a
+  // palette/keyboard invocation runs the SAME PickFolder flow the
+  // toolbar's own "Add cards from a folder" button does.
+  const addFromFolderRequest = useUISignalStore((s) => s.atlasAddFromFolderRequest)
+  const lastAddFromFolderRequest = useRef(addFromFolderRequest)
+  useEffect(() => {
+    if (addFromFolderRequest === lastAddFromFolderRequest.current) return
+    lastAddFromFolderRequest.current = addFromFolderRequest
+    void startPick()
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- keyed on the signal tick alone, startPick reads current viewedID via closure at fire time same as every other request-token effect in atlas/
+  }, [addFromFolderRequest])
+
   const toggleEntry = (relPath: string, checked: boolean) => {
     setAccepted((prev) => {
       const next = new Set(prev)

frontend/src/atlas/AtlasLensControl.tsx

@@ -1,8 +1,9 @@
-import { useState } from 'react'
+import { useEffect, useRef, useState } from 'react'
 import { useTranslation } from 'react-i18next'
 import { Button, Checkbox, CheckboxGroup, Dialog, FormControl, SegmentedControl } from '@primer/react'
 import { FilterIcon } from '@primer/octicons-react'
 import type { Kind } from '../../bindings/github.com/alicoding/mill/internal/domain/atlas/models'
+import { useUISignalStore } from '../shared/uiSignalStore'
 
 // The per-space lens (docs/goals/0061): which Kinds stay visible among
 // the viewed space's children, and the depth toggle (this level only vs
@@ -22,6 +23,17 @@ export function AtlasLensControl({ presentKinds, hiddenKindIDs, onChangeHidden,
   const [open, setOpen] = useState(false)
   const visibleIDs = presentKinds.map((k) => k.ID).filter((id) => !hiddenKindIDs.includes(id))
 
+  // atlas.lens's own signal (shared/atlasBoardCommands.ts): a palette/
+  // keyboard invocation opens the SAME dialog the toolbar's own lens
+  // button does.
+  const lensOpenRequest = useUISignalStore((s) => s.atlasLensOpenRequest)
+  const lastLensOpenRequest = useRef(lensOpenRequest)
+  useEffect(() => {
+    if (lensOpenRequest === lastLensOpenRequest.current) return
+    lastLensOpenRequest.current = lensOpenRequest
+    setOpen(true)
+  }, [lensOpenRequest])
+
   return (
     <>
       <Button leadingVisual={FilterIcon} size="small" variant="invisible" data-testid="atlas-lens-open" onClick={() => setOpen(true)}>

frontend/src/atlas/AtlasSpaceShareMenu.tsx

@@ -1,7 +1,7 @@
 import { useTranslation } from 'react-i18next'
 import { ActionList, ActionMenu } from '@primer/react'
 import { ShareIcon } from '@primer/octicons-react'
-import { AtlasService } from '../shared/bindings'
+import { atlasSpaceShareActions } from './atlasSpaceShareActions'
 
 // The space toolbar's own share affordance (goal 0063, ADR-0038): the
 // viewed space's mirror folder (reveal turns it into a STANDING
@@ -19,20 +19,7 @@ export function AtlasSpaceShareMenu({ spaceID, onError }: {
   onError: (message: string) => void
 }) {
   const { t } = useTranslation('atlas')
-
-  const revealFolder = () => {
-    AtlasService.RevealSpaceFolder(spaceID).catch((err) => onError(String(err)))
-  }
-  const bundleContext = (withAttachments: boolean) => {
-    AtlasService.SpaceBundleContext(spaceID, withAttachments)
-      .then((text) => navigator.clipboard.writeText(text))
-      .catch((err) => onError(String(err)))
-  }
-  const copyLinks = () => {
-    AtlasService.SpaceLinksList(spaceID)
-      .then((text) => navigator.clipboard.writeText(text))
-      .catch((err) => onError(String(err)))
-  }
+  const { revealFolder, bundleContext, copyLinks } = atlasSpaceShareActions(spaceID, onError)
 
   return (
     <ActionMenu>