@brimveyn/aimux 1.21.0 → 1.22.2

package/src/ui/components/modals/tabs/new-tab-modal.tsx

@@ -1,248 +1,72 @@
 import { useCallback, useMemo } from 'react'
 
-import type { WorktreeTemplate } from '../../../../config'
-import type { AssistantId, WorktreeRecord } from '../../../../state/types'
+import type { AssistantId } from '../../../../state/types'
 
 import { getAllAssistantOptions, getAssistantOption } from '../../../../pty/command-registry'
 import { dispatchGlobal, runSideEffectGlobal } from '../../../../state/dispatch-ref'
-import {
-  buildBaseRefOptions,
-  filterAssistants,
-  getTemplateNoneOffset,
-} from '../../../../state/selectors'
+import { getNewTabAssistantOptions } from '../../../../state/selectors'
 import { useTheme } from '../../../theme'
 import { uiTokens } from '../../../ui-tokens'
-import { AutoComplete, Form, type FormOptionItem, TextField } from '../shared/form'
+import { Form, TextField } from '../shared/form'
 import { Picker, type PickerItem } from '../shared/picker'
-import { WorktreeDeleteConfirm } from '../shared/worktree-delete-confirm'
 
 interface NewTabModalProps {
   selectedIndex: number
   customCommands: Record<string, string>
   filter: string | null
   cursorPos?: number
-  currentSessionId: string | null
   editingCommand: AssistantId | null
   editBuffer: string
-  activeField: 'assistant' | 'branch-name' | 'target-worktree' | 'worktree-name' | 'base'
-  branchError: string | null
-  branchName: string
-  createWorktree: boolean
-  selectedAssistantId: AssistantId | null
-  step: 'assistant' | 'worktree' | 'worktree-create' | 'template'
-  worktreeDeletePrompt: { worktreeId: string; reason: string } | null
-  worktrees: WorktreeRecord[]
-  worktreeName: string
-  baseQuery: string
-  baseRef: string
-  baseBranches: string[]
-  worktreeTemplates: WorktreeTemplate[]
-  /**
-   * True when this modal is the worktree-aware new-tab flow. False when the
-   * component is reused for `split-picker`, which can only choose an
-   * assistant — the template shortcut entry must be hidden there.
-   */
-  allowTemplateShortcut: boolean
-}
-
-const TEMPLATE_SHORTCUT_KEY = '__template-shortcut__'
-
-function getDeleteBlockedReason({
-  currentSessionId,
-  worktree,
-  worktrees,
-}: {
-  currentSessionId: string | null
-  worktree: WorktreeRecord | undefined
-  worktrees: WorktreeRecord[]
-}): string | null {
-  if (!worktree) return null
-  if (!(currentSessionId != null && currentSessionId !== ''))
-    return 'Cannot delete: no active session.'
-  if (worktrees.length <= 1) return 'Cannot delete: at least one worktree must remain.'
-  if (worktree.source === 'primary') return 'Cannot delete: root worktree is required.'
-  if (worktree.source === 'aimux-temp' && !worktree.createdByAimux) {
-    return 'Cannot delete: this temp worktree was not created by Aimux.'
-  }
-  return null
+  /** Chained from `<C-p>`: a shell cannot take the prompt, so Terminal is hidden. */
+  excludeTerminal: boolean
 }
 
 export function NewTabModal({
-  activeField,
-  allowTemplateShortcut,
-  baseBranches,
-  baseQuery,
-  baseRef,
-  branchError,
-  branchName,
-  createWorktree,
-  currentSessionId,
   cursorPos,
   customCommands,
   editBuffer,
   editingCommand,
+  excludeTerminal,
   filter,
-  selectedAssistantId,
   selectedIndex,
-  step,
-  worktreeDeletePrompt,
-  worktreeName,
-  worktrees,
-  worktreeTemplates,
 }: NewTabModalProps) {
   const t = useTheme()
   const options = useMemo(() => getAllAssistantOptions(customCommands), [customCommands])
-  const filtered = useMemo(() => filterAssistants(options, filter), [filter, options])
+  const filtered = useMemo(
+    () => getNewTabAssistantOptions(customCommands, filter, excludeTerminal),
+    [customCommands, excludeTerminal, filter]
+  )
 
   const handleHover = useCallback(
     (index: number) => dispatchGlobal({ index, type: 'set-modal-selection-index' }),
     []
   )
 
-  const worktreeItems = useMemo<PickerItem[]>(
-    () => [
-      ...worktrees.map((worktree, index) => {
+  const items = useMemo<PickerItem[]>(
+    () =>
+      filtered.map((option, index) => {
         const active = index === selectedIndex
-        const label = worktree.branch ?? worktree.name
-        const blockedReason = getDeleteBlockedReason({ currentSessionId, worktree, worktrees })
-        const canDelete = blockedReason == null || blockedReason === ''
+        const customCmd = customCommands[option.id]
         return {
-          key: worktree.id,
+          key: option.id,
           onClick: () => {
             dispatchGlobal({ index, type: 'set-modal-selection-index' })
             runSideEffectGlobal({ type: 'launch-selected-assistant' })
           },
-          onDelete:
-            active && canDelete && currentSessionId != null && currentSessionId !== ''
-              ? () => {
-                  dispatchGlobal({ index, type: 'set-modal-selection-index' })
-                  runSideEffectGlobal({
-                    force: false,
-                    sessionId: currentSessionId,
-                    type: 'delete-worktree',
-                    worktreeId: worktree.id,
-                  })
-                }
-              : undefined,
+          onEdit: () =>
+            dispatchGlobal({ assistantId: option.id, type: 'open-edit-custom-command' }),
           subtitle: (
             <box flexDirection="column">
-              <text fg={t.textMuted}>{worktree.path}</text>
-              <text fg={t.textMuted}>{worktree.source}</text>
+              <text fg={t.textMuted}>{option.description}</text>
+              {customCmd != null && customCmd !== '' ? (
+                <text fg={t.primary}>{customCmd}</text>
+              ) : null}
             </box>
           ),
-          title: <text fg={active ? t.text : t.textMuted}>{label}</text>,
+          title: <text fg={active ? t.text : t.textMuted}>{option.label}</text>,
         }
       }),
-      {
-        key: '__create-worktree__',
-        onClick: () => {
-          dispatchGlobal({ type: 'enter-new-tab-worktree-create' })
-          runSideEffectGlobal({ type: 'load-new-tab-base-branches' })
-        },
-        subtitle: <text fg={t.textMuted}>Create an Aimux temp worktree</text>,
-        title: <text fg={createWorktree ? t.text : t.textMuted}>Create new worktree</text>,
-      },
-    ],
-    [createWorktree, currentSessionId, selectedIndex, t, worktrees]
-  )
-
-  const noneOffset = getTemplateNoneOffset(selectedAssistantId)
-  const showNoneOption = noneOffset === 1
-  const templateItems = useMemo<PickerItem[]>(() => {
-    const noneItem: PickerItem[] = showNoneOption
-      ? [
-          {
-            key: '__none__',
-            onClick: () => {
-              dispatchGlobal({ index: 0, type: 'set-modal-selection-index' })
-              runSideEffectGlobal({ type: 'launch-selected-assistant' })
-            },
-            subtitle: <text fg={t.textMuted}>Single pane — current assistant only</text>,
-            title: <text fg={selectedIndex === 0 ? t.text : t.textMuted}>None</text>,
-          },
-        ]
-      : []
-    return [
-      ...noneItem,
-      ...worktreeTemplates.map((template, idx) => {
-        const itemIndex = idx + noneOffset
-        const active = itemIndex === selectedIndex
-        const tabCount = template.tabs.length
-        const paneCount = template.tabs.reduce((sum, tab) => sum + tab.panes.length, 0)
-        return {
-          key: template.id,
-          onClick: () => {
-            dispatchGlobal({ index: itemIndex, type: 'set-modal-selection-index' })
-            runSideEffectGlobal({ type: 'launch-selected-assistant' })
-          },
-          subtitle:
-            template.description != null && template.description !== '' ? (
-              <text fg={t.textMuted}>{template.description}</text>
-            ) : (
-              <text fg={t.textMuted}>
-                {tabCount} tab{tabCount === 1 ? '' : 's'}, {paneCount} pane
-                {paneCount === 1 ? '' : 's'}
-              </text>
-            ),
-          title: <text fg={active ? t.text : t.textMuted}>{template.name}</text>,
-        }
-      }),
-    ]
-  }, [noneOffset, selectedIndex, showNoneOption, t, worktreeTemplates])
-
-  const showShortcutEntry = allowTemplateShortcut && worktreeTemplates.length > 0
-  const items = useMemo<PickerItem[]>(() => {
-    const assistantItems: PickerItem[] = filtered.map((option, index) => {
-      const active = index === selectedIndex
-      const customCmd = customCommands[option.id]
-      return {
-        key: option.id,
-        onClick: () => dispatchGlobal({ assistantId: option.id, type: 'select-new-tab-assistant' }),
-        onEdit: () => dispatchGlobal({ assistantId: option.id, type: 'open-edit-custom-command' }),
-        subtitle: (
-          <box flexDirection="column">
-            <text fg={t.textMuted}>{option.description}</text>
-            {customCmd != null && customCmd !== '' ? <text fg={t.primary}>{customCmd}</text> : null}
-          </box>
-        ),
-        title: <text fg={active ? t.text : t.textMuted}>{option.label}</text>,
-      }
-    })
-    if (!showShortcutEntry) return assistantItems
-    const shortcutIndex = filtered.length
-    const shortcutActive = shortcutIndex === selectedIndex
-    return [
-      ...assistantItems,
-      {
-        key: TEMPLATE_SHORTCUT_KEY,
-        onClick: () => {
-          dispatchGlobal({ index: shortcutIndex, type: 'set-modal-selection-index' })
-          dispatchGlobal({ type: 'enter-new-tab-template-shortcut' })
-        },
-        subtitle: (
-          <text fg={t.textMuted}>Create a worktree and pick a template — no assistant step</text>
-        ),
-        title: <text fg={shortcutActive ? t.text : t.textMuted}>Worktree from template…</text>,
-      },
-    ]
-  }, [customCommands, filtered, showShortcutEntry, selectedIndex, t])
-
-  const baseItems = useMemo<FormOptionItem[]>(
-    () =>
-      buildBaseRefOptions(worktrees, baseBranches, baseQuery).map((option) => ({
-        key: option.ref,
-        leading: (
-          <text fg={option.kind === 'worktree' ? t.warning : t.textMuted}>
-            {option.kind === 'worktree' ? '\u{e728}' : '\u{e702}'}
-          </text>
-        ),
-        subtitle:
-          option.kind === 'worktree' ? (
-            <text fg={t.textMuted}>worktree: {option.detail}</text>
-          ) : null,
-        title: (active) => <text fg={active ? t.text : t.textMuted}>{option.label}</text>,
-      })),
-    [baseBranches, baseQuery, t, worktrees]
+    [customCommands, filtered, selectedIndex, t]
   )
 
   if (editingCommand !== null) {
@@ -264,142 +88,24 @@ export function NewTabModal({
     )
   }
 
-  if (step === 'template') {
-    return (
-      <Picker
-        title="Pick worktree template"
-        keybindsModeId="modal.new-tab.command-edit"
-        width={uiTokens.modalWidth.md}
-        gap={1}
-        filter={null}
-        items={templateItems}
-        selectedIndex={selectedIndex}
-        emptyState={<text fg={t.textMuted}>No templates configured.</text>}
-        onHover={handleHover}
-        footer={
-          <box flexDirection="column">
-            <text fg={t.textMuted}>Step 4/4: choose template</text>
-            <text fg={t.textMuted}>Enter launches, Esc returns to worktree settings</text>
-          </box>
-        }
-      />
-    )
-  }
-
-  if (step === 'worktree-create') {
-    const selectedAssistant =
-      options.find((option) => option.id === selectedAssistantId) ?? options[0]
-    const baseActive = activeField === 'base'
-    return (
-      <Form
-        title={`New worktree: ${selectedAssistant?.label ?? 'assistant'}`}
-        keybindsModeId="modal.new-tab.command-edit"
-        width={uiTokens.modalWidth.xl}
-      >
-        <box flexDirection="column" gap={1}>
-          <TextField
-            active={activeField === 'worktree-name'}
-            label="Worktree name"
-            value={worktreeName}
-            cursorPos={activeField === 'worktree-name' ? cursorPos : undefined}
-            placeholder="my-feature"
-          />
-          <box flexDirection="column">
-            <TextField
-              active={activeField === 'branch-name'}
-              label="Branch name"
-              value={branchName}
-              cursorPos={activeField === 'branch-name' ? cursorPos : undefined}
-              placeholder="aimux/my-feature"
-            />
-            {branchError != null && branchError !== '' ? (
-              <text fg={t.error}>{branchError}</text>
-            ) : null}
-          </box>
-          <AutoComplete
-            active={baseActive}
-            label="Base (fork from)"
-            placeholder="branch or worktree to fork from..."
-            value={baseQuery}
-            displayValue={baseRef !== '' ? baseRef : 'current branch'}
-            items={baseItems}
-            selectedIndex={selectedIndex}
-            cursorPos={baseActive ? cursorPos : undefined}
-            maxVisibleRows={6}
-            onHover={handleHover}
-            emptyState={<text fg={t.textMuted}>No branches found</text>}
-          />
-          <text fg={t.textMuted}>Step 3/3: configure new worktree · Tab switches fields</text>
-        </box>
-      </Form>
-    )
-  }
-
-  if (step === 'worktree') {
-    const selectedAssistant =
-      options.find((option) => option.id === selectedAssistantId) ??
-      filtered[selectedIndex] ??
-      options[0]
-
-    if (worktreeDeletePrompt != null) {
-      const target = worktrees.find((worktree) => worktree.id === worktreeDeletePrompt.worktreeId)
-      const label = target?.branch ?? target?.name ?? 'this worktree'
-      return (
-        <WorktreeDeleteConfirm
-          keybindsModeId="modal.new-tab.worktree-delete-confirm"
-          reason={worktreeDeletePrompt.reason}
-          worktreeLabel={label}
-        />
-      )
-    }
-
-    const selectedWorktree = worktrees[selectedIndex]
-    const deleteBlockedReason = getDeleteBlockedReason({
-      currentSessionId,
-      worktree: selectedWorktree,
-      worktrees,
-    })
-    return (
-      <Picker
-        title={`New assistant: ${selectedAssistant?.label ?? 'assistant'}`}
-        keybindsModeId="modal.new-tab.command-edit"
-        width={uiTokens.modalWidth.md}
-        gap={1}
-        filter={null}
-        items={worktreeItems}
-        selectedIndex={selectedIndex}
-        emptyState={<text fg={t.textMuted}>No worktrees.</text>}
-        onHover={handleHover}
-        footer={
-          <box flexDirection="column">
-            {deleteBlockedReason != null && deleteBlockedReason !== '' ? (
-              <text fg={t.textMuted}>{deleteBlockedReason}</text>
-            ) : null}
-            <text fg={t.textMuted}>Step 2/2: choose worktree</text>
-            <text fg={t.textMuted}>Enter launches, Ctrl+d deletes selected worktree</text>
-          </box>
-        }
-      />
-    )
-  }
-
   return (
     <Picker
-      title="New assistant: choose assistant"
+      title="New tab: choose assistant"
       keybindsModeId="modal.new-tab.command-edit"
       width={uiTokens.modalWidth.md}
       gap={1}
       filter={filter}
-      cursorPos={activeField === 'assistant' ? cursorPos : undefined}
+      cursorPos={cursorPos}
       items={items}
       selectedIndex={selectedIndex}
       emptyState={<text fg={t.textMuted}>No matching assistants.</text>}
       onHover={handleHover}
       footer={
-        <box flexDirection="column">
-          <text fg={t.textMuted}>Step 1/2: choose assistant</text>
-          <text fg={t.textMuted}>Enter continues to worktree selection</text>
-        </box>
+        <text fg={t.textMuted}>
+          {excludeTerminal
+            ? 'Enter launches in the new workspace and sends your prompt'
+            : 'Enter launches in the active workspace'}
+        </text>
       }
     />
   )

package/src/ui/components/modals/workspace/create-workspace-modal.tsx

@@ -0,0 +1,101 @@
+import { useCallback, useMemo } from 'react'
+
+import type { WorkspaceRecord } from '../../../../state/types'
+
+import { dispatchGlobal } from '../../../../state/dispatch-ref'
+import { buildBaseRefOptions } from '../../../../state/selectors'
+import { useTheme } from '../../../theme'
+import { uiTokens } from '../../../ui-tokens'
+import { AutoComplete, Form, type FormOptionItem, TextField } from '../shared/form'
+
+/** The box is this tall from the start: a one-line slot asks for a one-line task. */
+const PROMPT_LINES = 5
+
+interface CreateWorkspaceModalProps {
+  activeField: 'prompt' | 'base'
+  prompt: string
+  branchError: string | null
+  baseQuery: string
+  baseRef: string
+  baseBranches: string[]
+  cursorPos?: number
+  selectedIndex: number
+  workspaces: WorkspaceRecord[]
+}
+
+export function CreateWorkspaceModal({
+  activeField,
+  baseBranches,
+  baseQuery,
+  baseRef,
+  branchError,
+  cursorPos,
+  prompt,
+  selectedIndex,
+  workspaces,
+}: CreateWorkspaceModalProps) {
+  const t = useTheme()
+
+  const handleHover = useCallback(
+    (index: number) => dispatchGlobal({ index, type: 'set-modal-selection-index' }),
+    []
+  )
+
+  const baseItems = useMemo<FormOptionItem[]>(
+    () =>
+      buildBaseRefOptions(workspaces, baseBranches, baseQuery).map((option) => ({
+        key: option.ref,
+        leading: (
+          <text fg={option.kind === 'workspace' ? t.warning : t.textMuted}>
+            {option.kind === 'workspace' ? '\u{e728}' : '\u{e702}'}
+          </text>
+        ),
+        subtitle:
+          option.kind === 'workspace' ? (
+            <text fg={t.textMuted}>workspace: {option.detail}</text>
+          ) : null,
+        title: (active) => <text fg={active ? t.text : t.textMuted}>{option.label}</text>,
+      })),
+    [baseBranches, baseQuery, t, workspaces]
+  )
+
+  const baseActive = activeField === 'base'
+  return (
+    <Form
+      title="New workspace"
+      keybindsModeId="modal.create-workspace"
+      width={uiTokens.modalWidth.xl}
+    >
+      <box flexDirection="column" gap={1}>
+        <box flexDirection="column">
+          <TextField
+            active={activeField === 'prompt'}
+            label="What do you want to work on?"
+            description="Sent to the assistant, and names the workspace and its branch."
+            value={prompt}
+            cursorPos={activeField === 'prompt' ? cursorPos : undefined}
+            placeholder="Describe the task..."
+            minLines={PROMPT_LINES}
+          />
+          {branchError != null && branchError !== '' ? (
+            <text fg={t.error}>{branchError}</text>
+          ) : null}
+        </box>
+        <AutoComplete
+          active={baseActive}
+          label="Base (fork from)"
+          placeholder="branch or workspace to fork from..."
+          value={baseQuery}
+          displayValue={baseRef !== '' ? baseRef : 'current branch'}
+          items={baseItems}
+          selectedIndex={selectedIndex}
+          cursorPos={baseActive ? cursorPos : undefined}
+          maxVisibleRows={6}
+          onHover={handleHover}
+          emptyState={<text fg={t.textMuted}>No branches found</text>}
+        />
+        <text fg={t.textMuted}>Ctrl+Enter newline · Tab picks a base · Enter creates</text>
+      </box>
+    </Form>
+  )
+}

package/src/ui/components/modals/{worktree/worktree-move-confirm-modal.tsx → workspace/workspace-move-confirm-modal.tsx}

@@ -2,7 +2,7 @@ import { useTheme } from '../../../theme'
 import { uiTokens } from '../../../ui-tokens'
 import { Form } from '../shared/form'
 
-interface WorktreeMoveConfirmModalProps {
+interface WorkspaceMoveConfirmModalProps {
   variant: 'stash-target' | 'keep-conflicts'
   files: string[]
   sourceLabel: string
@@ -12,17 +12,17 @@ interface WorktreeMoveConfirmModalProps {
 const MAX_LISTED_FILES = 8
 
 /**
- * Confirmation dialog after a recoverable move failure. Both worktrees are
+ * Confirmation dialog after a recoverable move failure. Both workspaces are
  * already back in their original state; confirming re-runs the move with the
  * flag matching the variant (stash the target's changes / keep the conflict
  * markers in the target).
  */
-export function WorktreeMoveConfirmModal({
+export function WorkspaceMoveConfirmModal({
   files,
   sourceLabel,
   targetLabel,
   variant,
-}: WorktreeMoveConfirmModalProps) {
+}: WorkspaceMoveConfirmModalProps) {
   const t = useTheme()
   const listed = files.slice(0, MAX_LISTED_FILES)
   const remaining = files.length - listed.length
@@ -30,7 +30,7 @@ export function WorktreeMoveConfirmModal({
   return (
     <Form
       title={isStash ? 'Target has conflicting changes' : 'Move hit conflicts'}
-      keybindsModeId="modal.worktree-move-confirm"
+      keybindsModeId="modal.workspace-move-confirm"
       width={uiTokens.modalWidth.md}
       footer={
         <text fg={t.textMuted}>

package/src/ui/components/modals/{worktree/worktree-move-modal.tsx → workspace/workspace-move-modal.tsx}

@@ -1,21 +1,21 @@
 import { useCallback, useMemo } from 'react'
 
-import type { ModalWorktreeMove, WorktreeRecord } from '../../../../state/types'
+import type { ModalWorkspaceMove, WorkspaceRecord } from '../../../../state/types'
 
 import { dispatchGlobal } from '../../../../state/dispatch-ref'
-import { formatDivergence } from '../../../../state/session-worktrees'
+import { formatDivergence } from '../../../../state/project-workspaces'
 import { useTheme } from '../../../theme'
 import { uiTokens } from '../../../ui-tokens'
 import { ListItem } from '../../primitives/list-item'
 import { ModalShell } from '../shared/modal-shell'
 
-interface WorktreeMoveModalProps {
+interface WorkspaceMoveModalProps {
   deleteSource: boolean
   divergence: Record<string, { ahead: number; behind: number }>
   selectedIndex: number
-  sourceWorktreeId: string
-  stats: ModalWorktreeMove['stats']
-  worktrees: WorktreeRecord[]
+  sourceWorkspaceId: string
+  stats: ModalWorkspaceMove['stats']
+  workspaces: WorkspaceRecord[]
 }
 
 const MOVE_HINTS: [key: string, label: string][] = [
@@ -25,37 +25,37 @@ const MOVE_HINTS: [key: string, label: string][] = [
   ['esc', 'cancel'],
 ]
 
-export function WorktreeMoveModal({
+export function WorkspaceMoveModal({
   deleteSource,
   divergence,
   selectedIndex,
-  sourceWorktreeId,
+  sourceWorkspaceId,
   stats,
-  worktrees,
-}: WorktreeMoveModalProps) {
+  workspaces,
+}: WorkspaceMoveModalProps) {
   const t = useTheme()
   const source = useMemo(
-    () => worktrees.find((w) => w.id === sourceWorktreeId),
-    [sourceWorktreeId, worktrees]
+    () => workspaces.find((w) => w.id === sourceWorkspaceId),
+    [sourceWorkspaceId, workspaces]
   )
   const targets = useMemo(
-    () => worktrees.filter((w) => w.id !== sourceWorktreeId),
-    [sourceWorktreeId, worktrees]
+    () => workspaces.filter((w) => w.id !== sourceWorkspaceId),
+    [sourceWorkspaceId, workspaces]
   )
   const sourceLabel =
-    source?.branch != null && source.branch !== '' ? source.branch : (source?.name ?? 'worktree')
+    source?.branch != null && source.branch !== '' ? source.branch : (source?.name ?? 'workspace')
   // What the move would carry: commits ahead of the fork point (when known) plus
   // uncommitted files, loaded async after the modal opens.
   const sourcePreview = useMemo(() => {
     const parts: string[] = []
-    const ahead = divergence[sourceWorktreeId]?.ahead ?? 0
+    const ahead = divergence[sourceWorkspaceId]?.ahead ?? 0
     if (ahead > 0) parts.push(`${ahead} commit(s)`)
     if (stats.kind === 'ready') {
-      const dirty = stats.dirtyFiles[sourceWorktreeId] ?? 0
+      const dirty = stats.dirtyFiles[sourceWorkspaceId] ?? 0
       if (dirty > 0) parts.push(`${dirty} uncommitted file(s)`)
     }
     return parts.join(' · ')
-  }, [divergence, sourceWorktreeId, stats])
+  }, [divergence, sourceWorkspaceId, stats])
   const handleSelectIndex = useCallback(
     (index: number) => dispatchGlobal({ index, type: 'set-modal-selection-index' }),
     []
@@ -63,7 +63,7 @@ export function WorktreeMoveModal({
   return (
     <ModalShell
       title={`Move ${sourceLabel} →`}
-      keybindsModeId="modal.worktree-move"
+      keybindsModeId="modal.workspace-move"
       width={uiTokens.modalWidth.md}
       footer={
         <box flexDirection="column" gap={1} marginTop={1}>
@@ -87,18 +87,20 @@ export function WorktreeMoveModal({
       <box flexDirection="column" marginTop={1}>
         {sourcePreview !== '' ? <text fg={t.textMuted}>will move: {sourcePreview}</text> : null}
         {targets.length === 0 ? (
-          <text fg={t.textMuted}>No other worktree to move into.</text>
+          <text fg={t.textMuted}>No other workspace to move into.</text>
         ) : (
-          targets.map((worktree, index) => {
+          targets.map((workspace, index) => {
             const active = index === selectedIndex
             const label =
-              worktree.branch != null && worktree.branch !== '' ? worktree.branch : worktree.name
-            const ahead = formatDivergence(divergence[worktree.id])
-            const dirty = stats.kind === 'ready' && (stats.dirtyFiles[worktree.id] ?? 0) > 0
+              workspace.branch != null && workspace.branch !== ''
+                ? workspace.branch
+                : workspace.name
+            const ahead = formatDivergence(divergence[workspace.id])
+            const dirty = stats.kind === 'ready' && (stats.dirtyFiles[workspace.id] ?? 0) > 0
             return (
               <ListItem
-                key={worktree.id}
-                id={worktree.id}
+                key={workspace.id}
+                id={workspace.id}
                 index={index}
                 active={active}
                 onHoverIndex={handleSelectIndex}
@@ -106,7 +108,7 @@ export function WorktreeMoveModal({
                 title={
                   <text fg={active ? t.text : t.textMuted} wrapMode="none">
                     {label}
-                    {worktree.source === 'primary' ? ' (primary)' : ''}
+                    {workspace.source === 'primary' ? ' (primary)' : ''}
                     {ahead !== '' ? ` ${ahead}` : ''}
                     {dirty ? <span fg={t.warning}> ●</span> : null}
                   </text>