Restore the arrow keys to their original triage meanings

Applying the UI spec's keyboard model reassigned the arrows: they stopped
deciding and became navigation, so the long-standing right-keep/left-trash/
down-undo mapping silently changed under the operator. That mapping is
muscle memory and it mirrors the swipe directions, so it wins.

Arrows go back to keep/trash/undo/skip and Backspace back to undo (mixing
Backspace up with trash costs a file move). The spec's letter keys are kept
as additions rather than replacements: K/Enter keep, X/Delete trash, Z undo,
F/S star, hold Space to zoom.

e2e now covers the arrows and the letters as separate cases, plus that
ArrowUp skips without POSTing an action, so the mapping can't drift again.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EHGNXqgRVUa2qVY6SYofg9

Author: claude

README.md

@@ -468,10 +468,23 @@ UI_SPEC.md             Dark Studio UI spec the frontend implements
 ```
 
 The frontend follows the Dark Studio spec in `UI_SPEC.md`: two theme tiers
-(Charcoal default, Black for OLED — switchable in ⚙ → Appearance), decision
-colors reserved for keep/reject only, and a desktop keyboard model —
-`K`/`Enter` keep, `X`/`Delete`/`Backspace` reject, `F` star, `Z`/`←` undo,
-`→` skip without deciding, hold `Space` to zoom 2×. On desktop up to six
-up-next previews stack in their own column on the right of the viewer
-(next image at the bottom); on phones up to five sit side by side over the
-bottom of the stage.
+(Charcoal default, Black for OLED — switchable in ⚙ → Appearance) and
+decision colors reserved for keep/reject only. On desktop up to six up-next
+previews stack in their own column on the right of the viewer (next image at
+the bottom); on phones up to five sit side by side over the bottom of the
+stage.
+
+**Desktop keys.** The arrows match the swipe directions, and the spec's
+letter keys are layered on top rather than replacing them:
+
+| Action | Keys |
+|---|---|
+| keep | `→` `K` `Enter` |
+| trash | `←` `X` `Delete` |
+| undo | `↓` `Z` `Backspace` |
+| skip to end of stack | `↑` |
+| star | `F` `S` |
+| zoom 2× | hold `Space` |
+
+`→`/`←` run through `swipe_map`, so remapping a swipe direction in config
+remaps its arrow with it.

e2e/tests/triage.spec.js

@@ -102,15 +102,33 @@ test("search filters the stack by prompt text", async ({ page }) => {
     .toContain("charlie");
 });
 
-test("keyboard: K keeps, Z undoes", async ({ page }) => {
+// Each case decides once and undoes it, so the shared seeded library is left
+// as it was found.
+for (const [name, keep, undo] of [
+  ["arrows (the original mapping)", "ArrowRight", "ArrowDown"],
+  ["letters", "k", "z"],
+]) {
+  test(`keyboard: ${name}`, async ({ page }) => {
+    const first = await topCardId(page);
+    const actioned = page.waitForRequest(
+      (r) => r.url().includes("/action") && r.method() === "POST");
+    await page.keyboard.press(keep);
+    await actioned;
+    await expect.poll(async () => topCardId(page)).not.toBe(first);
+    await page.keyboard.press(undo);
+    await expect.poll(async () => topCardId(page)).toBe(first);
+  });
+}
+
+test("keyboard: ArrowUp skips without deciding", async ({ page }) => {
   const first = await topCardId(page);
-  const actioned = page.waitForRequest(
-    (r) => r.url().includes("/action") && r.method() === "POST");
-  await page.keyboard.press("k");
-  await actioned;
+  let actions = 0;
+  page.on("request", (r) => {
+    if (r.url().includes("/action") && r.method() === "POST") actions++;
+  });
+  await page.keyboard.press("ArrowUp");
   await expect.poll(async () => topCardId(page)).not.toBe(first);
-  await page.keyboard.press("z");   // net zero decisions for later tests
-  await expect.poll(async () => topCardId(page)).toBe(first);
+  expect(actions).toBe(0);   // skip defers the card, it does not triage it
 });
 
 test("star toggles the button state", async ({ page }) => {

frontend/app.js

@@ -1843,10 +1843,19 @@ els.search.addEventListener("keydown", (e) => {
   else if (e.key === "Escape") { clearSearch(); els.search.blur(); }
 });
 
-// Desktop keyboard (spec §10): K/Enter = keep, X/Delete/Backspace = reject,
-// F = flag (star; no advance), Z = undo, ←/↓ = back (undo), →/↑ = skip the
-// card to the end of the stack without deciding, hold Space = 2x zoom.
-// Arrows deliberately never decide — only the explicit decision keys do.
+// Desktop keyboard. The arrows keep their original meanings — → keep, ← trash,
+// ↓ undo, ↑ skip to the end of the stack — because that mapping is muscle
+// memory and it matches the swipe directions (→/← go through swipe_map, so a
+// remapped swipe remaps the arrow with it). The spec's letter keys are layered
+// on top rather than replacing them:
+//
+//   keep   K, Enter, →        trash  X, Delete, ←
+//   undo   Z, Backspace, ↓    skip   ↑
+//   star   F, S               zoom   hold Space (2x)
+//
+// Backspace stays on undo, not trash: mixing those up costs you a file move,
+// and undo is what it has always done here.
+//
 // Skipped while typing in search so keys still edit text. If the metadata
 // sheet is open, Escape closes it and everything else is ignored to avoid
 // triaging the card behind it.
@@ -1884,16 +1893,18 @@ window.addEventListener("keydown", (e) => {
   if (e.code === "Space") { e.preventDefault(); setZoom(true); return; }
   if (e.repeat) return;   // auto-repeat only drives the hold-zoom above
   const k = e.key.length === 1 ? e.key.toLowerCase() : e.key;
-  if (k === "k" || k === "Enter") { e.preventDefault(); buttonAction("right"); }
-  else if (k === "x" || k === "Delete" || k === "Backspace") {
-    e.preventDefault(); buttonAction("left");
+  if (k === "k" || k === "Enter" || k === "ArrowRight") {
+    e.preventDefault(); buttonAction("right");                         // keep
+  }
+  else if (k === "x" || k === "Delete" || k === "ArrowLeft") {
+    e.preventDefault(); buttonAction("left");                          // trash
   }
   else if (k === "f" || k === "s") { e.preventDefault(); toggleStar(); }
-  else if (k === "z" || k === "ArrowLeft" || k === "ArrowDown") {
+  else if (k === "z" || k === "Backspace" || k === "ArrowDown") {
     e.preventDefault(); undo();                                        // back
   }
-  else if (k === "ArrowRight" || k === "ArrowUp") {
-    e.preventDefault(); skipCurrent();          // next without deciding
+  else if (k === "ArrowUp") {
+    e.preventDefault(); skipCurrent();          // skip to end of stack
   }
 });