From b3c07f89f4898dcbeb4ce6c9f5646d21fe6815a2 Mon Sep 17 00:00:00 2001
From: amosblomqvist <amosblomqvist@gmail.com>
Date: Fri, 25 Sep 2026 02:39:11 +0300
Subject: [PATCH] =?UTF-8?q?Fix=20=E2=8C=98B:=20dispatch/listen=20event-nam?=
 =?UTF-8?q?e=20mismatch;=20thinking=20pill=20=E2=86=92=20"Thinking=20(?=
 =?UTF-8?q?=E2=87=A7=E2=87=A5)"?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Root cause (interlude, owner 2026-09-25): keyboard-shortcuts dispatches
registry actions on the lh:kbd-<action> convention, but the sidebar's
listener sat on the pre-convention name "lh:toggle-sidebar" — a name
nothing ever dispatches, so ⌘B silently did nothing while its tooltip
and cheat-sheet row kept claiming the binding. A sweep of every lh:
listener confirmed the sidebar was the lone stray (chat-renamed and
graph-revision are deliberate non-kbd events).

Fix, structural: kbdEventForAction(action) exported from
src/core/keyboard.ts — the ONE spelling — and both sides compose
through it (dispatcher's default branch, sidebar's toggle listener);
keyboard-shortcuts re-exports the helper so the contract pin can assert
no second spelling exists. The mismatch is now impossible by
construction.

Thinking pill: label trimmed to "Thinking" with its real shortcut via
the registry-composition path — "Thinking (⇧⇥)" (cycle-thinking,
rebind-live like every Hint suffix).

Pins (tests/keyboard-toggle-sidebar.test.ts): the full chain — mod+b →
actionForBinding → toggle-sidebar → kbdEventForAction →
lh:kbd-toggle-sidebar; formatBinding("shift+tab") → ⇧⇥; the
dispatcher-imports-the-same-helper contract.

Live-verified on :3001: ⌘B visually toggles on home, /chat/[id], and
/chat/new (sidebar 0↔288px, hamburger slot 0↔36); with the rebind
lh:keymap {"toggle-sidebar":"mod+j"}: ⌘J toggles and ⌘B is inert
(rebind-live); thinking pill renders "Thinking (⇧⇥)"; keymap restored,
sidebar left open.
---
 components/keyboard-shortcuts.tsx     |  8 ++++-
 components/model-picker.tsx           |  7 ++--
 components/sidebar.tsx                | 14 +++++---
 src/core/keyboard.ts                  | 12 +++++++
 tests/keyboard-toggle-sidebar.test.ts | 51 +++++++++++++++++++++++++++
 5 files changed, 85 insertions(+), 7 deletions(-)
 create mode 100644 tests/keyboard-toggle-sidebar.test.ts

diff --git a/components/keyboard-shortcuts.tsx b/components/keyboard-shortcuts.tsx
index 2bcffb2..19e6977 100644
--- a/components/keyboard-shortcuts.tsx
+++ b/components/keyboard-shortcuts.tsx
@@ -31,11 +31,17 @@ import {
 	eventBinding,
 	formatBinding,
 	isTypingSurface,
+	kbdEventForAction,
 	KEYBOARD_ACTIONS,
 } from "@/src/core";
 import { isDictationActive } from "@/components/dictation";
 import { useSettingsDialog } from "@/components/settings/settings-dialog.tsx";
 
+// Re-exported for the contract pin (tests/keyboard-toggle-sidebar.test.ts):
+// the dispatcher composes event names through the ONE helper — a second
+// spelling here is how the ⌘B bug happened.
+export { kbdEventForAction };
+
 export function KeyboardShortcuts() {
 	const router = useRouter();
 	const [cheatOpen, setCheatOpen] = useState(false);
@@ -109,7 +115,7 @@ export function KeyboardShortcuts() {
 					handlersRef.current.setCheatOpen(true);
 					break;
 				default:
-					window.dispatchEvent(new CustomEvent(`lh:kbd-${action}`));
+					window.dispatchEvent(new CustomEvent(kbdEventForAction(action)));
 			}
 		};
 		window.addEventListener("keydown", onKeyDown);
diff --git a/components/model-picker.tsx b/components/model-picker.tsx
index 15d4536..59536d1 100644
--- a/components/model-picker.tsx
+++ b/components/model-picker.tsx
@@ -277,8 +277,11 @@ export function ModelControl() {
 			</button>
 			</Hint>
 			<Hint
-				// Trimmed (owner, subtlety round 2026-09-25).
-				label="Thinking level"
+				// "Thinking" + its real shortcut via the registry (owner interlude
+				// 2026-09-25): ⇧⇥ cycles the level, so "Thinking (⇧⇥)" —
+				// rebind-live like every Hint suffix.
+				label="Thinking"
+				action="cycle-thinking"
 				side="bottom"
 			>
 				<button
diff --git a/components/sidebar.tsx b/components/sidebar.tsx
index 4690577..e1ea520 100644
--- a/components/sidebar.tsx
+++ b/components/sidebar.tsx
@@ -18,6 +18,7 @@ import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { cn } from "@/lib/utils";
 import type { ChatListItem } from "@/src/core";
+import { kbdEventForAction } from "@/src/core";
 
 /**
  * Toggleable sidebar — NOT a modal drawer: no backdrop, no focus theft. It
@@ -118,12 +119,17 @@ export function SidebarProvider({ children }: { children: React.ReactNode }) {
 		});
 	}, [narrow, open]);
 
-	// ⌘B (keyboard wave A): the global shortcut dispatches lh:toggle-sidebar;
-	// the context is the one place that owns open state, so it listens here.
+	// ⌘B: the global shortcut dispatches kbdEventForAction("toggle-sidebar")
+	// and the context answers on exactly that name — the shared spelling
+	// is the fix for the interlude bug (the listener sat on the pre-
+	// convention name "lh:toggle-sidebar" while the dispatcher sent
+	// "lh:kbd-toggle-sidebar", so ⌘B silently did nothing; owner
+	// 2026-09-25).
 	useEffect(() => {
+		const event = kbdEventForAction("toggle-sidebar");
 		const onToggle = () => toggle();
-		window.addEventListener("lh:toggle-sidebar", onToggle);
-		return () => window.removeEventListener("lh:toggle-sidebar", onToggle);
+		window.addEventListener(event, onToggle);
+		return () => window.removeEventListener(event, onToggle);
 	}, [toggle]);
 
 	return (
diff --git a/src/core/keyboard.ts b/src/core/keyboard.ts
index c188882..526f888 100644
--- a/src/core/keyboard.ts
+++ b/src/core/keyboard.ts
@@ -163,6 +163,18 @@ export function eventBinding(e: KeyboardEvent): string {
 	return [...mods, e.key.toLowerCase()].join("+");
 }
 
+/** The window event name a registry action dispatches/answers on —
+ *  the ONE spelling shared by the dispatcher (keyboard-shortcuts) and
+ *  every surface listener. Born from the ⌘B bug (owner interlude
+ *  2026-09-25): the sidebar listened on the pre-convention name
+ *  "lh:toggle-sidebar" while the dispatcher sent "lh:kbd-toggle-sidebar",
+ *  so ⌘B silently did nothing. With both sides composing through this
+ *  helper the mismatch is structurally impossible.
+ */
+export function kbdEventForAction(action: KeyAction): string {
+	return `lh:kbd-${action}`;
+}
+
 /** True when the event lands in a typing surface (input, textarea, or a
  *  contentEditable). In one, only mod/alt combos (and Tab, which types
  *  nothing) may fire — bare keys belong to the field (typing, caret). */
diff --git a/tests/keyboard-toggle-sidebar.test.ts b/tests/keyboard-toggle-sidebar.test.ts
new file mode 100644
index 0000000..c81f0c1
--- /dev/null
+++ b/tests/keyboard-toggle-sidebar.test.ts
@@ -0,0 +1,51 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	actionForBinding,
+	bindingForAction,
+	formatBinding,
+	kbdEventForAction,
+} from "../src/core/keyboard.ts";
+import { kbdEventForAction as kbdEventForActionFromUi } from "../components/keyboard-shortcuts.tsx";
+
+/**
+ * The ⌘B sidebar bug interlude (owner, 2026-09-25): ⌘B did nothing because
+ * the sidebar listened on the pre-convention "lh:toggle-sidebar" while the
+ * dispatcher sent "lh:kbd-toggle-sidebar". The fix is structural — both
+ * sides compose the event name through the ONE helper — and these pins
+ * hold the chain together: the registry maps the keypress to the action,
+ * the helper spells the event, and the UI dispatcher imports the same
+ * helper (not its own copy).
+ */
+
+describe("kbdEventForAction — the one spelling for action events", () => {
+	it("dispatch and listen names are the helper's output", () => {
+		assert.equal(kbdEventForAction("toggle-sidebar"), "lh:kbd-toggle-sidebar");
+		assert.equal(kbdEventForAction("sessions-search"), "lh:kbd-sessions-search");
+	});
+
+	it("the dispatcher imports the same helper (no second spelling exists)", () => {
+		assert.equal(kbdEventForActionFromUi, kbdEventForAction);
+	});
+});
+
+describe("the ⌘B chain — keypress → binding → action → event", () => {
+	it("mod+b is the toggle-sidebar action", () => {
+		assert.equal(actionForBinding("mod+b"), "toggle-sidebar");
+		assert.equal(bindingForAction("toggle-sidebar"), "mod+b");
+		assert.equal(formatBinding("mod+b"), "⌘B");
+	});
+
+	it("the event the chain ends in is the one the sidebar answers on", () => {
+		const action = actionForBinding("mod+b");
+		assert.equal(action, "toggle-sidebar");
+		assert.equal(kbdEventForAction(action), "lh:kbd-toggle-sidebar");
+	});
+});
+
+describe("the thinking pill suffix — ⇧⇥ via the registry", () => {
+	it("shift+tab formats as ⇧⇥ and maps to cycle-thinking", () => {
+		assert.equal(actionForBinding("shift+tab"), "cycle-thinking");
+		assert.equal(formatBinding("shift+tab"), "⇧⇥");
+	});
+});
\ No newline at end of file