@ssebastien/tcmd 0.1.3 → 0.1.7

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

@@ -10,16 +10,21 @@
 // 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).
-// - `bar`: true when the command appears in the command bar's key hints.
-// - `hidden`: true for internal commands that never show in the palette.
+// - `kind`: "ui" for UI-level actions; the command panel lists the two it can
+//   reach (the workspace-view toggle and Quit) alongside the CLI operations
+//   (see core/panel.js).
+// - `hidden`: true for internal commands that never show in the panel.
+// The default command bar is the explicit `BAR_COMMANDS` list below, in that
+// order.
 
-import { basename, parent as parentOf } from "./path.js"
-import { PANEL_FOCUS, argvFor, bindingAt, missingArg, rowAt, withToggledItem } from "./panel.js"
+import { parent as parentOf } from "./path.js"
+import { PANEL_FOCUS, argvFor, bindingAt, missingBinding, rowAt, withArgValue, withToggledItem } from "./panel.js"
+import { pickerAbsolutePath, pickerDirectoryText } from "./picker.js"
+import { hasBinaryByte, previewKind, previewSource, SNIFF_BYTES } from "./preview.js"
 import { clampCursor, moveCursor } from "./selection.js"
+import { currentPane } from "./pane.js"
 import { runLine } from "./script.js"
-import { getOperation, runOperation } from "./operations.js"
+import { getOperation, refreshPanes, runOperation } from "./operations.js"
 
 // Constant: PAGE / JUMP
 // Cursor movement steps: a page for PgUp/PgDn, a shorter jump for the
@@ -27,24 +32,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 = [
@@ -53,18 +40,12 @@ const FILTER_KEYS = [
 	{ id: null, title: "Clear", keys: "Esc" },
 ]
 
-// Constant: BOOKMARK_NAME_KEYS
-// Command-bar hints while naming a bookmark.
-const BOOKMARK_NAME_KEYS = [
-	{ id: null, title: "Save", keys: "Enter", primary: true },
-	{ id: null, title: "Cancel", keys: "Esc" },
-]
-
-// Constant: BOOKMARK_LIST_KEYS
-// Command-bar hints while picking a bookmark.
-const BOOKMARK_LIST_KEYS = [
+// Constant: BOOKMARK_KEYS
+// Command-bar hints while the bookmarks panel owns the keyboard.
+const BOOKMARK_KEYS = [
 	{ id: null, title: "Navigate", keys: "↑/↓" },
-	{ id: null, title: "Jump", keys: "Enter", primary: true },
+	{ id: null, title: "Remove", keys: "⌫/Del" },
+	{ id: null, title: "Open", keys: "Enter", primary: true },
 	{ id: null, title: "Close", keys: "Esc" },
 ]
 
@@ -73,11 +54,58 @@ 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_CONFIRM_KEYS
+// The same hints after a risky action is armed: Enter now confirms.
+const PANEL_CONFIRM_KEYS = PANEL_HINT_KEYS.map((hint) =>
+	hint.title === "Run" ? { ...hint, title: "Confirm" } : hint,
+)
+
+// Constant: PICKER_KEYS
+// Command-bar hints while the panel's file picker owns the keyboard.
+const PICKER_KEYS = [
+	{ id: null, title: "Path", keys: "type" },
+	{ id: null, title: "Row", keys: "↑/↓" },
+	{ id: null, title: "Open", keys: "→" },
+	{ id: null, title: "Go", keys: "↵", primary: true },
+	{ id: null, title: "Here", keys: "^↵" },
+	{ id: null, title: "Focus", keys: "⇥" },
+	{ id: null, title: "Back", keys: "Esc" },
+]
+
+// Constant: HISTORY_KEYS / TRASH_KEYS
+// Command-bar hints while the shared list overlay owns the keyboard.
+const HISTORY_KEYS = [
+	{ id: null, title: "Row", keys: "↑/↓" },
+	{ id: null, title: "Jump", keys: "↵", primary: true },
+	{ id: null, title: "Close", keys: "Esc" },
+]
+
+const TRASH_KEYS = [
+	{ id: null, title: "Row", keys: "↑/↓" },
+	{ id: null, title: "Restore", keys: "↵", primary: true },
+	{ id: null, title: "Close", keys: "Esc" },
+]
+
+// Constant: BAR_COMMANDS
+// The command bar's default entries, in display order. Kept as an explicit
+// list so the bar stays a short, stable set of primary actions instead of
+// every command that happens to be context-relevant.
+const BAR_COMMANDS = [
+	"panel.open",
+	"list.mark",
+	"filter.start",
+	"pane.toggle",
+	"bookmark.open",
+	"view.toggleMode",
+	"app.help",
+]
+
 const commands = [
 	{
 		id: "nav.up",
@@ -156,10 +184,26 @@ const commands = [
 		title: "Open",
 		keys: "Enter",
 		kind: "ui",
-		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 before
+			// it is opened, so the preview follows the entry that was acted on.
+			if (focused !== current) {
+				session.previewTarget.set(entry)
+				session.showPreview.set(true)
+			}
+			// A file: edit it when it is a text file the host can edit,
+			// otherwise show it fullscreen (see `openFile`).
+			return openFile(session, current, entry)
 		},
 	},
 	{
@@ -167,9 +211,11 @@ const commands = [
 		title: "Parent",
 		keys: "←",
 		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 +224,7 @@ const commands = [
 		keys: "Esc",
 		kind: "ui",
 		run(session) {
-			return pane(session).back()
+			return currentPane(session).back()
 		},
 	},
 	{
@@ -187,15 +233,14 @@ const commands = [
 		keys: "⇧Esc",
 		kind: "ui",
 		run(session) {
-			return pane(session).forward()
+			return currentPane(session).forward()
 		},
 	},
 	{
 		id: "pane.reload",
 		title: "Reload",
-		keys: "^R",
+		keys: "F5/r",
 		kind: "ui",
-		bar: true,
 		run(session) {
 			return pane(session).refresh()
 		},
@@ -205,9 +250,24 @@ const commands = [
 		title: "Switch",
 		keys: "Tab",
 		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)
 		},
 	},
 	{
@@ -215,46 +275,24 @@ const commands = [
 		title: "Mark",
 		keys: "Spc",
 		kind: "ui",
-		bar: true,
 		run(session) {
 			pane(session).toggleMark()
 		},
 	},
 	{
-		id: "bookmark.record",
-		title: "Bookmark",
+		id: "bookmark.open",
+		title: "Bookmarks",
 		keys: "b",
 		kind: "ui",
-		bar: true,
 		run(session) {
-			// Record the entry under the cursor; fall back to the pane's
-			// directory when the listing is empty.
+			// The add row records the entry under the cursor; it falls back to
+			// the pane's directory when the listing is empty.
 			const entry = pane(session).currentEntry()
 			const path = entry?.path ?? pane(session).path.value
 			const isDir = entry ? Boolean(entry.isDir) : true
-			const existing = session.bookmarks.find(path)
-			if (existing) {
-				// Already bookmarked: no need to re-name it.
-				session.notice.set({ kind: "tip", text: `bookmark ${existing.name}` })
-				return
-			}
-			// The default name is the path's basename.
-			session.bookmarkTarget.set({ path, isDir })
-			session.bookmarkQuery.set(basename(path))
-			session.bookmarkMode.set("name")
-			session.bookmarkOpen.set(true)
-		},
-	},
-	{
-		id: "bookmark.jump",
-		title: "Bookmarks",
-		keys: "g",
-		kind: "ui",
-		bar: true,
-		run(session) {
-			session.bookmarkTarget.set(null)
 			session.bookmarkQuery.set("")
-			session.bookmarkMode.set("list")
+			session.bookmarkIndex.set(0)
+			session.bookmarkTarget.set({ path, isDir })
 			session.bookmarkOpen.set(true)
 		},
 	},
@@ -277,30 +315,19 @@ const commands = [
 		},
 	},
 	{
-		id: "bookmark.save",
-		title: "Save bookmark",
+		id: "bookmark.remove",
+		title: "Remove bookmark",
 		kind: "ui",
 		hidden: true,
-		run(session) {
-			const name = `${session.bookmarkQuery.value ?? ""}`.trim()
-			const target = session.bookmarkTarget.value
-			if (!name) {
-				session.notice.set({ kind: "warning", text: "bookmark needs a name" })
-				return
-			}
-			if (!target) {
-				closeBookmark(session)
-				return
-			}
-			// Close synchronously: the global key handler and the input's
-			// `on:enter` can both fire, and a second save while the overlay is
-			// still open would re-record and flash the notice twice. A rejected
-			// `record` (rejected name) still surfaces through the dispatch's
-			// error notice.
-			closeBookmark(session)
-			return session.bookmarks.record(name, target.path, target.isDir).then(() => {
-				session.notice.set({ kind: "tip", text: `bookmarked ${name}` })
-			})
+		async run(session) {
+			const items = session.bookmarkItems.value ?? []
+			const index = clampCursor(session.bookmarkIndex.value, items.length)
+			const item = items[index]
+			// The add row is an action, not a stored bookmark.
+			if (!item || item.add) return
+			if (!(await session.bookmarks.remove(item.name))) return
+			session.bookmarkIndex.set(clampCursor(index, session.bookmarkItems.value.length))
+			session.notice.set({ kind: "tip", text: `removed bookmark ${item.name}` })
 		},
 	},
 	{
@@ -321,7 +348,9 @@ 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]
+			// The add row records the current target instead of navigating.
+			if (item.add) return addCurrentBookmark(session)
+			const target = currentPane(session)
 			const path = item.path
 			// Resolve the kind when it is unknown (legacy path-only bookmark).
 			let isDir = item.isDir
@@ -351,15 +380,145 @@ const commands = [
 			closeBookmark(session)
 		},
 	},
+	// Undo/redo and the shared list overlay (`u` history, `⇧T` trash). The
+	// journal records reversible operations (see core/operations); the overlay
+	// is one modal list whose rows/actions depend on the active mode.
+	{
+		id: "history.undo",
+		title: "Undo",
+		keys: "^Z",
+		kind: "ui",
+		async run(session) {
+			const entry = await session.journal.undo(session)
+			if (!entry) {
+				session.notice.set({ kind: "warning", text: "nothing to undo" })
+				return
+			}
+			await refreshPanes(session)
+			session.notice.set({ kind: "tip", text: `undid ${entry.label}` })
+		},
+	},
+	{
+		id: "history.redo",
+		title: "Redo",
+		keys: "^⇧Z",
+		kind: "ui",
+		async run(session) {
+			const entry = await session.journal.redo(session)
+			if (!entry) {
+				session.notice.set({ kind: "warning", text: "nothing to redo" })
+				return
+			}
+			await refreshPanes(session)
+			session.notice.set({ kind: "tip", text: `redid ${entry.label}` })
+		},
+	},
+	{
+		id: "history.open",
+		title: "History",
+		keys: "u",
+		kind: "ui",
+		run(session) {
+			openHistory(session)
+		},
+	},
+	{
+		id: "trash.open",
+		title: "Trash",
+		keys: "⇧T",
+		kind: "ui",
+		async run(session) {
+			await openTrash(session)
+		},
+	},
+	{
+		id: "file.mkdir",
+		title: "New directory",
+		keys: "n",
+		kind: "ui",
+		run(session) {
+			// The panel opens on `mkdir` with its NAME field primed, the same
+			// way `!` lands on `run`; PATH is prefilled with the current path.
+			openPanel(session, { name: "mkdir", focus: PANEL_FOCUS.ARGS })
+			const nameIndex = session.panelRows.value.findIndex(
+				(row) => row.type === "arg" && row.name === "NAME",
+			)
+			session.panelRowIndex.set(nameIndex >= 0 ? nameIndex : 0)
+		},
+	},
+	{
+		id: "overlay.up",
+		title: "Previous row",
+		kind: "ui",
+		hidden: true,
+		run(session) {
+			const rows = session.overlayItems.value
+			session.overlayIndex.set(moveCursor(session.overlayIndex.value, -1, rows.length))
+		},
+	},
+	{
+		id: "overlay.down",
+		title: "Next row",
+		kind: "ui",
+		hidden: true,
+		run(session) {
+			const rows = session.overlayItems.value
+			session.overlayIndex.set(moveCursor(session.overlayIndex.value, 1, rows.length))
+		},
+	},
+	{
+		id: "overlay.setIndex",
+		title: "Highlight row",
+		kind: "ui",
+		hidden: true,
+		run(session, payload) {
+			if (payload?.index !== undefined) session.overlayIndex.set(Math.max(0, payload.index))
+		},
+	},
+	{
+		id: "overlay.activate",
+		title: "Activate row",
+		kind: "ui",
+		hidden: true,
+		async run(session) {
+			const mode = session.overlay.value
+			const rows = session.overlayItems.value
+			const row = rows[clampCursor(session.overlayIndex.value, rows.length)]
+			if (!row) return
+			if (mode === "history") return activateHistory(session, row)
+			if (mode === "trash") return activateTrash(session, row)
+			return undefined
+		},
+	},
+	{
+		id: "overlay.cancel",
+		title: "Close list",
+		kind: "ui",
+		hidden: true,
+		run(session) {
+			closeOverlay(session)
+		},
+	},
 	{
 		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 +536,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)
 		},
 	},
 	{
@@ -387,11 +548,64 @@ const commands = [
 		title: "Preview",
 		keys: "v",
 		kind: "ui",
-		bar: true,
 		run(session) {
 			session.showPreview.set(!session.showPreview.value)
 		},
 	},
+	{
+		id: "view.toggleViewer",
+		title: "Fullscreen",
+		kind: "ui",
+		hidden: true,
+		run(session) {
+			// The fullscreen inspector overlay. `v` opens it on a narrow
+			// terminal and Enter opens it on a file that cannot be edited (see
+			// `openFile`); the shared App controller closes it on Esc or `v`
+			// (see `components/App#createBehaviors`).
+			session.viewerOpen.set(!session.viewerOpen.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: "preview.scroll",
+		title: "Scroll preview",
+		kind: "ui",
+		hidden: true,
+		run(session, payload) {
+			// The renderers own the body and its measured viewport, so the
+			// command publishes a one-shot request instead of an offset. The
+			// token keeps repeated presses of the same direction distinct.
+			const delta = Math.trunc(Number(payload?.delta ?? 0))
+			if (!Number.isFinite(delta) || !delta) return
+			const current = session.previewScroll?.value
+			session.previewScroll?.set({ delta, token: (current?.token ?? 0) + 1 })
+		},
+	},
+	{
+		id: "view.toggleMode",
+		title: "Toggle Mode",
+		keys: "t",
+		kind: "ui",
+		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 +628,38 @@ 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())
+			// A host without an editor (the web's null adapter) reports it, the
+			// same guard `openFile` uses, instead of tripping over the throw.
+			if (session.os?.canEdit === false) {
+				session.notice.set({ kind: "warning", text: "no editor available" })
+				return
+			}
+			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,26 +708,27 @@ 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, each argument header,
+			// then the Run action, 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 = []
-			for (let i = 0; i < rows.length; i++) if (rows[i].type === "arg") headers.push(i)
-			if (!headers.length) return
+			const stops = []
+			for (let i = 0; i < rows.length; i++) if (rows[i].type === "arg" || rows[i].type === "run") stops.push(i)
+			if (!stops.length) return
 			if (session.panelFocus.value === PANEL_FOCUS.OPS) {
-				session.panelRowIndex.set(delta > 0 ? headers[0] : headers[headers.length - 1])
+				session.panelRowIndex.set(delta > 0 ? stops[0] : stops[stops.length - 1])
 				session.panelFocus.set(PANEL_FOCUS.ARGS)
 				return
 			}
-			const at = headers.indexOf(session.panelRowIndex.value)
+			const at = stops.indexOf(session.panelRowIndex.value)
 			if (delta > 0) {
-				if (at === -1 || at >= headers.length - 1) session.panelFocus.set(PANEL_FOCUS.OPS)
-				else session.panelRowIndex.set(headers[at + 1])
+				if (at === -1 || at >= stops.length - 1) session.panelFocus.set(PANEL_FOCUS.OPS)
+				else session.panelRowIndex.set(stops[at + 1])
 			} else if (at <= 0) {
 				session.panelFocus.set(PANEL_FOCUS.OPS)
 			} else {
-				session.panelRowIndex.set(headers[at - 1])
+				session.panelRowIndex.set(stops[at - 1])
 			}
 		},
 	},
@@ -567,6 +784,31 @@ const commands = [
 			session.panelFocus.set(PANEL_FOCUS.ARGS)
 		},
 	},
+	{
+		id: "panel.moveBit",
+		title: "Move permission bit",
+		kind: "ui",
+		hidden: true,
+		run(session, payload) {
+			// Left/Right walk the r/w/x cells of a focused permission row.
+			const row = rowAt(session.panelRows.value, session.panelRowIndex.value)
+			if (row?.type !== "perm") return
+			const delta = payload?.delta === -1 ? -1 : 1
+			session.panelPermBit.set(Math.min(2, Math.max(0, session.panelPermBit.value + delta)))
+		},
+	},
+	{
+		id: "panel.togglePerm",
+		title: "Toggle permission bit",
+		kind: "ui",
+		hidden: true,
+		run(session, payload) {
+			// A click on one permission cell.
+			const { argIndex, itemIndex } = payload ?? {}
+			if (!Number.isInteger(argIndex) || !Number.isInteger(itemIndex)) return
+			session.panelDraft.set(withToggledItem(session.panelDraft.value, argIndex, itemIndex, true))
+		},
+	},
 	{
 		id: "panel.toggleItem",
 		title: "Toggle argument item",
@@ -577,165 +819,321 @@ 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
+			}
+			if (row.type === "perm") {
+				const bit = row.bits?.[session.panelPermBit.value]
+				if (bit) session.panelDraft.set(withToggledItem(draft, row.argIndex, bit.itemIndex, true))
 				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
+			// Only a selection argument mass-toggles from its header; a
+			// permission grid has no safe "all" state and stays per-bit.
+			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)))
 		},
 	},
 	{
-		id: "panel.run",
-		title: "Run command",
+		id: "panel.copy",
+		title: "Copy argument value",
 		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}»` })
+		run(session, payload) {
+			// A click on a read-only argument value copies it through the host
+			// (OSC 52 in the TUI, the Clipboard API in a browser); the command
+			// bar confirms so the gesture is visible even though the clipboard
+			// itself is out of band.
+			const text = `${payload?.text ?? ""}`
+			if (!text) return
+			if (!session.os?.copy?.(text)) {
+				session.notice?.set({ kind: "warning", text: "clipboard is not available" })
 				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)
+			session.notice?.set({ kind: "tip", text: `copied ${text}` })
+			showBriefPanelResult(session)
 		},
 	},
+	// File picker: a sub-mode of the panel that browses the filesystem for a
+	// path/destination argument. Lifecycle then navigation then choose.
 	{
-		id: "panel.cancel",
-		title: "Close command panel",
+		id: "panel.browse",
+		title: "Browse for a path",
 		kind: "ui",
 		hidden: true,
 		run(session) {
-			closePanel(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: "palette.toggle",
-		title: "Palette",
-		keys: "^P",
+		id: "picker.up",
+		title: "Previous 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.pickerFocus.set("rows")
+			session.panelRowIndex.set(moveCursor(session.panelRowIndex.value, -1, length))
 		},
 	},
 	{
-		id: "palette.script",
-		title: "Script",
+		id: "picker.down",
+		title: "Next picker row",
 		kind: "ui",
+		hidden: true,
 		run(session) {
-			openPalette(session, "script", "")
+			const length = session.pickerRows.value.length
+			session.pickerFocus.set("rows")
+			session.panelRowIndex.set(moveCursor(session.panelRowIndex.value, 1, length))
 		},
 	},
 	{
-		id: "palette.run",
-		title: "Run command",
-		keys: "!",
+		id: "picker.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))
+			session.pickerFocus.set("rows")
 		},
 	},
 	{
-		id: "filter.start",
-		title: "Filter",
-		keys: "/",
+		id: "picker.focusPath",
+		title: "Edit the picker path",
 		kind: "ui",
-		bar: true,
+		hidden: true,
 		run(session) {
-			session.filtering.set(session.active.value)
+			session.pickerFocus.set("path")
 		},
 	},
 	{
-		id: "filter.accept",
-		title: "Keep filter",
+		id: "picker.focusRows",
+		title: "Focus the picker entries",
 		kind: "ui",
 		hidden: true,
 		run(session) {
-			session.filtering.set(null)
+			session.pickerFocus.set("rows")
 		},
 	},
 	{
-		id: "filter.clear",
-		title: "Clear filter",
+		id: "picker.type",
+		title: "Type into the picker path",
 		kind: "ui",
 		hidden: true,
-		run(session) {
-			pane(session).clearFilter()
-			session.filtering.set(null)
+		run(session, payload) {
+			// A printable key pressed while the entry list owns the keyboard
+			// jumps back to the path field and extends it, so typing always
+			// means "narrow the path" no matter where the cursor sits.
+			const text = `${session.pickerPathText.value ?? ""}`
+			session.pickerPathText.set(`${text}${payload?.char ?? ""}`)
+			session.pickerFocus.set("path")
 		},
 	},
 	{
-		id: "palette.up",
-		title: "Previous command",
+		id: "picker.path",
+		title: "Go to the typed picker path",
 		kind: "ui",
 		hidden: true,
-		run(session) {
-			movePalette(session, -1)
+		async run(session) {
+			// Enter in the path field commits it: an existing directory is
+			// chosen (destination) or opened (file/any picker), an existing
+			// file is chosen, and a path that does not exist is reported.
+			const text = `${session.pickerPathText.value ?? ""}`
+			const absolute = pickerAbsolutePath(
+				text,
+				session.pickerBasePath.value || session.pickerPane.path.value || "/",
+				session.fs.home?.() ?? "/",
+			)
+			const stats = await session.fs.stat(absolute)
+			if (!stats) {
+				// A partial path narrowed the listing: Enter takes the match
+				// under the cursor (the `..` parent row is not a match).
+				const row = pickerEntry(session)
+				if (row?.type === "entry") {
+					if (row.isDir && session.pickerMode.value !== "dir") return descendPicker(session, row.path)
+					if (row.isDir || session.pickerMode.value !== "dir") return choosePicker(session, row.path)
+				}
+				session.notice.set({ kind: "warning", text: `no such path: ${absolute}` })
+				return
+			}
+			if (stats.isDir) {
+				if (session.pickerMode.value === "dir") return choosePicker(session, absolute)
+				return descendPicker(session, absolute)
+			}
+			if (session.pickerMode.value === "dir") {
+				session.notice.set({ kind: "warning", text: `not a directory: ${absolute}` })
+				return
+			}
+			return choosePicker(session, absolute)
 		},
 	},
 	{
-		id: "palette.down",
-		title: "Next command",
+		id: "picker.enter",
+		title: "Choose picker row",
 		kind: "ui",
 		hidden: true,
 		run(session) {
-			movePalette(session, 1)
+			const entry = pickerEntry(session)
+			if (!entry) return undefined
+			if (entry.type === "parent") return session.dispatch("picker.parent")
+			// A directory descends unless this is a destination picker, where
+			// every row is already a valid choice.
+			if (entry.isDir && session.pickerMode.value !== "dir") {
+				return descendPicker(session, entry.path)
+			}
+			return choosePicker(session, entry.path)
 		},
 	},
 	{
-		id: "palette.complete",
-		title: "Complete",
+		id: "picker.descend",
+		title: "Open the picker's directory",
 		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)
+			const entry = pickerEntry(session)
+			if (entry?.type === "parent") return session.dispatch("picker.parent")
+			if (entry?.isDir) return descendPicker(session, entry.path)
+			return undefined
 		},
 	},
 	{
-		id: "palette.setQuery",
-		title: "Set palette query",
+		id: "picker.parent",
+		title: "Picker parent directory",
 		kind: "ui",
 		hidden: true,
-		run(session, payload) {
-			session.paletteQuery.set(`${payload?.query ?? ""}`)
+		async run(session) {
+			session.pickerPaths.invalidate()
+			session.pickerQuery.set("")
+			const cameFrom = session.pickerPane.path.value
+			await session.pickerPane.up()
+			session.pickerPathText.set(pickerDirectoryText(session.pickerPane.path.value))
+			const index = session.pickerRows.value.findIndex((row) => row.path === cameFrom)
+			session.panelRowIndex.set(index >= 0 ? index : 0)
 		},
 	},
 	{
-		id: "palette.submit",
-		title: "Submit palette",
+		id: "picker.chooseDir",
+		title: "Choose the picker's directory",
 		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 choosePicker(session, session.pickerPane.path.value)
+		},
+	},
+	{
+		id: "picker.cancel",
+		title: "Leave the picker",
+		kind: "ui",
+		hidden: true,
+		run(session) {
+			// Back to the argument column, panel still open.
+			session.pickerPaths.invalidate()
+			session.pickerOpen.set(false)
+			session.pickerArg.set(-1)
+			session.panelFocus.set(PANEL_FOCUS.ARGS)
+			session.pickerFocus.set("path")
+			session.panelRowIndex.set(0)
+		},
+	},
+	{
+		id: "panel.run",
+		title: "Run command",
+		kind: "ui",
+		hidden: true,
+		async run(session) {
+			const entry = session.panelEntry.value
+			if (!entry) return
+			if (entry.commandId) {
+				closePanel(session)
+				return session.dispatch(entry.commandId)
+			}
+			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.pickerPendingRun.set(true)
+					return openPicker(session, missing.index, missing)
+				}
+				focusBinding(session, missing)
+				return
+			}
+			session.panelRunError?.set(null)
+			// Amber (caution) and red (destructive) actions are two-step: the
+			// first Run prints the assembled command and arms `[Confirm]`; the
+			// second executes it without the separate confirm overlay.
+			const risk = entry.risk === "caution" || entry.risk === "destructive"
+			if (risk && !session.panelArmed.value) {
+				session.panelArmed.set(true)
 				return
 			}
-			return runLine(session, query).then((status) => {
-				if (status !== "empty") closePalette(session)
-				return status
+			const status = await runOperation(session, op, argvFor(draft), {
+				panel: true,
+				...(risk ? { confirmed: true } : {}),
 			})
+			// 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 === "error") keepPanelError(session)
+			else if (status === "ran") {
+				showBriefPanelResult(session)
+				closePanel(session)
+			}
+		},
+	},
+	{
+		id: "panel.cancel",
+		title: "Close command panel",
+		kind: "ui",
+		hidden: true,
+		run(session) {
+			closePanel(session)
+		},
+	},
+	{
+		id: "filter.start",
+		title: "Filter",
+		keys: "/",
+		kind: "ui",
+		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: "filter.accept",
+		title: "Keep filter",
+		kind: "ui",
+		hidden: true,
+		run(session) {
+			session.filtering.set(null)
+		},
+	},
+	{
+		id: "filter.clear",
+		title: "Clear filter",
+		kind: "ui",
+		hidden: true,
+		run(session) {
+			pane(session).clearFilter()
+			session.filtering.set(null)
 		},
 	},
 	{
@@ -753,7 +1151,11 @@ const commands = [
 				// A panel-originated confirm re-runs its draft and, on success,
 				// closes the panel that was waiting on it.
 				return runOperation(session, op, pending.args, { confirmed: true }).then((status) => {
-					if (status === "ran" && session.panelOpen?.value) closePanel(session)
+					if (status === "error" && session.panelOpen?.value) keepPanelError(session)
+					if (status === "ran" && session.panelOpen?.value) {
+						showBriefPanelResult(session)
+						closePanel(session)
+					}
 					return status
 				})
 			}
@@ -769,16 +1171,29 @@ const commands = [
 			session.confirm.set(null)
 		},
 	},
-	// 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.
+	// Quit: the key path intercepts `app.quit` before dispatch, while the
+	// panel's synthetic Quit entry dispatches it; both reach the renderer's
+	// host hook (`session.quit`, installed at mount). Hidden from the `?`
+	// keymap's command bar, not from the panel.
 	{
 		id: "app.quit",
 		title: "Quit",
 		keys: "q",
 		kind: "ui",
-		bar: true,
+		hidden: true,
+		run(session) {
+			return session.quit?.()
+		},
+	},
+	// Help: presentation-only too. Each renderer intercepts `?` and owns its
+	// own overlay cell, and routes the bar click the same way; the registry
+	// entry exists so the bar and the `?` reference can advertise it. Hidden
+	// from the panel, where it could only no-op.
+	{
+		id: "app.help",
+		title: "Help",
+		keys: "?",
+		kind: "ui",
 		hidden: true,
 		run() {},
 	},
@@ -799,40 +1214,35 @@ 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
-	if (bookmarkOpen) return bookmarkMode === "name" ? BOOKMARK_NAME_KEYS : BOOKMARK_LIST_KEYS
-	if (paletteOpen) return paletteMode === "script" ? SCRIPT_KEYS : PALETTE_KEYS
+// Command-bar rows for the current context: the panel's key hints while it is
+// open, the bookmark-panel hints while that panel owns the keyboard, the
+// filter hints while a pane filter is capturing input, or the fixed
+// `BAR_COMMANDS` set otherwise, in display order. Takes the context as named
+// fields — four adjacent flags are too easy to transpose.
+function getCommandBarItems({ filtering, bookmarkOpen, panelOpen, pickerOpen, panelArmed, overlay }) {
+	if (panelOpen) return pickerOpen ? PICKER_KEYS : panelArmed ? PANEL_CONFIRM_KEYS : PANEL_HINT_KEYS
+	if (bookmarkOpen) return BOOKMARK_KEYS
+	if (overlay === "history") return HISTORY_KEYS
+	if (overlay === "trash") return TRASH_KEYS
 	if (filtering) return FILTER_KEYS
-	return commands.filter((command) => command.bar).map(commandRow)
+	return BAR_COMMANDS.map((id) => getCommand(id)).filter(Boolean).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,
 	}
 }
 
 // Function: createDispatch
-// Returns `dispatch(id, payload)` bound to the session. Unknown and `app.*`
-// (presentation-only) commands are ignored here. Failures (sync throws and
+// Returns `dispatch(id, payload)` bound to the session. Unknown commands are
+// ignored here; `app.*` commands run their host hook. Failures (sync throws and
 // rejections) land on the active pane's error cell and the session notice.
 function createDispatch(session) {
 	return (id, payload) => {
@@ -854,8 +1264,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 +1301,83 @@ 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: openFile
+// Enter on a file. A text file the host can edit opens in `$EDITOR` and the
+// pane is refreshed afterwards (an editor may have rewritten it); anything else
+// — an image, media, a binary body, or any file on a host without an editor
+// (the web) — opens the fullscreen inspector instead.
+async function openFile(session, current, entry) {
+	if (await isEditable(session, entry)) {
+		await session.os.edit(entry.path)
+		await current.refresh()
+		return
+	}
+	session.previewTarget.set(entry)
+	session.showPreview.set(true)
+	session.viewerOpen.set(true)
+}
+
+// Function: isEditable
+// Whether Enter edits `entry` rather than previewing it: the host must have an
+// editor, the entry must preview as text (not an image/media card) and its head
+// must not be binary. Compressed entries are never editable: the inspector
+// decompresses them, but `$EDITOR` would only see the compressed bytes. The
+// read follows symlinks, like the inspector's own, and needs only the sniff
+// window `hasBinaryByte` looks at.
+async function isEditable(session, entry) {
+	if (entry?.isDir) return false
+	if (session.os?.canEdit === false) return false
+	const source = previewSource(entry)
+	if (source.compression) return false
+	if (previewKind(source.innerExt) !== "text") return false
+	const head = await session.fs.readTextHead(entry.path, SNIFF_BYTES).catch(() => null)
+	return head !== null && !hasBinaryByte(head)
+}
+
 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 +1387,262 @@ function closeBookmark(session) {
 	session.bookmarkOpen.set(false)
 }
 
-function openPanel(session) {
+// Function: addCurrentBookmark
+// Records the panel's target under an automatic name and closes the panel.
+// Closing happens before the async save so a second Enter cannot add twice.
+function addCurrentBookmark(session) {
+	const target = session.bookmarkTarget.value
+	if (!target) return
+	closeBookmark(session)
+	return session.bookmarks.add(target.path, target.isDir).then(({ name, added }) => {
+		session.notice.set({ kind: "tip", text: added ? `bookmarked ${name}` : `bookmark ${name}` })
+	})
+}
+
+// Function: openHistory
+// Opens the history overlay: one row per journal entry, the cursor parked on
+// the current position. A row carries its journal `index` so activating it can
+// rewind/replay to that point.
+function openHistory(session) {
+	const rows = session.journal.rows()
+	session.overlayItems.set(
+		rows.map((row) => ({
+			key: `h:${row.id}`,
+			text: row.label,
+			meta: row.applied ? (row.current ? "current" : "applied") : "undone",
+			index: row.index,
+			current: row.current,
+			dim: !row.applied,
+		})),
+	)
+	const current = rows.findIndex((row) => row.current)
+	session.overlayIndex.set(current >= 0 ? current : 0)
+	session.overlay.set("history")
+}
+
+// Function: openTrash
+// Opens the trash overlay on the current trash listing.
+async function openTrash(session) {
+	await loadTrash(session)
+	session.overlayIndex.set(0)
+	session.overlay.set("trash")
+}
+
+// Function: loadTrash
+// Refreshes the overlay rows from the trash listing. A row's key is its trash
+// path (`fs.restore` addresses entries by it) and its meta the original path.
+async function loadTrash(session) {
+	const rows = (await session.fs.trashList?.()) ?? []
+	session.overlayItems.set(
+		rows.map((row) => ({
+			key: row.trashPath,
+			text: row.name,
+			meta: row.originalPath ?? "",
+			trashPath: row.trashPath,
+			dim: false,
+		})),
+	)
+	return rows
+}
+
+// Function: activateHistory
+// Rewinds or replays the journal to `row.index`, refreshes the panes and closes
+// the overlay.
+async function activateHistory(session, row) {
+	await session.journal.goTo(session, row.index)
+	await refreshPanes(session)
+	closeOverlay(session)
+	session.notice.set({ kind: "tip", text: `history → ${row.text}` })
+}
+
+// Function: activateTrash
+// Restores the trashed entry under the cursor, refreshes the trash list (the
+// restored row is gone), the panes and closes nothing (the panel stays open so
+// several entries can be restored in a row).
+async function activateTrash(session, row) {
+	await session.fs.restore([row.trashPath])
+	await loadTrash(session)
+	session.overlayIndex.set(clampCursor(session.overlayIndex.value, session.overlayItems.value.length))
+	await refreshPanes(session)
+	session.notice.set({ kind: "tip", text: `restored ${row.meta || row.text}` })
+}
+
+// Function: closeOverlay
+function closeOverlay(session) {
+	session.overlay.set(null)
+}
+
+// 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.pickerOpen.set(false)
+	session.pickerArg.set(-1)
+	session.pickerPendingRun.set(false)
+	session.panelRunError?.set(null)
 	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) {
+	session.pickerPaths.invalidate()
+	const mode = binding?.mode ?? "dir"
+	session.pickerMode.set(mode)
+	session.pickerArg.set(argIndex)
+	session.pickerQuery.set("")
+	session.pickerOpen.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)
+	session.pickerBasePath.set(startPath)
+	session.pickerFocus.set("path")
+	await session.pickerPane.navigate(startPath, { record: false, cursorPath })
+	session.pickerPathText.set(pickerDirectoryText(session.pickerPane.path.value))
+	const rows = session.pickerRows.value
+	const index = cursorPath ? rows.findIndex((row) => row.path === cursorPath) : -1
+	session.panelRowIndex.set(index >= 0 ? index : 0)
+}
+
+// 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.pickerPaths.invalidate()
+	session.pickerQuery.set("")
+	await session.pickerPane.navigate(path, { record: false })
+	session.pickerPathText.set(pickerDirectoryText(session.pickerPane.path.value))
+	session.pickerFocus.set("rows")
+	session.panelRowIndex.set(0)
+	return undefined
+}
+
+// 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
+	session.pickerPaths.invalidate()
+	const argIndex = session.pickerArg.value
+	session.panelDraft.set(withArgValue(session.panelDraft.value, argIndex, path))
+	session.pickerOpen.set(false)
+	session.pickerArg.set(-1)
+	session.panelFocus.set(PANEL_FOCUS.ARGS)
+	session.pickerFocus.set("path")
+	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.pickerPendingRun.value) {
+		session.pickerPendingRun.set(false)
+		return session.dispatch("panel.run")
+	}
+	return undefined
 }
 
 function closePanel(session) {
+	session.pickerPaths.invalidate()
 	session.panelOpen.set(false)
+	session.panelRunError?.set(null)
 }
 
-function openPalette(session, mode, query) {
-	session.paletteMode.set(mode)
-	session.paletteQuery.set(query)
-	session.paletteIndex.set(0)
-	session.paletteOpen.set(true)
+// Keep an operation error in the panel action row rather than duplicating it
+// in the command bar underneath the modal.
+function keepPanelError(session) {
+	const notice = session.notice?.value
+	session.panelRunError?.set(notice?.text ?? "The command failed")
+	session.notice?.set(null)
+	const runIndex = session.panelRows?.value?.findIndex((row) => row.type === "run") ?? -1
+	if (runIndex >= 0) {
+		session.panelFocus.set(PANEL_FOCUS.ARGS)
+		session.panelRowIndex.set(runIndex)
+	}
 }
 
-function closePalette(session) {
-	session.paletteOpen.set(false)
+// Successful panel results briefly replace the command bar's normal hints.
+// A later dispatch can replace the notice first; the identity check prevents
+// this timer from clearing that newer status.
+function showBriefPanelResult(session) {
+	const notice = session.notice?.value
+	if (!notice || notice.kind === "error") return
+	const timer = setTimeout(() => {
+		if (session.notice?.value === notice) session.notice.set(null)
+	}, 2500)
+	timer?.unref?.()
 }
 
 export {
-	commandRow,
+	barRow,
+	closePanel,
 	createDispatch,
 	getCommand,
 	getCommandBarItems,
 	getCommands,
-	getPaletteCommands,
+	openPanel,
 }