@crouton-kit/crouter 0.3.70 → 0.3.79

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' } },
 ];

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

@@ -61,8 +61,8 @@ export function render(state, draw, content) {
   }
 
   const header = state.edit
-    ? `Replacing ${state.edit.label} — Enter saves, Esc cancels`
-    : 'j/k move · h/l switch matrix cell · enter edit · g refresh';
+    ? `Replacing ${state.edit.label} — submit saves, cancel discards`
+    : 'Move · switch matrix cell · edit · refresh';
   draw.text(content.row, content.col, 'Model ladders', { bold: true });
   draw.text(content.row + 1, content.col, header, { dim: true });
   if (state.edit) {
@@ -76,14 +76,14 @@ export function render(state, draw, content) {
 }
 
 export const keymap = [
-  { keys: ['j', 'down'], intent: 'cursorDown', when: (s) => !s.edit, hint: { keys: 'j/k', label: 'move' } },
-  { keys: ['k', 'up'], intent: 'cursorUp', when: (s) => !s.edit },
-  { keys: ['h', 'left'], intent: 'matrixLeft', when: (s) => !s.edit, hint: { keys: 'h/l', label: 'switch cell' } },
-  { keys: ['l', 'right'], intent: 'matrixRight', when: (s) => !s.edit },
-  { keys: ['g'], intent: 'refresh', when: (s) => !s.edit, hint: { keys: 'g', label: 'refresh' } },
-  { keys: ['q'], intent: 'quit', hint: { keys: 'q', label: 'quit' } },
+  { bindingId: 'crtr.view.settings.down', intent: 'cursorDown', when: (s) => !s.edit, hint: { label: 'move' } },
+  { bindingId: 'crtr.view.settings.up', intent: 'cursorUp', when: (s) => !s.edit },
+  { bindingId: 'crtr.view.settings.cell-previous', intent: 'matrixLeft', when: (s) => !s.edit, hint: { label: 'switch cell' } },
+  { bindingId: 'crtr.view.settings.cell-next', intent: 'matrixRight', when: (s) => !s.edit },
+  { bindingId: 'crtr.view.settings.refresh', intent: 'refresh', when: (s) => !s.edit, hint: { label: 'refresh' } },
+  { bindingId: 'crtr.view.settings.quit', intent: 'quit', hint: { label: 'quit' } },
   { capture: 'setDraft', when: (s) => !!s.edit },
-  { keys: ['enter', 'return'], intent: 'submitEdit', when: (s) => !!s.edit },
-  { keys: ['enter', 'return'], intent: 'beginEdit', when: (s) => !s.edit, hint: { keys: 'enter', label: 'edit' } },
-  { keys: ['escape', 'esc'], intent: 'cancelEdit', when: (s) => !!s.edit },
+  { bindingId: 'crtr.view.settings.edit-or-submit', intent: 'submitEdit', when: (s) => !!s.edit },
+  { bindingId: 'crtr.view.settings.edit-or-submit', intent: 'beginEdit', when: (s) => !s.edit, hint: { label: 'edit' } },
+  { bindingId: 'crtr.view.settings.cancel-edit', intent: 'cancelEdit', when: (s) => !!s.edit },
 ];

package/dist/builtin-views/workspace-sidebar/tui.mjs

@@ -115,7 +115,7 @@ export function render(state, draw, content) {
     }
     emptyState(draw, content, {
       headline: 'No agents here',
-      secondary: ['Nothing started in this cwd.', 'Press g to refresh.'],
+      secondary: ['Nothing started in this cwd.', 'Refresh to try again.'],
     });
     return;
   }
@@ -128,15 +128,14 @@ export function render(state, draw, content) {
 // ── keymap ───────────────────────────────────────────────────────────────
 
 /**
- * j/k move the cursor over node rows, ↵ swaps the selected node into the chat
- * pane (the controller action), g refreshes, q quits. Footer hints come from
- * these bindings' `hint` fields (the single source of truth).
+ * Move over node rows, open the selected node in the chat pane, refresh, or
+ * leave the view. Footer hints use the host-resolved binding gestures.
  * @type {import('../../core/view/contract.js').KeyBinding<SidebarState>[]}
  */
 export const keymap = [
-  { keys: ['j', 'down'], intent: 'cursorDown', hint: { keys: 'j/k', label: 'move' } },
-  { keys: ['k', 'up'], intent: 'cursorUp' },
-  { keys: ['return', 'enter'], intent: 'open', hint: { keys: '↵', label: 'open' } },
-  { keys: ['g', 'r'], intent: 'refresh', hint: { keys: 'g', label: 'refresh' } },
-  { keys: ['q'], intent: 'quit', hint: { keys: 'q', label: 'quit' } },
+  { bindingId: 'crtr.view.workspace-sidebar.down', intent: 'cursorDown', hint: { label: 'move' } },
+  { bindingId: 'crtr.view.workspace-sidebar.up', intent: 'cursorUp' },
+  { bindingId: 'crtr.view.workspace-sidebar.open', intent: 'open', hint: { label: 'open' } },
+  { bindingId: 'crtr.view.workspace-sidebar.refresh', intent: 'refresh', hint: { label: 'refresh' } },
+  { bindingId: 'crtr.view.workspace-sidebar.quit', intent: 'quit', hint: { label: 'quit' } },
 ];