@ssebastien/tcmd 0.1.3 → 0.1.4

package/src/js/tcmd/core/commands.js

@@ -10,14 +10,15 @@
 // source of truth for every presentation layer.
 //
 // Commands carry presentation metadata:
-// - `kind`: "ui" for UI-level actions; the command palette lists UI actions by
-//   default (scripting operations live in core/operations.js).
+// - `kind`: "ui" for UI-level actions; the command panel lists the visible UI
+//   actions alongside the CLI operations (see core/panel.js).
 // - `bar`: true when the command appears in the command bar's key hints.
-// - `hidden`: true for internal commands that never show in the palette.
+// - `hidden`: true for internal commands that never show in the panel.
 
 import { basename, parent as parentOf } from "./path.js"
-import { PANEL_FOCUS, argvFor, bindingAt, missingArg, rowAt, withToggledItem } from "./panel.js"
+import { PANEL_FOCUS, argvFor, bindingAt, missingBinding, rowAt, withArgValue, withToggledItem } from "./panel.js"
 import { clampCursor, moveCursor } from "./selection.js"
+import { currentPane } from "./pane.js"
 import { runLine } from "./script.js"
 import { getOperation, runOperation } from "./operations.js"
 
@@ -27,24 +28,6 @@ import { getOperation, runOperation } from "./operations.js"
 const PAGE = 10
 const JUMP = 5
 
-// Function: PALETTE_KEYS
-// Command-bar hints shown while the command palette is open.
-const PALETTE_KEYS = [
-	{ id: null, title: "Navigate", keys: "↑/↓" },
-	{ id: null, title: "Complete", keys: "Tab" },
-	{ id: null, title: "Run", keys: "Enter", primary: true },
-	{ id: null, title: "Close", keys: "Esc" },
-]
-
-// Constant: SCRIPT_KEYS
-// Command-bar hints for scripting mode (no UI navigation, only the palette
-// itself).
-const SCRIPT_KEYS = [
-	{ id: null, title: "Complete", keys: "Tab" },
-	{ id: null, title: "Run", keys: "Enter", primary: true },
-	{ id: null, title: "Close", keys: "Esc" },
-]
-
 // Constant: FILTER_KEYS
 // Command-bar hints shown while a pane filter is capturing input.
 const FILTER_KEYS = [
@@ -73,11 +56,24 @@ const BOOKMARK_LIST_KEYS = [
 const PANEL_HINT_KEYS = [
 	{ id: null, title: "Command", keys: "↑/↓" },
 	{ id: null, title: "Arg", keys: "⇥" },
+	{ id: null, title: "Browse", keys: "^O" },
 	{ id: null, title: "Toggle", keys: "Spc" },
 	{ id: null, title: "Run", keys: "↵", primary: true },
 	{ id: null, title: "Close", keys: "Esc" },
 ]
 
+// Constant: PANEL_PICK_KEYS
+// Command-bar hints while the panel's file picker owns the keyboard.
+const PANEL_PICK_KEYS = [
+	{ id: null, title: "Filter", keys: "type" },
+	{ id: null, title: "Row", keys: "↑/↓" },
+	{ id: null, title: "Open", keys: "→" },
+	{ id: null, title: "Choose", keys: "↵", primary: true },
+	{ id: null, title: "Here", keys: "^↵" },
+	{ id: null, title: "Up", keys: "⌫" },
+	{ id: null, title: "Back", keys: "Esc" },
+]
+
 const commands = [
 	{
 		id: "nav.up",
@@ -159,7 +155,21 @@ const commands = [
 		bar: true,
 		primary: true,
 		run(session) {
-			return pane(session).open()
+			// The entry under the *focused* pane's cursor decides where the
+			// current directory goes: a directory descends into it. On an
+			// auxiliary column (parent/preview) that means the current pane
+			// follows the selection, which is what keeps the mirror in step.
+			const focused = pane(session)
+			const entry = focused.currentEntry()
+			if (!entry) return
+			const current = currentPane(session)
+			if (entry.isDir) return current.navigate(entry.path)
+			// A file outside the current pane pins the inspector on it.
+			if (focused !== current) {
+				session.previewTarget.set(entry)
+				session.showPreview.set(true)
+			}
+			return undefined
 		},
 	},
 	{
@@ -169,7 +179,10 @@ const commands = [
 		kind: "ui",
 		bar: true,
 		run(session) {
-			return pane(session).up()
+			// Stepping up always moves the current directory: the parent
+			// column mirrors it, so navigating that column itself would
+			// break the mirror.
+			return currentPane(session).up()
 		},
 	},
 	{
@@ -178,7 +191,7 @@ const commands = [
 		keys: "Esc",
 		kind: "ui",
 		run(session) {
-			return pane(session).back()
+			return currentPane(session).back()
 		},
 	},
 	{
@@ -187,7 +200,7 @@ const commands = [
 		keys: "⇧Esc",
 		kind: "ui",
 		run(session) {
-			return pane(session).forward()
+			return currentPane(session).forward()
 		},
 	},
 	{
@@ -207,7 +220,23 @@ const commands = [
 		kind: "ui",
 		bar: true,
 		run(session) {
-			session.active.set(session.active.value === "left" ? "right" : "left")
+			// Cycle through the columns the current view mode shows:
+			// source ⇄ destination in commander, parent → current → preview
+			// in explorer. Focus parked on a column that is not in the cycle
+			// (the inspector in commander) lands on the other side.
+			const current = session.currentId.value
+			const order =
+				session.viewMode.value === "explorer"
+					? session.showPreview.value
+						? ["parent", current, "preview"]
+						: ["parent", current]
+					: ["left", "right"]
+			const at = order.indexOf(session.active.value)
+			const next =
+				at >= 0
+					? order[(at + 1) % order.length]
+					: order.find((paneId) => paneId !== current) ?? order[0]
+			session.active.set(next)
 		},
 	},
 	{
@@ -321,7 +350,7 @@ const commands = [
 			const items = session.bookmarkItems.value
 			const item = items[clampCursor(session.bookmarkIndex.value, items.length)]
 			if (!item) return
-			const target = session.panes[session.active.value]
+			const target = currentPane(session)
 			const path = item.path
 			// Resolve the kind when it is unknown (legacy path-only bookmark).
 			let isDir = item.isDir
@@ -353,13 +382,24 @@ const commands = [
 	},
 	{
 		id: "list.cursor",
-		title: "Set cursor",
+		title: "Select row",
 		kind: "ui",
 		hidden: true,
 		run(session, payload) {
 			const target = payload?.paneId ? session.panes[payload.paneId] : pane(session)
 			activate(session, payload?.paneId)
-			target.cursor.set(clampCursor(payload?.index ?? 0, target.entries.value.length))
+			const index = payload?.index ?? 0
+			target.cursor.set(clampCursor(index, target.entries.value.length))
+			// In the explorer the parent and preview columns are mirrors: a
+			// click on one of their rows retargets the current directory
+			// instead of only moving that column's cursor (see
+			// `retargetFromParent` / `retargetFromPreview`). Focus stays on the
+			// clicked column; the pane body's own `pane:activate` agrees.
+			if (session.viewMode.value !== "explorer") return
+			if (payload?.paneId === "parent") return retargetFromParent(session, target, index)
+			if (payload?.paneId === "preview" && isColumnPane(session, "preview")) {
+				return retargetFromPreview(session, target, index)
+			}
 		},
 	},
 	{
@@ -377,9 +417,11 @@ const commands = [
 		kind: "ui",
 		hidden: true,
 		run(session, payload) {
-			const target = payload?.paneId ? session.panes[payload.paneId] : pane(session)
+			// A breadcrumb click focuses its column, then lands the current
+			// directory there: the auxiliary columns mirror it, so their
+			// crumbs navigate the pane they follow.
 			activate(session, payload?.paneId)
-			return target.navigate(payload?.path)
+			return currentPane(session).navigate(payload?.path)
 		},
 	},
 	{
@@ -392,6 +434,33 @@ const commands = [
 			session.showPreview.set(!session.showPreview.value)
 		},
 	},
+	{
+		id: "view.maximize",
+		title: "Maximize preview",
+		keys: "⇧V",
+		kind: "ui",
+		run(session) {
+			// The inspector takes the whole pane row, or gives it back. The
+			// preference cells are untouched, so the previous layout — pane
+			// widths, focus and whether the preview was even shown — returns
+			// untouched on the next press.
+			session.previewFull.set(!session.previewFull.value)
+		},
+	},
+	{
+		id: "view.toggleMode",
+		title: "Explorer view",
+		keys: "t",
+		kind: "ui",
+		bar: true,
+		run(session) {
+			// Flip the workspace between the two-pane commander and the
+			// three-column explorer (parent · current · preview). Focus on a
+			// column that does not exist in the target mode is handed back to
+			// the pane it was following (see the guard effect in the session).
+			session.viewMode.set(session.viewMode.value === "explorer" ? "commander" : "explorer")
+		},
+	},
 	{
 		id: "file.open",
 		title: "Open file",
@@ -414,36 +483,33 @@ const commands = [
 				session.notice.set({ kind: "warning", text: "no file to edit" })
 				return
 			}
-			return session.os.edit(entry.path).then(() => session.panes[session.active.value].refresh())
+			return session.os.edit(entry.path).then(() => currentPane(session).refresh())
 		},
 	},
-	// Command panel (`:`/`m`): the structured Commando view over the
-	// operations. Lifecycle, then navigation, then draft editing, then run.
+	// Command panel (`:`): the one entry point, over both the CLI operations
+	// and the TinyCmd actions. Lifecycle, then navigation, then draft editing,
+	// then run.
 	{
-		id: "panel.toggle",
+		id: "panel.open",
 		title: "Commands",
-		keys: "m",
+		keys: ":",
 		kind: "ui",
 		bar: true,
 		run(session) {
-			togglePanel(session)
+			openPanel(session)
 		},
 	},
 	{
-		id: "panel.open",
-		title: "Commands",
-		keys: ":",
+		id: "panel.shell",
+		title: "Shell command",
 		kind: "ui",
 		hidden: true,
 		run(session) {
-			// `:` is the natural "command" key: open the structured panel on
-			// renderers that have it, and fall back to the flat script palette
-			// on those that do not (the web view).
-			if (!session.panelEnabled?.value) {
-				openPalette(session, "script", "")
-				return
-			}
-			openPanel(session)
+			// `!` is the "run a shell command" reflex: land on the `run`
+			// operation with its raw CMD field already owning the keyboard. The
+			// field starts empty — `!` is a script-line alias, not part of the
+			// command itself.
+			openPanel(session, { name: "run", focus: PANEL_FOCUS.ARGS })
 		},
 	},
 	{
@@ -492,8 +558,9 @@ const commands = [
 		kind: "ui",
 		hidden: true,
 		run(session, payload) {
-			// Tab cycles the focus ring: the command (query) then each argument
-			// header, wrapping at both ends. Shift-Tab walks it backwards.
+			// Tab cycles the focus ring: the command filter then each argument
+			// header, wrapping at both ends (an item row is reached with the
+			// arrows). Shift-Tab walks it backwards.
 			const delta = payload?.delta === -1 ? -1 : 1
 			const rows = session.panelRows.value
 			const headers = []
@@ -577,165 +644,194 @@ const commands = [
 			if (!row) return
 			const draft = session.panelDraft.value
 			if (row.type === "item") {
-				session.panelDraft.set(withToggledItem(draft, row.argIndex, row.itemIndex))
+				session.panelDraft.set(withToggledItem(draft, row.argIndex, row.itemIndex, row.multi !== false))
 				return
 			}
 			// An argument header toggles its whole selection: select all when
-			// some are off, clear when all are on.
+			// some are off, clear when all are on. A single-path argument is a
+			// radio list, so its header has nothing to toggle.
 			const binding = bindingAt(draft, row.argIndex)
-			if (!binding || binding.kind !== "selection") return
+			if (!binding || binding.kind !== "selection" || binding.multi !== true) return
 			const all = (binding.items ?? []).length > 0 && (binding.items ?? []).every((item) => item.selected)
 			const items = (binding.items ?? []).map((item) => ({ ...item, selected: !all }))
 			session.panelDraft.set(draft.map((b) => (b.index === row.argIndex ? { ...b, items } : b)))
 		},
 	},
+	// File picker: a sub-mode of the panel that browses the filesystem for a
+	// path/destination argument. Lifecycle then navigation then choose.
 	{
-		id: "panel.run",
-		title: "Run command",
+		id: "panel.browse",
+		title: "Browse for a path",
 		kind: "ui",
 		hidden: true,
-		async run(session) {
-			const op = session.panelOperation.value
-			if (!op) return
-			// An unrunnable draft is refused with the missing argument's name —
-			// the `«NAME»` the preview already flags — instead of the generic
-			// usage error `runOperation` would produce.
-			const missing = missingArg(session.panelDraft.value)
-			if (missing) {
-				session.notice.set({ kind: "error", text: `${op.name}: fill in «${missing}»` })
-				return
-			}
-			const status = await runOperation(session, op, argvFor(session.panelDraft.value))
-			// A confirm keeps the panel open until the user answers; a run
-			// closes it. Errors stay open so the draft can be fixed.
-			if (status === "ran") closePanel(session)
+		run(session) {
+			// Browse the focused argument when it is pickable, else the first
+			// pickable argument of the operation; a no-op when there is none.
+			const focused = focusedBinding(session)
+			const binding = focused?.picker === true ? focused : firstPickableBinding(session)
+			if (!binding) return undefined
+			return openPicker(session, binding.index, binding)
 		},
 	},
 	{
-		id: "panel.cancel",
-		title: "Close command panel",
+		id: "panel.pick.up",
+		title: "Previous picker row",
 		kind: "ui",
 		hidden: true,
 		run(session) {
-			closePanel(session)
+			const length = session.pickerRows.value.length
+			session.panelRowIndex.set(moveCursor(session.panelRowIndex.value, -1, length))
 		},
 	},
 	{
-		id: "palette.toggle",
-		title: "Palette",
-		keys: "^P",
+		id: "panel.pick.down",
+		title: "Next picker row",
 		kind: "ui",
-		bar: true,
+		hidden: true,
 		run(session) {
-			if (session.paletteOpen.value) {
-				closePalette(session)
-				return
-			}
-			openPalette(session, "ui", "")
+			const length = session.pickerRows.value.length
+			session.panelRowIndex.set(moveCursor(session.panelRowIndex.value, 1, length))
 		},
 	},
 	{
-		id: "palette.script",
-		title: "Script",
+		id: "panel.pick.setCursor",
+		title: "Highlight picker row",
 		kind: "ui",
-		run(session) {
-			openPalette(session, "script", "")
+		hidden: true,
+		run(session, payload) {
+			if (payload?.index !== undefined) session.panelRowIndex.set(Math.max(0, payload.index))
 		},
 	},
 	{
-		id: "palette.run",
-		title: "Run command",
-		keys: "!",
+		id: "panel.pick.enter",
+		title: "Choose picker row",
 		kind: "ui",
+		hidden: true,
 		run(session) {
-			openPalette(session, "script", "!")
+			const entry = pickerEntry(session)
+			if (!entry) return undefined
+			// A directory descends unless this is a destination picker, where
+			// every row is already a valid choice.
+			if (entry.isDir && session.panelPickerMode.value !== "dir") {
+				return descendPicker(session, entry.path)
+			}
+			return choosePicker(session, entry.path)
 		},
 	},
 	{
-		id: "filter.start",
-		title: "Filter",
-		keys: "/",
+		id: "panel.pick.descend",
+		title: "Open the picker's directory",
 		kind: "ui",
-		bar: true,
+		hidden: true,
 		run(session) {
-			session.filtering.set(session.active.value)
+			const entry = pickerEntry(session)
+			if (entry?.isDir) return descendPicker(session, entry.path)
+			return undefined
 		},
 	},
 	{
-		id: "filter.accept",
-		title: "Keep filter",
+		id: "panel.pick.parent",
+		title: "Picker parent directory",
 		kind: "ui",
 		hidden: true,
-		run(session) {
-			session.filtering.set(null)
+		async run(session) {
+			session.pickerQuery.set("")
+			await session.pickerPane.up()
+			session.panelRowIndex.set(0)
 		},
 	},
 	{
-		id: "filter.clear",
-		title: "Clear filter",
+		id: "panel.pick.chooseDir",
+		title: "Choose the picker's directory",
 		kind: "ui",
 		hidden: true,
 		run(session) {
-			pane(session).clearFilter()
-			session.filtering.set(null)
+			return choosePicker(session, session.pickerPane.path.value)
 		},
 	},
 	{
-		id: "palette.up",
-		title: "Previous command",
+		id: "panel.pick.cancel",
+		title: "Leave the picker",
 		kind: "ui",
 		hidden: true,
 		run(session) {
-			movePalette(session, -1)
+			// Back to the argument column, panel still open.
+			session.panelPicking.set(false)
+			session.panelPickerArg.set(-1)
+			session.panelFocus.set(PANEL_FOCUS.ARGS)
+			session.panelRowIndex.set(0)
 		},
 	},
 	{
-		id: "palette.down",
-		title: "Next command",
+		id: "panel.run",
+		title: "Run command",
 		kind: "ui",
 		hidden: true,
-		run(session) {
-			movePalette(session, 1)
+		async run(session) {
+			const entry = session.panelEntry.value
+			if (!entry) return
+			const op = entry.op
+			const draft = session.panelDraft.value
+			// An incomplete command does not fail: a blank destination/path
+			// asks where to (the picker opens and the run resumes on a choice —
+			// explorer mode has no DST pane to default from), and any other
+			// missing argument just takes the cursor, so Enter walks the
+			// command field by field.
+			const missing = missingBinding(draft)
+			if (missing) {
+				if (missing.kind === "dest" || missing.kind === "path") {
+					session.panelPendingRun.set(true)
+					return openPicker(session, missing.index, missing)
+				}
+				focusBinding(session, missing)
+				return
+			}
+			const status = await runOperation(session, op, argvFor(draft))
+			// A confirm keeps the panel open until the user answers; a run
+			// closes it. Errors stay open so the draft can be fixed.
+			if (status === "ran") closePanel(session)
 		},
 	},
 	{
-		id: "palette.complete",
-		title: "Complete",
+		id: "panel.cancel",
+		title: "Close command panel",
 		kind: "ui",
 		hidden: true,
 		run(session) {
-			const items = session.paletteItems.value
-			const item = items[clampCursor(session.paletteIndex.value, items.length)]
-			if (item?.completion) session.paletteQuery.set(item.completion)
+			closePanel(session)
+		},
+	},
+	{
+		id: "filter.start",
+		title: "Filter",
+		keys: "/",
+		kind: "ui",
+		bar: true,
+		run(session) {
+			// A column with no filter field (the inspector, or a column the
+			// current mode does not show) hands focus to the pane it follows
+			// before the input starts capturing keystrokes.
+			if (!hasFilterField(session, session.active.value)) activate(session, session.currentId.value)
+			session.filtering.set(session.active.value)
 		},
 	},
 	{
-		id: "palette.setQuery",
-		title: "Set palette query",
+		id: "filter.accept",
+		title: "Keep filter",
 		kind: "ui",
 		hidden: true,
-		run(session, payload) {
-			session.paletteQuery.set(`${payload?.query ?? ""}`)
+		run(session) {
+			session.filtering.set(null)
 		},
 	},
 	{
-		id: "palette.submit",
-		title: "Submit palette",
+		id: "filter.clear",
+		title: "Clear filter",
 		kind: "ui",
 		hidden: true,
 		run(session) {
-			const query = `${session.paletteQuery.value ?? ""}`.trim()
-			if (!query) {
-				// Nothing to run: complete the highlighted row instead.
-				const items = session.paletteItems.value
-				const item = items[clampCursor(session.paletteIndex.value, items.length)]
-				if (item?.completion) session.paletteQuery.set(item.completion)
-				return
-			}
-			return runLine(session, query).then((status) => {
-				if (status !== "empty") closePalette(session)
-				return status
-			})
+			pane(session).clearFilter()
+			session.filtering.set(null)
 		},
 	},
 	{
@@ -772,7 +868,7 @@ const commands = [
 	// Quit: presentation-only. The key path intercepts `app.quit` before
 	// dispatch, and the command-bar click does the same (the renderer owns
 	// exiting); the registry entry exists so the bar and the `?` reference
-	// can advertise it. Hidden from the palette, where it could only no-op.
+	// can advertise it. Hidden from the panel, where it could only no-op.
 	{
 		id: "app.quit",
 		title: "Quit",
@@ -799,34 +895,27 @@ function getCommand(id) {
 	return null
 }
 
-// Function: getPaletteCommands
-// Commands the command palette lists in UI mode: user-visible UI actions.
-function getPaletteCommands() {
-	return commands.filter((command) => !command.hidden && (command.kind ?? "ui") === "ui")
-}
-
 // Function: getCommandBarItems
-// Command-bar rows for the current context: the palette's key hints while it
-// is open (scripting mode has its own), the filter hints while a pane filter is
-// capturing input, the `bar`-flagged UI commands otherwise (keymap order).
-function getCommandBarItems(paletteOpen, paletteMode, filtering, bookmarkOpen, bookmarkMode, panelOpen) {
-	if (panelOpen) return PANEL_HINT_KEYS
+// Command-bar rows for the current context: the panel's key hints while it is
+// open, the filter hints while a pane filter is capturing input, the bookmark
+// hints while the picker owns the keyboard, the `bar`-flagged UI commands
+// otherwise (keymap order). Takes the context as named fields — four adjacent
+// flags are too easy to transpose.
+function getCommandBarItems({ filtering, bookmarkOpen, bookmarkMode, panelOpen, panelPicking }) {
+	if (panelOpen) return panelPicking ? PANEL_PICK_KEYS : PANEL_HINT_KEYS
 	if (bookmarkOpen) return bookmarkMode === "name" ? BOOKMARK_NAME_KEYS : BOOKMARK_LIST_KEYS
-	if (paletteOpen) return paletteMode === "script" ? SCRIPT_KEYS : PALETTE_KEYS
 	if (filtering) return FILTER_KEYS
-	return commands.filter((command) => command.bar).map(commandRow)
+	return commands.filter((command) => command.bar).map(barRow)
 }
 
-// Function: commandRow
-// Projects a command to the small row object views render.
-function commandRow(command) {
+// Function: barRow
+// Projects a command to the small row object the command bar renders.
+function barRow(command) {
 	return {
 		id: command.id,
 		title: command.title,
 		keys: command.keys,
-		kind: command.kind ?? "ui",
 		primary: command.primary === true,
-		completion: command.completion ?? command.title,
 	}
 }
 
@@ -854,8 +943,33 @@ function fail(session, error) {
 	return null
 }
 
+// Function: isColumnPane
+// Whether the focused column is backed by a rendered pane. The parent column
+// only exists in explorer mode (focus is handed back on leaving it); the
+// inspector column only while it previews a directory — over a file it is a
+// read-only card with no listing to drive.
+function isColumnPane(session, paneId) {
+	if (paneId !== "preview") return paneId !== "parent" || session.viewMode.value === "explorer"
+	return Boolean(session.showPreview.value) && Boolean(session.previewEntry.value?.isDir) && !session.preview.value
+}
+
+// Function: hasFilterField
+// Whether the focused column renders a filter input. The inspector column
+// never does — its header is the preview title — so `/` hands focus to the
+// pane it shows before capturing keystrokes, the same way a nav key falls
+// back to it.
+function hasFilterField(session, paneId) {
+	return paneId !== "preview" && isColumnPane(session, paneId)
+}
+
+// Function: pane
+// The pane cursor movement, marks and reload act on: the focused column's
+// pane when it has one, else the current pane (so the inspector over a file
+// keeps scrolling the directory it is showing).
 function pane(session) {
-	return session.panes[session.active.value]
+	const focused = session.panes[session.active.value]
+	if (!focused || !isColumnPane(session, session.active.value)) return currentPane(session)
+	return focused
 }
 
 // Function: activate
@@ -866,16 +980,50 @@ function activate(session, paneId) {
 	if (session.active.value !== paneId) session.active.set(paneId)
 }
 
+// Function: retargetFromParent
+// A click on a row of the explorer's parent column retargets the current
+// directory: a directory becomes it, a file opens its containing directory
+// with the file selected so the inspector previews it. Both moves are
+// recorded, so Esc steps back to where the click came from.
+function retargetFromParent(session, parent, index) {
+	const entries = parent.entries.value
+	const entry = entries[clampCursor(index, entries.length)]
+	if (!entry) return
+	const current = currentPane(session)
+	if (entry.isDir) return current.navigate(entry.path)
+	return current
+		.navigate(parent.path.value, { cursorPath: entry.path })
+		.then(() => pinPreview(session, current))
+}
+
+// Function: retargetFromPreview
+// A click on a row of the explorer's preview column promotes the previewed
+// directory to the current one, selecting the clicked entry: a directory then
+// previews its own contents (the next click descends further), a file previews
+// as a card.
+function retargetFromPreview(session, preview, index) {
+	const entries = preview.entries.value
+	const entry = entries[clampCursor(index, entries.length)]
+	if (!entry) return
+	const current = currentPane(session)
+	return current.navigate(preview.path.value, { cursorPath: entry.path }).then(() => {
+		if (!entry.isDir) pinPreview(session, current)
+	})
+}
+
+// Function: pinPreview
+// Points the inspector at the pane's cursor entry, so a file a click just
+// revealed previews even if the follow effect lags the navigation.
+function pinPreview(session, pane) {
+	session.previewTarget.set(pane.currentEntry() ?? null)
+	session.showPreview.set(true)
+}
+
 function bump(session, delta) {
 	const p = pane(session)
 	p.cursor.set(moveCursor(p.cursor.value, delta, p.entries.value.length))
 }
 
-function movePalette(session, delta) {
-	const length = session.paletteItems.value.length
-	session.paletteIndex.set(moveCursor(session.paletteIndex.value, delta, length))
-}
-
 function moveBookmark(session, delta) {
 	const length = session.bookmarkItems.value.length
 	session.bookmarkIndex.set(moveCursor(session.bookmarkIndex.value, delta, length))
@@ -885,46 +1033,140 @@ function closeBookmark(session) {
 	session.bookmarkOpen.set(false)
 }
 
-function openPanel(session) {
+// Function: focusedBinding
+// The draft binding under the right pane's cursor (an argument header or one
+// of its item rows), or null on the command filter.
+function focusedBinding(session) {
+	if (session.panelFocus.value !== PANEL_FOCUS.ARGS) return null
+	const row = rowAt(session.panelRows.value, session.panelRowIndex.value)
+	return row ? bindingAt(session.panelDraft.value, row.argIndex) : null
+}
+
+// Function: firstPickableBinding
+// The first browsable (`picker`) binding of the draft, so `^O` works from the
+// command filter too.
+function firstPickableBinding(session) {
+	return (session.panelDraft.value ?? []).find((binding) => binding.picker === true) ?? null
+}
+
+// Function: focusBinding
+// Moves the cursor onto the argument header row of the binding Enter found
+// missing.
+function focusBinding(session, binding) {
+	const rowIndex = (session.panelRows.value ?? []).findIndex(
+		(row) => row.type === "arg" && row.argIndex === binding.index,
+	)
+	session.panelFocus.set(PANEL_FOCUS.ARGS)
+	session.panelRowIndex.set(rowIndex >= 0 ? rowIndex : 0)
+}
+
+// Function: openPanel
+// Opens the command panel fresh: empty query, first entry selected, the entry
+// column focused. `options.name` selects a CLI operation by name — `!` lands on
+// `run` — and `options.focus` moves the focus ring to the argument column so a
+// raw or literal argument owns the keyboard right away.
+function openPanel(session, options = {}) {
 	session.panelQuery.set("")
 	session.panelOpIndex.set(0)
 	session.panelRowIndex.set(0)
 	session.panelFocus.set(PANEL_FOCUS.OPS)
+	session.panelPicking.set(false)
+	session.panelPickerArg.set(-1)
+	session.panelPendingRun.set(false)
 	session.panelOpen.set(true)
+	if (!options.name) return
+	// Select the operation by index rather than by query, so the filter stays
+	// empty and the list keeps its full ordering. A missing name is a bug in
+	// the caller (a renamed operation), not something to silently paper over by
+	// landing on the first entry.
+	const index = session.panelFiltered.value.findIndex((entry) => entry.name === options.name)
+	if (index < 0) throw new Error(`command panel has no entry named "${options.name}"`)
+	session.panelOpIndex.set(index)
+	if (options.focus === PANEL_FOCUS.ARGS) {
+		session.panelFocus.set(PANEL_FOCUS.ARGS)
+		session.panelRowIndex.set(0)
+	}
 }
 
-// Function: togglePanel
-// Opens the command panel, or closes it when already open. Disabled (TUI-only)
-// renderers ignore it.
-function togglePanel(session) {
-	if (!session.panelEnabled?.value) return
-	if (session.panelOpen.value) {
-		closePanel(session)
-		return
+// Function: pickerEntry
+// The entry under the picker cursor, or null (empty listing / stale cursor).
+function pickerEntry(session) {
+	const rows = session.pickerRows.value
+	return rows[clampCursor(session.panelRowIndex.value, rows.length)] ?? null
+}
+
+// Function: openPicker
+// Opens the panel's file picker on a path argument: the argument column
+// switches to a browsable listing seated on the argument's current value (a
+// directory opens there, a file opens in its parent with the file under the
+// cursor), else on the current pane's directory. Focus moves to the argument
+// column so the picker's own input owns the keyboard.
+async function openPicker(session, argIndex, binding) {
+	const mode = binding?.mode ?? "dir"
+	session.panelPickerMode.set(mode)
+	session.panelPickerArg.set(argIndex)
+	session.pickerQuery.set("")
+	session.panelPicking.set(true)
+	session.panelFocus.set(PANEL_FOCUS.ARGS)
+	let startPath = currentPane(session)?.path?.value ?? session.fs.cwd?.() ?? "/"
+	let cursorPath = null
+	const value = `${binding?.value ?? ""}`.trim()
+	if (value) {
+		const stats = await session.fs.stat(value)
+		if (stats?.isDir) startPath = value
+		else {
+			startPath = parentOf(value) ?? "/"
+			cursorPath = value
+		}
 	}
-	openPanel(session)
+	await session.pickerPane.navigate(startPath, { record: false, cursorPath })
+	const rows = session.pickerRows.value
+	const index = cursorPath ? rows.findIndex((row) => row.path === cursorPath) : -1
+	session.panelRowIndex.set(index >= 0 ? index : 0)
 }
 
-function closePanel(session) {
-	session.panelOpen.set(false)
+// Function: descendPicker
+// Moves the picker into `path`, clearing its filter and re-anchoring the
+// cursor at the top of the fresh listing.
+async function descendPicker(session, path) {
+	if (!path) return undefined
+	session.pickerQuery.set("")
+	await session.pickerPane.navigate(path, { record: false })
+	session.panelRowIndex.set(0)
+	return undefined
 }
 
-function openPalette(session, mode, query) {
-	session.paletteMode.set(mode)
-	session.paletteQuery.set(query)
-	session.paletteIndex.set(0)
-	session.paletteOpen.set(true)
+// Function: choosePicker
+// Accepts `path` as the picked value: writes it into the argument, leaves the
+// picker (the panel stays open on the argument column) and, when the picker was
+// opened to satisfy a pending run, runs the operation now.
+function choosePicker(session, path) {
+	if (path == null) return undefined
+	const argIndex = session.panelPickerArg.value
+	session.panelDraft.set(withArgValue(session.panelDraft.value, argIndex, path))
+	session.panelPicking.set(false)
+	session.panelPickerArg.set(-1)
+	session.panelFocus.set(PANEL_FOCUS.ARGS)
+	const rows = session.panelRows.value
+	const index = rows.findIndex((row) => row.type === "arg" && row.argIndex === argIndex)
+	session.panelRowIndex.set(index >= 0 ? index : 0)
+	if (session.panelPendingRun.value) {
+		session.panelPendingRun.set(false)
+		return session.dispatch("panel.run")
+	}
+	return undefined
 }
 
-function closePalette(session) {
-	session.paletteOpen.set(false)
+function closePanel(session) {
+	session.panelOpen.set(false)
 }
 
 export {
-	commandRow,
+	barRow,
+	closePanel,
 	createDispatch,
 	getCommand,
 	getCommandBarItems,
 	getCommands,
-	getPaletteCommands,
+	openPanel,
 }