@crouton-kit/crouter 0.3.70 → 0.3.78

package/dist/builtin-pi-packages/pi-mode-switch/README.md

@@ -1,8 +1,6 @@
 # pi-mode-switch
 
-Press **Alt+M** to cycle between operating modes — the way Claude's Shift+Tab
-cycles plan / accept-edits. Whenever the mode changes, the new mode's operating
-instructions are injected (invisibly) before your next message.
+Cycle between operating modes with crouter's configurable **Cycle mode** binding (default **Alt+M**) — the way Claude's Shift+Tab cycles plan / accept-edits. Whenever the mode changes, the new mode's operating instructions are injected invisibly before your next message.
 
 ## Modes
 
@@ -14,51 +12,25 @@ instructions are injected (invisibly) before your next message.
 
 ## Usage
 
-- `Alt+M` — cycle `normal → spec → plan → normal`
-- `/mode` — same as Alt+M
+- the configured `crtr.mode.cycle` binding (default `Alt+M`) — cycle `normal → spec → plan → normal`
+- `/mode` — cycle without using the shortcut
 - `/mode <normal\|spec\|plan>` — jump to a specific mode
-- the agent can switch its own mode by running the bundled `bin/mode` CLI through
-  its bash tool — e.g. `bash <plugin>/bin/mode normal` after a spec/plan is
-  approved. The command prints that mode's guidance, so the text only enters
-  context at the moment of the switch (no always-on tool)
+- the agent can switch its own mode by running the bundled `bin/mode` CLI through its bash tool — e.g. `bash <plugin>/bin/mode normal` after a spec/plan is approved. The command prints that mode's guidance, so the text only enters context at the moment of the switch (no always-on tool)
 
-The current mode renders as a badge on the **bottom-right of the input box**,
-diagonally opposite the session-name badge (top-left). Mode persists across
-`--resume`.
+The current mode renders as a badge on the **bottom-right of the input box**, diagonally opposite the session-name badge (top-left). Mode persists across `--resume`.
 
 ## How it works
 
-The extension tracks the active mode and the mode whose guidance was last
-injected. On `before_agent_start` it compares the two: if they differ, it
-prepends that mode's guidance to the turn (as a hidden `mode-switch-context`
-message) and records the injection. Stay in the same mode and nothing extra is
-added. Returning to `normal` also strips stale guidance from context.
+The extension tracks the active mode and the mode whose guidance was last injected. On `before_agent_start` it compares the two: if they differ, it prepends that mode's guidance to the turn as a hidden `mode-switch-context` message and records the injection. Stay in the same mode and nothing extra is added. Returning to `normal` also strips stale guidance from context.
 
-The agent can also switch its own mode without a permanent tool. The bundled
-`bin/mode` CLI, run through the normal bash tool, writes the requested mode to
-`<artifact-root>/mode-switch/request.json` and prints that mode's operating
-instructions to stdout. The extension mirrors each mode's guidance to
-`mode-switch/guidance/<mode>.txt` at session start (single source of truth stays
-in the extension), watches the request file to keep the badge and session state in
-sync, and consumes each request on read so a later Alt+M isn't clobbered. The
-guidance reaches the agent through the command's own output, so it only enters
-context at the moment of the switch — no tool sits in the context window, and
-there's no coupling to any external runtime, just files.
+The agent can also switch its own mode without a permanent tool. The bundled `bin/mode` CLI, run through the normal bash tool, writes the requested mode to `<artifact-root>/mode-switch/request.json` and prints that mode's operating instructions to stdout. The extension mirrors each mode's guidance to `mode-switch/guidance/<mode>.txt` at session start, watches the request file to keep the badge and session state in sync, and applies each tokenized request once. The guidance reaches the agent through the command's own output, so it only enters context at the moment of the switch — no tool sits in the context window, and there's no coupling to an external runtime beyond the shared files.
 
-This is guidance-only — it does not hard-restrict tools. The instructions tell
-the agent not to edit in spec/plan mode; combine with a tool gate if you want
-enforcement.
+This is guidance-only — it does not hard-restrict tools. The instructions tell the agent not to edit in spec/plan mode; combine with a tool gate if you want enforcement.
 
-The input badge is drawn by wrapping whatever editor is already installed (e.g. a
-session-name badge extension) in a transparent Proxy that overrides only
-`render()`. It composes instead of replacing, so other editor decorations keep
-working.
+The input badge is drawn by wrapping whatever editor is already installed (for example, a session-name badge extension) in a transparent Proxy that overrides only `render()`. It composes instead of replacing, so other editor decorations keep working.
 
 ## Install
 
-```bash
-pi install /Users/silasrhyneer/Code/cli/pi-mode-switch          # user scope
-pi install -l /Users/silasrhyneer/Code/cli/pi-mode-switch       # project scope
-```
+This package ships inside crouter. `crtr sys setup` registers its built package path with pi; there is no separate repository or package to install.
 
-Run `/reload` in pi after install, then press Alt+M.
+Run `/reload` in pi after setup. The extension resolves `crtr.mode.cycle` from the sparse `keybindings` object in `~/.crouter/config.json`; missing overrides use Alt+M, multiple gestures all register, and an empty list disables the shortcut. `/mode` remains available when the shortcut is disabled. Pi's stock actions and `~/.pi/agent/keybindings.json` remain untouched.

package/dist/builtin-pi-packages/pi-mode-switch/extensions/index.ts

@@ -1,8 +1,8 @@
 /**
  * Mode Switch Extension
  *
- * Press Alt+M to cycle between operating modes, the way Claude's Shift+Tab
- * cycles plan / accept-edits. Modes here:
+ * Use the configured crouter mode-cycle binding to cycle between operating
+ * modes, the way Claude's Shift+Tab cycles plan / accept-edits. Modes here:
  *
  *   normal  → full access (default)
  *   spec    → write a specification before any code
@@ -13,7 +13,7 @@
  * instructions are prepended (invisibly) to the next agent turn. Stay in the
  * same mode across turns and nothing extra is injected.
  *
- * - Alt+M or /mode to cycle; /mode <name> to jump to a specific mode
+ * - The configured shortcut or /mode cycles; /mode <name> jumps to a mode
  * - The agent can switch its own mode by running the bundled `bin/mode` CLI via
  *   its bash tool; the command prints the new mode's guidance to stdout, so that
  *   text only enters context at the moment of the switch (no always-on tool)
@@ -31,6 +31,7 @@ import { type FSWatcher, mkdirSync, readFileSync, rmSync, watch, writeFileSync }
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { workspaceRoot } from "../../../core/artifact.js";
+import { resolveUserKeybindings } from "../../../core/keybindings/index.js";
 
 type Mode = "normal" | "spec" | "plan";
 
@@ -62,7 +63,7 @@ function modeSwitchDir(cwd: string = process.cwd(), nodeId: string = process.env
 	return join(workspaceRoot(cwd), "mode-switch", nodeId);
 }
 
-// The cycle order Alt+M walks through.
+// The order used by the shortcut and /mode command.
 const CYCLE: Mode[] = ["normal", "spec", "plan"];
 
 interface ModeDef {
@@ -214,9 +215,8 @@ export default function modeSwitchExtension(pi: ExtensionAPI): void {
 	}
 
 	// Apply a mode change to state and persistence. Shared by every path: the
-	// Alt+M / command path (which adds a UI toast and injects guidance on the
-	// next turn) and the CLI path (which already handed the agent its guidance via
-	// stdout).
+	// Shortcut/command changes add a UI toast and inject guidance on the next
+	// turn; the CLI path has already handed the agent its guidance via stdout.
 	function applyMode(next: Mode): void {
 		currentMode = next;
 		repaint();
@@ -241,8 +241,8 @@ export default function modeSwitchExtension(pi: ExtensionAPI): void {
 	// requested mode to <root>/mode-switch/request.json. We pick that up live via
 	// fs.watch (with a before_agent_start reconcile as a backstop) only to sync the
 	// badge and persisted state — never to inject guidance, since the CLI already
-	// printed it to the agent's bash output. The request is consumed on read so a
-	// later Alt+M can't be clobbered by a stale request.
+	// printed it to the agent's bash output. Token gating ensures a later
+	// shortcut-driven change can't be clobbered by a stale request.
 	function applyFromRequest(next: Mode, source: "cli" | "attach"): void {
 		if (next === currentMode) return;
 		applyMode(next);
@@ -266,7 +266,7 @@ export default function modeSwitchExtension(pi: ExtensionAPI): void {
 		// Apply each CLI request at most once (token-gated) and never delete it, so
 		// every live instance — including the one actually on screen — converges to the
 		// requested mode regardless of /reload leftovers. A lingering request whose
-		// token we already applied can't clobber a later Alt+M.
+		// token we already applied can't clobber a later shortcut-driven change.
 		if (parsed.token && parsed.token === lastAppliedToken) return;
 		lastAppliedToken = parsed.token;
 		if (parsed.mode && (CYCLE as string[]).includes(parsed.mode)) {
@@ -291,11 +291,16 @@ export default function modeSwitchExtension(pi: ExtensionAPI): void {
 		setMode(CYCLE[(idx + 1) % CYCLE.length], ctx);
 	}
 
-	// Alt+M cycles modes.
-	pi.registerShortcut("alt+m", {
-		description: "Cycle mode (normal → spec → plan)",
-		handler: async (ctx) => cycleMode(ctx),
-	});
+	// Resolve once when the extension loads. Crouter's sparse user config owns
+	// this semantic action; pi's stock action bindings remain independently owned
+	// by pi and are neither read nor rewritten here.
+	const bindings = resolveUserKeybindings();
+	for (const gesture of bindings.gestures("crtr.mode.cycle")) {
+		pi.registerShortcut(gesture, {
+			description: "Cycle mode (normal → spec → plan)",
+			handler: async (ctx) => cycleMode(ctx),
+		});
+	}
 
 	// /mode cycles; /mode <name> jumps to a specific mode.
 	pi.registerCommand("mode", {

package/dist/builtin-pi-packages/pi-mode-switch/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-mode-switch",
   "version": "0.1.0",
-  "description": "Press Alt+M to cycle between spec, plan, and normal modes. Injects mode-specific operating guidance whenever the mode changes.",
+  "description": "Cycle between spec, plan, and normal modes with crouter's configurable mode binding. Injects mode-specific guidance whenever the mode changes.",
   "keywords": ["pi-package", "modes", "spec", "plan"],
   "license": "MIT",
   "peerDependencies": {

package/dist/builtin-views/canvas/tui.mjs

@@ -127,12 +127,12 @@ export function render(state, draw, content) {
     if (state.totalNodes === 0) {
       emptyState(draw, content, {
         headline: 'No nodes on the canvas',
-        secondary: ['Spawn one with `crtr node new`.', 'Press g to refresh.'],
+        secondary: ['Spawn one with `crtr node new`.', 'Use refresh to update.'],
       });
     } else {
       emptyState(draw, content, {
         headline: 'All caught up',
-        secondary: [`${state.totalNodes} node${state.totalNodes === 1 ? '' : 's'} finished — none active.`, 'Press g to refresh.'],
+        secondary: [`${state.totalNodes} node${state.totalNodes === 1 ? '' : 's'} finished — none active.`, 'Use refresh to update.'],
       });
     }
     return;
@@ -156,14 +156,13 @@ export function render(state, draw, content) {
 // ── keymap ───────────────────────────────────────────────────────────────
 
 /**
- * Read-only navigation: j/k move the cursor, g refreshes, q quits. No async
- * actions from input — this is a monitor, not a controller. Footer hints come
- * from these bindings' `hint` fields (the single source of truth).
+ * Read-only navigation. No async actions from input — this is a monitor, not a
+ * controller. Footer hints come from these bindings' `hint` fields.
  * @type {import('../../core/view/contract.js').KeyBinding<CanvasState>[]}
  */
 export const keymap = [
-  { keys: ['j', 'down'], intent: 'cursorDown', hint: { keys: 'j/k', label: 'move' } },
-  { keys: ['k', 'up'], intent: 'cursorUp' },
-  { keys: ['g'], intent: 'refresh', hint: { keys: 'g', label: 'refresh' } },
-  { keys: ['q'], intent: 'quit', hint: { keys: 'q', label: 'quit' } },
+  { bindingId: 'crtr.view.canvas.down', intent: 'cursorDown', hint: { label: 'move' } },
+  { bindingId: 'crtr.view.canvas.up', intent: 'cursorUp' },
+  { bindingId: 'crtr.view.canvas.refresh', intent: 'refresh', hint: { label: 'refresh' } },
+  { bindingId: 'crtr.view.canvas.quit', intent: 'quit', hint: { label: 'quit' } },
 ];

package/dist/builtin-views/chat/tui.mjs

@@ -275,7 +275,7 @@ function renderTakeover(state, draw, content) {
     errorState(draw, content, {
       headline: 'Missing target',
       cause: 'run crtr view run chat --target <node-id>',
-      hint: 'Press q to quit.',
+      hint: 'Use the view quit control.',
     });
     return;
   }
@@ -285,7 +285,7 @@ function renderTakeover(state, draw, content) {
       glyphFg: '33',
       headline: 'Node asleep',
       explanation: 'node is asleep / focus or revive it first',
-      nextStep: 'Press r after revive.',
+      nextStep: 'Reconnect after revive.',
     });
     return;
   }
@@ -293,7 +293,7 @@ function renderTakeover(state, draw, content) {
     errorState(draw, content, {
       headline: 'Node not found',
       cause: 'check the target',
-      hint: 'Press q to quit.',
+      hint: 'Use the view quit control.',
     });
     return;
   }
@@ -354,15 +354,15 @@ const canCompose = (state) => state.target != null && state.conn !== 'no-broker'
 
 /** @type {import('../../core/view/contract.js').KeyBinding<ChatState>[]} */
 export const keymap = [
-  { capture: 'setDraft', when: canCompose, hint: { keys: 'type', label: 'compose' } },
-  { keys: ['return', 'enter'], intent: 'submitDraft', when: canCompose, hint: { keys: 'enter', label: 'send' } },
-  { keys: ['escape', 'esc'], intent: 'abort', when: isControllerStreaming },
-  { keys: ['escape', 'esc'], intent: 'clearNotice', when: hasNotice, payload: (state) => state.notices[state.notices.length - 1]?.id },
-  { keys: ['escape', 'esc'], intent: 'setDraft', when: hasDraft, payload: () => '' },
-  { keys: ['r'], intent: 'reconnect', when: canCompose, hint: { keys: 'r', label: 'reconnect' } },
-  { keys: ['c'], intent: 'requestControl', when: isObserver, hint: { keys: 'c', label: 'control' } },
-  { keys: ['C', 'ctrl+r'], intent: 'releaseControl', when: isController, hint: { keys: 'C', label: 'yield' } },
-  { keys: ['q'], intent: 'quit', hint: { keys: 'q', label: 'quit' } },
+  { capture: 'setDraft', when: canCompose, hint: { label: 'compose' } },
+  { bindingId: 'crtr.view.chat.submit', intent: 'submitDraft', when: canCompose, hint: { label: 'send' } },
+  { bindingId: 'crtr.view.chat.contextual-cancel', intent: 'abort', when: isControllerStreaming },
+  { bindingId: 'crtr.view.chat.contextual-cancel', intent: 'clearNotice', when: hasNotice, payload: (state) => state.notices[state.notices.length - 1]?.id },
+  { bindingId: 'crtr.view.chat.contextual-cancel', intent: 'setDraft', when: hasDraft, payload: () => '' },
+  { bindingId: 'crtr.view.chat.reconnect', intent: 'reconnect', when: canCompose, hint: { label: 'reconnect' } },
+  { bindingId: 'crtr.view.chat.request-control', intent: 'requestControl', when: isObserver, hint: { label: 'control' } },
+  { bindingId: 'crtr.view.chat.release-control', intent: 'releaseControl', when: isController, hint: { label: 'yield' } },
+  { bindingId: 'crtr.view.chat.quit', intent: 'quit', hint: { label: 'quit' } },
 ];
 
 export default { render, keymap };

package/dist/builtin-views/git-pr/tui.mjs

@@ -275,7 +275,7 @@ export function render(state, draw, content) {
   if (g.files.length === 0 && state.prs.length === 0 && !state.prNote) {
     emptyState(draw, bodyRect, {
       headline: 'All clear',
-      secondary: [`${g.branch} — clean working tree, no open PRs.`, 'Press g to refresh.'],
+      secondary: [`${g.branch} — clean working tree, no open PRs.`, 'Use refresh to update.'],
     });
     return;
   }
@@ -289,14 +289,13 @@ export function render(state, draw, content) {
 // ── keymap ───────────────────────────────────────────────────────────────
 
 /**
- * Read-only navigation: j/k move the cursor, g refreshes, q quits. No async
- * actions from input — this is a monitor, not a controller. Footer hints come
- * from these bindings' `hint` fields (the single source of truth).
+ * Read-only navigation. No async actions from input — this is a monitor, not a
+ * controller. Footer hints come from these bindings' `hint` fields.
  * @type {import('../../core/view/contract.js').KeyBinding<GitPrState>[]}
  */
 export const keymap = [
-  { keys: ['j', 'down'], intent: 'cursorDown', hint: { keys: 'j/k', label: 'move' } },
-  { keys: ['k', 'up'], intent: 'cursorUp' },
-  { keys: ['g'], intent: 'refresh', hint: { keys: 'g', label: 'refresh' } },
-  { keys: ['q'], intent: 'quit', hint: { keys: 'q', label: 'quit' } },
+  { bindingId: 'crtr.view.git-pr.down', intent: 'cursorDown', hint: { label: 'move' } },
+  { bindingId: 'crtr.view.git-pr.up', intent: 'cursorUp' },
+  { bindingId: 'crtr.view.git-pr.refresh', intent: 'refresh', hint: { label: 'refresh' } },
+  { bindingId: 'crtr.view.git-pr.quit', intent: 'quit', hint: { label: 'quit' } },
 ];

package/dist/builtin-views/inbox/tui.mjs

@@ -33,7 +33,7 @@ function renderGuided(draw, content, guide) {
     errorState(draw, content, {
       headline,
       cause: d.explanation,
-      hint: d.nextStep || 'Press g to retry.',
+      hint: d.nextStep || 'Refresh to retry.',
     });
     return;
   }
@@ -149,11 +149,10 @@ function renderThreadBody(state, draw, rect, reactTarget) {
   }
 }
 
-/** The compose bar (reply mode): hairline + label + draft + cursor + hint. */
+/** The compose bar (reply mode): hairline + label + draft + cursor. */
 function renderComposer(state, draw, right) {
-  const hairRow = right.row + right.height - 3;
-  const barRow = right.row + right.height - 2;
-  const hintRow = right.row + right.height - 1;
+  const hairRow = right.row + right.height - 2;
+  const barRow = right.row + right.height - 1;
   draw.hline(hairRow, right.col, right.col + right.width);
   const label = '✎ Reply ';
   const labelW = Array.from(label).length;
@@ -166,18 +165,12 @@ function renderComposer(state, draw, right) {
     { text: shown },
     { text: '█', style: { fg: '33' } },
   ], right.width);
-  draw.spans(hintRow, right.col, [
-    { text: 'enter', style: { bold: true } }, { text: ' send', style: { dim: true } },
-    { text: ' · ', style: { dim: true } },
-    { text: 'esc', style: { bold: true } }, { text: ' cancel', style: { dim: true } },
-  ], right.width);
 }
 
-/** The react picker bar (react mode): hairline + emoji chip row + hint. */
+/** The react picker bar (react mode): hairline + emoji chip row. */
 function renderReactBar(state, draw, right) {
-  const hairRow = right.row + right.height - 3;
-  const barRow = right.row + right.height - 2;
-  const hintRow = right.row + right.height - 1;
+  const hairRow = right.row + right.height - 2;
+  const barRow = right.row + right.height - 1;
   draw.hline(hairRow, right.col, right.col + right.width);
   /** @type {object[]} */
   const spans = [{ text: '☺ React ', style: { fg: '33', bold: true } }];
@@ -190,13 +183,6 @@ function renderReactBar(state, draw, right) {
     }
   });
   draw.spans(barRow, right.col, spans, right.width);
-  draw.spans(hintRow, right.col, [
-    { text: '←/→', style: { bold: true } }, { text: ' pick', style: { dim: true } },
-    { text: ' · ', style: { dim: true } },
-    { text: 'enter', style: { bold: true } }, { text: ' react', style: { dim: true } },
-    { text: ' · ', style: { dim: true } },
-    { text: 'esc', style: { bold: true } }, { text: ' cancel', style: { dim: true } },
-  ], right.width);
 }
 
 /**
@@ -210,7 +196,7 @@ function renderDetail(state, draw, right) {
     centeredStack(draw, right, [
       [{ text: '✉  ', style: { dim: true } }, { text: 'No conversation open', style: { dim: true } }],
       [{ text: '' }],
-      [{ text: 'Press ' }, { text: 'Enter', style: { bold: true } }, { text: ' to open a conversation' }],
+      [{ text: 'Open a conversation to view it.', style: { dim: true } }],
     ]);
     return;
   }
@@ -233,7 +219,7 @@ function renderDetail(state, draw, right) {
 
   const composing = state.mode === 'reply';
   const reacting = state.mode === 'react';
-  const composerRows = composing || reacting ? 3 : 0;
+  const composerRows = composing || reacting ? 2 : 0;
   const bodyTop = right.row + headerRows + 1;
   const bodyBottom = right.row + right.height - 1 - composerRows;
   const bodyRect = { row: bodyTop, col: right.col, width: right.width, height: Math.max(0, bodyBottom - bodyTop + 1) };
@@ -269,7 +255,7 @@ export function render(state, draw, content) {
     }
     emptyState(draw, content, {
       headline: 'All caught up',
-      secondary: ['No messages in your inbox.', 'Press g to refresh.'],
+      secondary: ['No messages in your inbox.', 'Refresh to check again.'],
     });
     return;
   }
@@ -290,23 +276,23 @@ const reactMode = (s) => s.mode === 'react';
 /** @type {import('../../core/view/contract.js').KeyBinding<InboxState>[]} */
 export const keymap = [
   // list
-  { keys: ['j', 'down'], intent: 'cursorDown', when: listMode, hint: { keys: 'j/k', label: 'move' } },
-  { keys: ['k', 'up'], intent: 'cursorUp', when: listMode },
-  { keys: ['return'], intent: 'open', payload: (s) => s.cursor, when: listMode, hint: { keys: 'enter', label: 'open' } },
-  { keys: ['r'], intent: 'startReply', when: listMode, hint: { keys: 'r', label: 'reply' } },
-  { keys: ['e'], intent: 'startReact', when: listMode, hint: { keys: 'e', label: 'react' } },
-  { keys: ['f'], intent: 'cycleFilter', when: listMode, hint: { keys: 'f', label: 'filter' } },
-  { keys: ['g'], intent: 'refresh', when: listMode, hint: { keys: 'g', label: 'refresh' } },
-  { keys: ['L'], intent: 'connectLinkedin', when: listMode },
-  { keys: ['G'], intent: 'connectGmail', when: listMode, hint: { keys: 'G', label: 'connect' } },
-  { keys: ['q'], intent: 'quit', when: listMode, hint: { keys: 'q', label: 'quit' } },
+  { bindingId: 'crtr.view.inbox.down', intent: 'cursorDown', when: listMode, hint: { label: 'move' } },
+  { bindingId: 'crtr.view.inbox.up', intent: 'cursorUp', when: listMode },
+  { bindingId: 'crtr.view.inbox.open', intent: 'open', payload: (s) => s.cursor, when: listMode, hint: { label: 'open' } },
+  { bindingId: 'crtr.view.inbox.reply', intent: 'startReply', when: listMode, hint: { label: 'reply' } },
+  { bindingId: 'crtr.view.inbox.react', intent: 'startReact', when: listMode, hint: { label: 'react' } },
+  { bindingId: 'crtr.view.inbox.filter', intent: 'cycleFilter', when: listMode, hint: { label: 'filter' } },
+  { bindingId: 'crtr.view.inbox.refresh', intent: 'refresh', when: listMode, hint: { label: 'refresh' } },
+  { bindingId: 'crtr.view.inbox.connect-linkedin', intent: 'connectLinkedin', when: listMode },
+  { bindingId: 'crtr.view.inbox.connect-gmail', intent: 'connectGmail', when: listMode, hint: { label: 'connect' } },
+  { bindingId: 'crtr.view.inbox.quit', intent: 'quit', when: listMode, hint: { label: 'quit' } },
   // reply
-  { capture: 'setDraft', when: replyMode, hint: { keys: 'type', label: 'reply' } },
-  { keys: ['return'], intent: 'submitReply', when: replyMode },
-  { keys: ['escape'], intent: 'cancelCompose', when: replyMode },
+  { capture: 'setDraft', when: replyMode, hint: { label: 'reply' } },
+  { bindingId: 'crtr.view.inbox.submit-reply', intent: 'submitReply', when: replyMode, hint: { label: 'send' } },
+  { bindingId: 'crtr.view.inbox.cancel', intent: 'cancelCompose', when: replyMode, hint: { label: 'cancel' } },
   // react
-  { keys: ['h', 'left'], intent: 'reactPrev', when: reactMode },
-  { keys: ['l', 'right'], intent: 'reactNext', when: reactMode },
-  { keys: ['return'], intent: 'submitReact', when: reactMode },
-  { keys: ['escape'], intent: 'cancelCompose', when: reactMode },
+  { bindingId: 'crtr.view.inbox.reaction-previous', intent: 'reactPrev', when: reactMode, hint: { label: 'pick' } },
+  { bindingId: 'crtr.view.inbox.reaction-next', intent: 'reactNext', when: reactMode },
+  { bindingId: 'crtr.view.inbox.submit-reaction', intent: 'submitReact', when: reactMode, hint: { label: 'react' } },
+  { bindingId: 'crtr.view.inbox.cancel', intent: 'cancelCompose', when: reactMode, hint: { label: 'cancel' } },
 ];

package/dist/builtin-views/linkedin/tui.mjs

@@ -274,9 +274,8 @@ function renderThreadBody(state, draw, rect, reactTarget) {
 
 /** The compose bar (reply mode). @param {LiState} state @param {Draw} draw @param {Rect} right */
 function renderComposer(state, draw, right) {
-  const hairRow = right.row + right.height - 3;
-  const barRow = right.row + right.height - 2;
-  const hintRow = right.row + right.height - 1;
+  const hairRow = right.row + right.height - 2;
+  const barRow = right.row + right.height - 1;
   draw.hline(hairRow, right.col, right.col + right.width);
   const label = '✎ Reply ';
   const labelW = Array.from(label).length;
@@ -289,18 +288,12 @@ function renderComposer(state, draw, right) {
     { text: shown },
     { text: '█', style: { fg: '33' } },
   ], right.width);
-  draw.spans(hintRow, right.col, [
-    { text: 'enter', style: { bold: true } }, { text: ' send', style: { dim: true } },
-    { text: ' · ', style: { dim: true } },
-    { text: 'esc', style: { bold: true } }, { text: ' cancel', style: { dim: true } },
-  ], right.width);
 }
 
 /** The react picker bar (react mode). @param {LiState} state @param {Draw} draw @param {Rect} right */
 function renderReactBar(state, draw, right) {
-  const hairRow = right.row + right.height - 3;
-  const barRow = right.row + right.height - 2;
-  const hintRow = right.row + right.height - 1;
+  const hairRow = right.row + right.height - 2;
+  const barRow = right.row + right.height - 1;
   draw.hline(hairRow, right.col, right.col + right.width);
   /** @type {Span[]} */
   const spans = [{ text: '☺ React ', style: { fg: '33', bold: true } }];
@@ -313,13 +306,6 @@ function renderReactBar(state, draw, right) {
     }
   });
   draw.spans(barRow, right.col, spans, right.width);
-  draw.spans(hintRow, right.col, [
-    { text: '←/→', style: { bold: true } }, { text: ' pick', style: { dim: true } },
-    { text: ' · ', style: { dim: true } },
-    { text: 'enter', style: { bold: true } }, { text: ' react', style: { dim: true } },
-    { text: ' · ', style: { dim: true } },
-    { text: 'esc', style: { bold: true } }, { text: ' cancel', style: { dim: true } },
-  ], right.width);
 }
 
 /** Right pane — the open thread + the compose/react bar when in a mode. @param {LiState} state @param {Draw} draw @param {Rect} right */
@@ -331,7 +317,7 @@ function renderThread(state, draw, right) {
     centeredStack(draw, right, [
       [{ text: '✉  ', style: { dim: true } }, { text: 'No conversation open', style: { dim: true } }],
       [{ text: '' }],
-      [{ text: 'Press ' }, { text: 'Enter', style: { bold: true } }, { text: ' to open a conversation' }],
+      [{ text: 'Open a conversation to view it.', style: { dim: true } }],
     ]);
     return;
   }
@@ -345,7 +331,7 @@ function renderThread(state, draw, right) {
 
   const composing = state.mode === 'reply';
   const reacting = state.mode === 'react';
-  const composerRows = composing || reacting ? 3 : 0;
+  const composerRows = composing || reacting ? 2 : 0;
   const bodyTop = right.row + 2;
   const bodyBottom = right.row + right.height - 1 - composerRows;
   const bodyRect = { row: bodyTop, col: right.col, width: right.width, height: Math.max(0, bodyBottom - bodyTop + 1) };
@@ -380,7 +366,7 @@ export function render(state, draw, content) {
     }
     emptyState(draw, content, {
       headline: 'All caught up',
-      secondary: ['No conversations in your inbox.', 'Press g to refresh.'],
+      secondary: ['No conversations in your inbox.', 'Refresh to check again.'],
     });
     return;
   }
@@ -403,25 +389,25 @@ const isComposeOrReact = (s) => s.mode === 'reply' || s.mode === 'react';
 /**
  * Input→intent map. List-mode navigation + entry into compose/react; the compose
  * bar uses a `capture` binding (the host's line-editor dispatches setDraft with
- * the next draft); react uses h/l + arrows. Footer hints come from these `hint`
- * fields (single source of truth).
+ * the next draft). Footer hints come from these `hint` fields (single source of
+ * truth).
  * @type {import('../../core/view/contract.js').KeyBinding<LiState>[]}
  */
 export const keymap = [
   // ── List mode ──
-  { keys: ['j', 'down'], intent: 'cursorDown', when: isList, hint: { keys: 'j/k', label: 'move' } },
-  { keys: ['k', 'up'], intent: 'cursorUp', when: isList },
-  { keys: ['enter', 'return'], intent: 'openThread', payload: (s) => s.convCursor, when: isList, hint: { keys: 'enter', label: 'open' } },
-  { keys: ['r'], intent: 'startReply', when: isList, hint: { keys: 'r', label: 'reply' } },
-  { keys: ['e'], intent: 'startReact', when: isList, hint: { keys: 'e', label: 'react' } },
-  { keys: ['g'], intent: 'refresh', when: isList, hint: { keys: 'g', label: 'refresh' } },
-  { keys: ['q'], intent: 'quit', when: isList, hint: { keys: 'q', label: 'quit' } },
-  // ── Reply mode ── (capture → setDraft; enter sends; esc cancels)
-  { capture: 'setDraft', when: isReply },
-  { keys: ['enter', 'return'], intent: 'submitReply', when: isReply },
-  { keys: ['escape', 'esc'], intent: 'cancelCompose', when: isComposeOrReact },
+  { bindingId: 'crtr.view.linkedin.down', intent: 'cursorDown', when: isList, hint: { label: 'move' } },
+  { bindingId: 'crtr.view.linkedin.up', intent: 'cursorUp', when: isList },
+  { bindingId: 'crtr.view.linkedin.open', intent: 'openThread', payload: (s) => s.convCursor, when: isList, hint: { label: 'open' } },
+  { bindingId: 'crtr.view.linkedin.reply', intent: 'startReply', when: isList, hint: { label: 'reply' } },
+  { bindingId: 'crtr.view.linkedin.react', intent: 'startReact', when: isList, hint: { label: 'react' } },
+  { bindingId: 'crtr.view.linkedin.refresh', intent: 'refresh', when: isList, hint: { label: 'refresh' } },
+  { bindingId: 'crtr.view.linkedin.quit', intent: 'quit', when: isList, hint: { label: 'quit' } },
+  // ── Reply mode ──
+  { capture: 'setDraft', when: isReply, hint: { label: 'reply' } },
+  { bindingId: 'crtr.view.linkedin.submit-reply', intent: 'submitReply', when: isReply, hint: { label: 'send' } },
+  { bindingId: 'crtr.view.linkedin.cancel', intent: 'cancelCompose', when: isComposeOrReact, hint: { label: 'cancel' } },
   // ── React mode ──
-  { keys: ['left', 'h'], intent: 'reactPrev', when: isReact },
-  { keys: ['right', 'l'], intent: 'reactNext', when: isReact },
-  { keys: ['enter', 'return'], intent: 'submitReact', when: isReact },
+  { bindingId: 'crtr.view.linkedin.reaction-previous', intent: 'reactPrev', when: isReact, hint: { label: 'pick' } },
+  { bindingId: 'crtr.view.linkedin.reaction-next', intent: 'reactNext', when: isReact },
+  { bindingId: 'crtr.view.linkedin.submit-reaction', intent: 'submitReact', when: isReact, hint: { label: 'react' } },
 ];

package/dist/builtin-views/prompt-review/tui.mjs

@@ -107,14 +107,14 @@ export function render(state, draw, content) {
     return;
   }
   if (state.review.length === 0) {
-    emptyState(draw, content, { headline: 'No prompt layers', secondary: ['Press g to refresh.'] });
+    emptyState(draw, content, { headline: 'No prompt layers', secondary: ['Refresh to try again.'] });
     return;
   }
 
   const headerRows = 3;
   draw.text(content.row, content.col, 'Prompt Studio', { bold: true });
   draw.text(content.row + 1, content.col, configHeadline(state.config), { dim: true });
-  draw.text(content.row + 2, content.col, `j/k layer · h/l compare · tab raw/layered · e export · g refresh${state.lastExportPath ? ` · ${state.lastExportPath}` : ''}`, { dim: true });
+  draw.text(content.row + 2, content.col, `Layer navigation · comparison · raw/layered · export · refresh${state.lastExportPath ? ` · ${state.lastExportPath}` : ''}`, { dim: true });
 
   const body = { row: content.row + headerRows + 1, col: content.col, width: content.width, height: Math.max(0, content.height - headerRows - 1) };
   const cols = draw.columns(body, [3, 5, 4]);
@@ -184,13 +184,13 @@ export function render(state, draw, content) {
 }
 
 export const keymap = [
-  { keys: ['j', 'down'], intent: 'cursorDown', hint: { keys: 'j/k', label: 'layer' } },
-  { keys: ['k', 'up'], intent: 'cursorUp' },
-  { keys: ['h', 'left'], intent: 'compareCursorUp', hint: { keys: 'h/l', label: 'compare' } },
-  { keys: ['l', 'right'], intent: 'compareCursorDown' },
-  { keys: ['tab'], intent: 'setViewMode', payload: (s) => (s.viewMode === 'raw' ? 'layered' : 'raw'), hint: { keys: 'tab', label: 'raw/layered' } },
-  { keys: ['enter', 'return'], intent: 'toggleLayerExpanded', payload: (s) => s.selectedLayerId || (s.review && s.review[s.cursor] && s.review[s.cursor].id) || '', hint: { keys: 'enter', label: 'expand' } },
-  { keys: ['e'], intent: 'exportComments', hint: { keys: 'e', label: 'export' } },
-  { keys: ['g'], intent: 'refresh', hint: { keys: 'g', label: 'refresh' } },
-  { keys: ['q'], intent: 'quit', hint: { keys: 'q', label: 'quit' } },
+  { bindingId: 'crtr.view.prompt-review.down', intent: 'cursorDown', hint: { label: 'layer' } },
+  { bindingId: 'crtr.view.prompt-review.up', intent: 'cursorUp' },
+  { bindingId: 'crtr.view.prompt-review.compare-previous', intent: 'compareCursorUp', hint: { label: 'compare' } },
+  { bindingId: 'crtr.view.prompt-review.compare-next', intent: 'compareCursorDown' },
+  { bindingId: 'crtr.view.prompt-review.toggle-mode', intent: 'setViewMode', payload: (s) => (s.viewMode === 'raw' ? 'layered' : 'raw'), hint: { label: 'raw/layered' } },
+  { bindingId: 'crtr.view.prompt-review.expand', intent: 'toggleLayerExpanded', payload: (s) => s.selectedLayerId || (s.review && s.review[s.cursor] && s.review[s.cursor].id) || '', hint: { label: 'expand' } },
+  { bindingId: 'crtr.view.prompt-review.export', intent: 'exportComments', hint: { label: 'export' } },
+  { bindingId: 'crtr.view.prompt-review.refresh', intent: 'refresh', hint: { label: 'refresh' } },
+  { bindingId: 'crtr.view.prompt-review.quit', intent: 'quit', hint: { label: 'quit' } },
 ];