mulmoterminal 5.0.1 → 5.2.0

package/common/agentTitle.ts

@@ -0,0 +1,23 @@
+// The cap on what an agent's own store label may be, shipped to the roster.
+//
+// In `common/` because BOTH sides decide from it: the server cuts the title here, and the client has
+// to know that a title of exactly this length may be a TRUNCATION of the prompt beneath it rather
+// than the whole of it. Without that, the roster cannot tell "the summary is the entire prompt, cut
+// by us" from "the summary is a shorter, different sentence that happens to start the same way", and
+// suppressing the second hides a real opening (#2123, Codex round 4).
+export const AGENT_TITLE_MAX = 200;
+
+/** What an `agentTitle` IS, which the roster cannot work out from the string itself.
+ *
+ *  Four agents answer with the person's OPENING PROMPT; two answer with a summary the agent wrote
+ *  for itself. The difference decides whether a title that is exactly `AGENT_TITLE_MAX` long may be
+ *  treated as our own truncation of the prompt beneath it — for an opening prompt it is, for an
+ *  agent's own summary it may simply be a long sentence that happens to start the same way.
+ *
+ *  Sent per response rather than derived on the client, so the two cannot drift: the server states
+ *  what it just read. */
+export type AgentTitleKind = "opening-prompt" | "agent-summary";
+
+/** Which kind each agent's store answers with. copilot and muse write their own summary — and are
+ *  also the two the reader never caches, because they REWRITE it as the conversation goes. */
+export const agentTitleKind = (agent: string): AgentTitleKind => (agent === "copilot" || agent === "muse" ? "agent-summary" : "opening-prompt");

package/common/keymap.ts

@@ -16,6 +16,8 @@ export const KEYMAP_ACTIONS = [
   "zoom-toggle",
   "zoom-next",
   "zoom-prev",
+  "focus-next",
+  "focus-prev",
   "next-attention",
   "terminal-new",
   "terminal-new-here",
@@ -62,6 +64,18 @@ export const NEEDS_A_CURRENT_TERMINAL: readonly KeymapAction[] = [
   "files-find",
 ];
 
+// The mirror of the list above: actions that walk the TILED grid, and so need nothing enlarged.
+// While a cell is, every other cell is either off-screen or parked in the roster, and moving the
+// cursor into one would put it somewhere the user cannot see.
+//
+// This is deliberately NOT one key meaning two things by state. An action has ONE meaning and
+// declines where it has none — exactly as NEEDS_A_CURRENT_TERMINAL does in the other state. Binding
+// one keystroke to `zoom-prev` AND `focus-prev` still resolves to a single action, because
+// `actionForKey` stops at the first bound one, and validateKeymap reports that. Picking the action
+// by state would mean an ordered-candidates resolver plus action-to-action collision reporting; see
+// plans/feat-2106-focus-prev-next.md for why that is a change of its own.
+export const NEEDS_NOTHING_ENLARGED: readonly KeymapAction[] = ["focus-next", "focus-prev"];
+
 // A key that puts BYTES into the focused terminal instead of running an app action (#1005) —
 // Cmd+Right as Ctrl+E for end-of-line, say, or Alt+B for word-back.
 //
@@ -80,7 +94,8 @@ export type Keymap = Partial<Record<KeymapAction, string>> & { send?: SendBindin
 
 // A parsed binding. `key` is matched against `KeyboardEvent.key` exactly as the browser
 // reports it, so it is case-sensitive for printable characters ("a" and "A" differ, the
-// latter implying Shift).
+// latter implying Shift) — except while Cmd is held on macOS, where the browser reports the
+// UNSHIFTED character and an uppercase letter is unreachable (validateKeymap warns, #2125).
 export interface KeyBinding {
   key: string;
   shift: boolean;
@@ -213,11 +228,35 @@ export function validateKeymap(input: unknown): KeymapProblem[] {
       return [{ action, binding, reason: 'unparseable key binding — expected e.g. "PageDown" or "Shift+PageUp"', fatal: true }];
     }
     claim(parsed, { label: action, binding, rank: KEYMAP_ACTIONS.indexOf(action), kind: "action" });
-    return [];
+    return unshiftedUnderCmdWarnings(action, binding, parsed);
   });
   return [...problems, ...duplicateWarnings(bound)];
 }
 
+// A binding that says one keystroke and waits for another. While Cmd is held, a macOS browser puts
+// the UNSHIFTED character in `KeyboardEvent.key` — Cmd+Shift+P arrives as `"p"` — so a binding
+// written `"Cmd+Shift+P"` waits for a `"P"` that never comes, and nothing downstream can see the
+// difference between that and a shortcut the user has not pressed yet (#2125).
+//
+// Safari and Chrome both do this and w3c/uievents#169 is still open, so it is the platform, not a
+// bug to route around: matching stays case-sensitive (`"a"` and `"A"` are different keystrokes,
+// pinned by the specs) and this only says so out loud.
+//
+// A WARNING, not an error: the deviation is macOS's, so a browser following the spec reports `"P"`
+// and the identical entry is correct there — and the server cannot know which one will connect.
+const UPPERCASE_ASCII_LETTER = /^[A-Z]$/;
+const unshiftedUnderCmdWarnings = (action: string, binding: string, parsed: KeyBinding): KeymapProblem[] =>
+  parsed.meta && parsed.shift && UPPERCASE_ASCII_LETTER.test(parsed.key)
+    ? [
+        {
+          action,
+          binding,
+          reason: `never fires in a macOS browser — with Cmd held it reports the unshifted letter, so write the key lowercase ("${parsed.key.toLowerCase()}")`,
+          fatal: false,
+        },
+      ]
+    : [];
+
 interface Claim {
   label: string;
   binding: string;
@@ -248,7 +287,7 @@ function sendProblems(input: unknown, claim: (parsed: KeyBinding, entry: Claim)
     }
     // Ranked after every action, matching who actually wins (see the `bound` comment above).
     claim(parsed, { label, binding: entry.key, rank: KEYMAP_ACTIONS.length + i, kind: "send" });
-    return [];
+    return unshiftedUnderCmdWarnings(label, entry.key, parsed);
   });
 }
 
@@ -280,6 +319,7 @@ function duplicateWarnings(bound: Map<string, Claim[]>): KeymapProblem[] {
 //
 //   - `copy` with no selection (clipboardActionFor), deliberately, so Ctrl+C stays interrupt.
 //   - NEEDS_A_CURRENT_TERMINAL with nothing enlarged (gridShortcutFor).
+//   - NEEDS_NOTHING_ENLARGED with something enlarged (gridShortcutFor), the mirror of it.
 //
 // `acts` and `otherwise` are the two halves of what the user is told.
 interface StandsAside {
@@ -287,8 +327,10 @@ interface StandsAside {
   otherwise: string;
 }
 const WHILE_ENLARGED: StandsAside = { acts: "only while a terminal is enlarged", otherwise: "when none is" };
+const WHILE_NOT_ENLARGED: StandsAside = { acts: "only while no terminal is enlarged", otherwise: "when one is" };
 const standsAside = (label: string): StandsAside | null => {
   if (label === "copy") return { acts: "only while text is selected", otherwise: "when nothing is" };
+  if (NEEDS_NOTHING_ENLARGED.some((action) => action === label)) return WHILE_NOT_ENLARGED;
   return NEEDS_A_CURRENT_TERMINAL.some((action) => action === label) ? WHILE_ENLARGED : null;
 };