@ssebastien/tcmd 0.1.4 → 0.1.7

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

@@ -10,17 +10,21 @@
 // source of truth for every presentation layer.
 //
 // Commands carry presentation metadata:
-// - `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.
+// - `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 { 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
@@ -36,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" },
 ]
 
@@ -62,18 +60,52 @@ const PANEL_HINT_KEYS = [
 	{ id: null, title: "Close", keys: "Esc" },
 ]
 
-// Constant: PANEL_PICK_KEYS
+// 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 PANEL_PICK_KEYS = [
-	{ id: null, title: "Filter", keys: "type" },
+const PICKER_KEYS = [
+	{ id: null, title: "Path", keys: "type" },
 	{ id: null, title: "Row", keys: "↑/↓" },
 	{ id: null, title: "Open", keys: "→" },
-	{ id: null, title: "Choose", keys: "↵", primary: true },
+	{ id: null, title: "Go", keys: "↵", primary: true },
 	{ id: null, title: "Here", keys: "^↵" },
-	{ id: null, title: "Up", 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",
@@ -152,7 +184,6 @@ const commands = [
 		title: "Open",
 		keys: "Enter",
 		kind: "ui",
-		bar: true,
 		primary: true,
 		run(session) {
 			// The entry under the *focused* pane's cursor decides where the
@@ -164,12 +195,15 @@ const commands = [
 			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.
+			// 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)
 			}
-			return undefined
+			// 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)
 		},
 	},
 	{
@@ -177,7 +211,6 @@ const commands = [
 		title: "Parent",
 		keys: "←",
 		kind: "ui",
-		bar: true,
 		run(session) {
 			// Stepping up always moves the current directory: the parent
 			// column mirrors it, so navigating that column itself would
@@ -206,9 +239,8 @@ const commands = [
 	{
 		id: "pane.reload",
 		title: "Reload",
-		keys: "^R",
+		keys: "F5/r",
 		kind: "ui",
-		bar: true,
 		run(session) {
 			return pane(session).refresh()
 		},
@@ -218,7 +250,6 @@ const commands = [
 		title: "Switch",
 		keys: "Tab",
 		kind: "ui",
-		bar: true,
 		run(session) {
 			// Cycle through the columns the current view mode shows:
 			// source ⇄ destination in commander, parent → current → preview
@@ -244,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)
 		},
 	},
@@ -306,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}` })
 		},
 	},
 	{
@@ -350,6 +348,8 @@ const commands = [
 			const items = session.bookmarkItems.value
 			const item = items[clampCursor(session.bookmarkIndex.value, items.length)]
 			if (!item) return
+			// 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).
@@ -380,6 +380,125 @@ 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: "Select row",
@@ -429,11 +548,23 @@ 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",
@@ -447,12 +578,26 @@ const commands = [
 			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: "Explorer view",
+		title: "Toggle Mode",
 		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
@@ -483,6 +628,12 @@ const commands = [
 				session.notice.set({ kind: "warning", text: "no file to edit" })
 				return
 			}
+			// 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())
 		},
 	},
@@ -494,7 +645,6 @@ const commands = [
 		title: "Commands",
 		keys: ":",
 		kind: "ui",
-		bar: true,
 		run(session) {
 			openPanel(session)
 		},
@@ -558,27 +708,27 @@ const commands = [
 		kind: "ui",
 		hidden: true,
 		run(session, payload) {
-			// 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.
+			// 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])
 			}
 		},
 	},
@@ -634,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",
@@ -647,16 +822,43 @@ const commands = [
 				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. A single-path argument is a
 			// radio list, so its header has nothing to toggle.
 			const binding = bindingAt(draft, row.argIndex)
+			// 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.copy",
+		title: "Copy argument value",
+		kind: "ui",
+		hidden: true,
+		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
+			}
+			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.
 	{
@@ -674,74 +876,153 @@ const commands = [
 		},
 	},
 	{
-		id: "panel.pick.up",
+		id: "picker.up",
 		title: "Previous picker row",
 		kind: "ui",
 		hidden: true,
 		run(session) {
 			const length = session.pickerRows.value.length
+			session.pickerFocus.set("rows")
 			session.panelRowIndex.set(moveCursor(session.panelRowIndex.value, -1, length))
 		},
 	},
 	{
-		id: "panel.pick.down",
+		id: "picker.down",
 		title: "Next picker row",
 		kind: "ui",
 		hidden: true,
 		run(session) {
 			const length = session.pickerRows.value.length
+			session.pickerFocus.set("rows")
 			session.panelRowIndex.set(moveCursor(session.panelRowIndex.value, 1, length))
 		},
 	},
 	{
-		id: "panel.pick.setCursor",
+		id: "picker.setCursor",
 		title: "Highlight picker row",
 		kind: "ui",
 		hidden: true,
 		run(session, payload) {
 			if (payload?.index !== undefined) session.panelRowIndex.set(Math.max(0, payload.index))
+			session.pickerFocus.set("rows")
+		},
+	},
+	{
+		id: "picker.focusPath",
+		title: "Edit the picker path",
+		kind: "ui",
+		hidden: true,
+		run(session) {
+			session.pickerFocus.set("path")
+		},
+	},
+	{
+		id: "picker.focusRows",
+		title: "Focus the picker entries",
+		kind: "ui",
+		hidden: true,
+		run(session) {
+			session.pickerFocus.set("rows")
+		},
+	},
+	{
+		id: "picker.type",
+		title: "Type into the picker path",
+		kind: "ui",
+		hidden: true,
+		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: "picker.path",
+		title: "Go to the typed picker path",
+		kind: "ui",
+		hidden: true,
+		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: "panel.pick.enter",
+		id: "picker.enter",
 		title: "Choose picker row",
 		kind: "ui",
 		hidden: true,
 		run(session) {
 			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.panelPickerMode.value !== "dir") {
+			if (entry.isDir && session.pickerMode.value !== "dir") {
 				return descendPicker(session, entry.path)
 			}
 			return choosePicker(session, entry.path)
 		},
 	},
 	{
-		id: "panel.pick.descend",
+		id: "picker.descend",
 		title: "Open the picker's directory",
 		kind: "ui",
 		hidden: true,
 		run(session) {
 			const entry = pickerEntry(session)
+			if (entry?.type === "parent") return session.dispatch("picker.parent")
 			if (entry?.isDir) return descendPicker(session, entry.path)
 			return undefined
 		},
 	},
 	{
-		id: "panel.pick.parent",
+		id: "picker.parent",
 		title: "Picker parent directory",
 		kind: "ui",
 		hidden: true,
 		async run(session) {
+			session.pickerPaths.invalidate()
 			session.pickerQuery.set("")
+			const cameFrom = session.pickerPane.path.value
 			await session.pickerPane.up()
-			session.panelRowIndex.set(0)
+			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: "panel.pick.chooseDir",
+		id: "picker.chooseDir",
 		title: "Choose the picker's directory",
 		kind: "ui",
 		hidden: true,
@@ -750,15 +1031,17 @@ const commands = [
 		},
 	},
 	{
-		id: "panel.pick.cancel",
+		id: "picker.cancel",
 		title: "Leave the picker",
 		kind: "ui",
 		hidden: true,
 		run(session) {
 			// Back to the argument column, panel still open.
-			session.panelPicking.set(false)
-			session.panelPickerArg.set(-1)
+			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)
 		},
 	},
@@ -770,6 +1053,10 @@ const commands = [
 		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
@@ -780,16 +1067,32 @@ const commands = [
 			const missing = missingBinding(draft)
 			if (missing) {
 				if (missing.kind === "dest" || missing.kind === "path") {
-					session.panelPendingRun.set(true)
+					session.pickerPendingRun.set(true)
 					return openPicker(session, missing.index, missing)
 				}
 				focusBinding(session, missing)
 				return
 			}
-			const status = await runOperation(session, op, argvFor(draft))
+			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
+			}
+			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 === "ran") closePanel(session)
+			if (status === "error") keepPanelError(session)
+			else if (status === "ran") {
+				showBriefPanelResult(session)
+				closePanel(session)
+			}
 		},
 	},
 	{
@@ -806,7 +1109,6 @@ const commands = [
 		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
@@ -849,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
 				})
 			}
@@ -865,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 panel, 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() {},
 	},
@@ -897,15 +1216,17 @@ function getCommand(id) {
 
 // Function: getCommandBarItems
 // 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
+// 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(barRow)
+	return BAR_COMMANDS.map((id) => getCommand(id)).filter(Boolean).map(barRow)
 }
 
 // Function: barRow
@@ -920,8 +1241,8 @@ function barRow(command) {
 }
 
 // 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) => {
@@ -1019,6 +1340,39 @@ function pinPreview(session, pane) {
 	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))
@@ -1033,6 +1387,91 @@ function closeBookmark(session) {
 	session.bookmarkOpen.set(false)
 }
 
+// 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.
@@ -1070,9 +1509,10 @@ function openPanel(session, options = {}) {
 	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.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
@@ -1102,11 +1542,12 @@ function pickerEntry(session) {
 // 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.panelPickerMode.set(mode)
-	session.panelPickerArg.set(argIndex)
+	session.pickerMode.set(mode)
+	session.pickerArg.set(argIndex)
 	session.pickerQuery.set("")
-	session.panelPicking.set(true)
+	session.pickerOpen.set(true)
 	session.panelFocus.set(PANEL_FOCUS.ARGS)
 	let startPath = currentPane(session)?.path?.value ?? session.fs.cwd?.() ?? "/"
 	let cursorPath = null
@@ -1119,7 +1560,10 @@ async function openPicker(session, argIndex, binding) {
 			cursorPath = value
 		}
 	}
+	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)
@@ -1130,8 +1574,11 @@ async function openPicker(session, argIndex, binding) {
 // 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
 }
@@ -1142,23 +1589,52 @@ async function descendPicker(session, path) {
 // 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.pickerPaths.invalidate()
+	const argIndex = session.pickerArg.value
 	session.panelDraft.set(withArgValue(session.panelDraft.value, argIndex, path))
-	session.panelPicking.set(false)
-	session.panelPickerArg.set(-1)
+	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.panelPendingRun.value) {
-		session.panelPendingRun.set(false)
+	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)
+}
+
+// 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)
+	}
+}
+
+// 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 {