feat(plugins): add keybindings and modal window capabilities (#1895)

* feat(plugins): add keybindings and modal window capabilities

Add two independent plugin UI capabilities.

Keybindings: plugins declare keybindings in the manifest under
ui.keybindings ({id, default, description}), validated backend-side
(combo grammar + unique ids, requires a UI bundle) and exposed to the
frontend. Plugin JS binds a handler via registry.registerKeybinding(id,
handler); a global dispatcher fires it. Combos are user-overridable in
Settings > Keyboard Shortcuts (namespaced plugin:{pluginId}:{id}) with
conflict detection against core and other plugins.

Modals: host.openModal({title?, content, size?, dismissible?}) returns a
{ close() } handle and renders in a single host-owned Dialog isolated by
PluginErrorBoundary, cleaned up on plugin unload.

Fixture plugin, PLUGIN-API.md / spec, and a Playwright e2e demonstrate a
keybinding handler opening a modal.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(plugins): address review feedback on keybinding dispatch and validation

Core shortcuts now take precedence over plugin keybindings on a colliding
combo (defaultPrevented cooperation between the two capture-phase
dispatchers), a throwing plugin handler no longer aborts dispatch to other
plugins, and the keybinding combo grammar is tightened: the backend validator
and frontend parser both drop the undocumented control/super modifier
aliases and reject shift+digit/symbol combos that can never actually fire
(KeyboardEvent.key reports the shifted character, not the token).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(plugins): stop conflicting core shortcut from double-firing with plugin keybindings

The earlier defaultPrevented guard only covered the central useAppShortcuts
dispatcher. Per-component core shortcuts registered via useKeyboardShortcut
run in the bubble phase, after the capture-phase plugin keybinding dispatcher,
so a plugin-handled-and-prevented combo still triggered the core action too.
Guard useKeyboardShortcut (and use-editor-keybinds, another capture-phase core
listener) on event.defaultPrevented so exactly one action fires per combo.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(plugins): make core shortcuts always win over plugin keybindings

Panel-search, task-switcher, and other core listeners never checked
event.defaultPrevented, so a plugin bound to the same combo (e.g. Cmd/Ctrl+F)
could still fire alongside them. Instead of patching every core listener,
usePluginShortcuts now computes the set of effective core shortcut combos
(registry, resolved through user overrides, plus FIND_IN_PANEL/SAVE) and
skips invoking any plugin handler whose combo is in that set, so the
matching core listener always handles the event exactly once.

Also adds a hook-level regression test for useEditorKeybinds' existing
defaultPrevented guard, and fixes a leaked capture-phase window listener in
use-keyboard-shortcut.test.ts that could bleed into later tests.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(web): keep Cmd+K closing the command panel after shortcut-precedence guard

cmdk's built-in vim bindings intercept Ctrl/Cmd+K and +P as list-navigation
shortcuts and call preventDefault() before the event reaches our window-level
useKeyboardShortcut listeners. Once that hook started bailing on
event.defaultPrevented (added to fix core/plugin shortcut double-firing), the
palette's own Cmd+K close/reopen toggle got silently suppressed whenever focus
was inside the open panel. Disable cmdk's vim bindings on the command palette
so its Ctrl/Cmd+K and +P always reach the app-level toggle.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* docs(plugins): document keybindings and modal window plugin APIs

Fill in the public author-facing docs that the internal plugin-keybindings
and modal-window contract (PLUGIN-API.md, spec.md) already covers: the
registry.registerKeybinding / host.openModal JS surface, the ui.keybindings
manifest field with its combo grammar, and a capability mention on the
Plugins overview page.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Kandev Agent <agent@kandev.dev>
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

docs/plans/plugins/PLUGIN-API.md

@@ -59,6 +59,21 @@ interface PluginHostApi {
   // path as the app router, so plugin pages can link into native routes
   // (e.g. /t/{taskId}) without a full reload.
   navigate(href: string, options?: { replace?: boolean }): void;
+  // Imperatively opens a modal window rendered by the host's <PluginModalHost/>
+  // (mounted once at the app root, isolated behind its own error boundary).
+  // Independent of keybindings — any plugin code path may call it.
+  openModal(options: PluginModalOptions): PluginModalHandle;
+}
+
+interface PluginModalOptions {
+  title?: string;                          // rendered in a DialogHeader/DialogTitle; omit for no header title
+  content: React.ComponentType<{ slotProps?: unknown }>; // reuses the slot-component contract
+  size?: "sm" | "md" | "lg" | "xl";         // maps to the host's Dialog width classes; default "md"
+  dismissible?: boolean;                    // overlay click / Escape close the modal; default true
+}
+
+interface PluginModalHandle {
+  close(): void; // closes this modal instance; no-op if already closed
 }
 ```
 
@@ -153,6 +168,25 @@ interface PluginRegistry {
   // WS action handler. Bridged into the existing lib/ws dispatch; called with the
   // decoded message payload for that action string.
   registerWsHandler(action: string, handler: (payload: unknown) => void): void;
+
+  // Binds a handler to a keybinding declared in this plugin's manifest
+  // (ui.keybindings[].id — { id, default, description }, see manifest schema).
+  // The host resolves the effective combo (user override if the user
+  // rebound it, else the manifest default) and dispatches globally, skipping
+  // editable targets the same way core app shortcuts do. Combos are
+  // user-overridable in Settings > Keyboard Shortcuts, namespaced
+  // `plugin:{pluginId}:{id}`. Binding an id the manifest didn't declare still
+  // stores the handler (a console warning is logged) since the dispatcher's
+  // effective-shortcut resolution keys off the manifest list.
+  //
+  // Combo grammar (manifest `default` and any user override): `+`-separated
+  // tokens, one of the modifiers `mod|ctrl|cmd|meta|alt|option|shift`
+  // (repeatable) plus exactly one key token. `mod` resolves to Cmd on macOS
+  // and Ctrl elsewhere (⌘/Ctrl). `shift` may not be combined with a digit or
+  // symbol key (e.g. `shift+1`, `shift+slash`) — Shift changes the character
+  // a browser reports for those keys, so the combo could never dispatch; both
+  // the manifest validator and the frontend parser reject it.
+  registerKeybinding(id: string, handler: (event: KeyboardEvent) => void): void;
 }
 ```