From b5e02cb88ae2d8491c3c14af71266f014c52b17b Mon Sep 17 00:00:00 2001
From: M4n5ter <m4n5terrr@gmail.com>
Date: Fri, 6 Nov 2026 14:44:16 +0800
Subject: [PATCH 1/2] fix(composer): render skills as atomic inline book tags

Use the existing RichEditor for inline skill atoms in drafts and sent
messages, preserving canonical source text and whole-node editing.
Keep completion, clipboard, IME and application shortcuts integrated.

Fix reproduced NSH focus, composition and shortcut routing faults.

Generated-by: Codex
---
 packages/plugin-sdk/src/composer-view.ts      |   1 +
 plugins/agent/composer/ui/Composer.tsx        |  90 ++-
 .../agent/composer/ui/ComposerCompletion.tsx  |  44 +-
 plugins/agent/composer/ui/composerPaste.ts    |  18 +-
 .../agent/conversations/ui/SessionSurface.tsx |  36 +-
 .../tests/real_host/desktop_new_session.rs    |   3 +-
 products/maka/workbench/app/ComposerEditor.ts |  46 ++
 products/maka/workbench/app/Icon.tsx          |   1 +
 products/maka/workbench/app/MessageRow.tsx    |   5 +-
 products/maka/workbench/app/SkillInput.tsx    | 228 +++++++
 products/maka/workbench/app/SkillMessage.tsx  |  59 ++
 products/maka/workbench/app/lucide.ts         |   6 +
 products/maka/workbench/app/skillTokenText.ts |  46 ++
 products/maka/workbench/examples/ui_types.rs  |   1 +
 products/maka/workbench/scripts/lucide.py     |   1 +
 products/maka/workbench/src/bindings.rs       |   2 +
 products/maka/workbench/src/composer_input.rs | 628 ++++++++++++++++++
 .../workbench/src/composer_input/message.rs   | 217 ++++++
 .../workbench/src/composer_input/model.rs     | 502 ++++++++++++++
 products/maka/workbench/src/lib.rs            |  99 +++
 .../workbench/tests/fixtures/skill-input.tsx  |  90 +++
 .../maka/workbench/tests/skill-token.test.mjs |  55 ++
 scripts/ci/suites.mjs                         |   2 +-
 .../assets/composer-ui/index.tsx              |   8 +-
 .../gpui/nsh-platform-gpui/src/text_input.rs  |  52 +-
 .../src/rich_editor/view/controller.rs        |  15 +-
 .../nsh-base/src/rich_editor/view/keys.rs     |  19 +-
 .../nsh-base/src/rich_editor/view/render.rs   |   6 +-
 .../nsh-base/tests/base/rich_editor/typing.rs |  92 +++
 tools/ui-build/src/lib.rs                     |   8 +-
 30 files changed, 2258 insertions(+), 122 deletions(-)
 create mode 100644 products/maka/workbench/app/ComposerEditor.ts
 create mode 100644 products/maka/workbench/app/SkillInput.tsx
 create mode 100644 products/maka/workbench/app/SkillMessage.tsx
 create mode 100644 products/maka/workbench/app/skillTokenText.ts
 create mode 100644 products/maka/workbench/src/composer_input.rs
 create mode 100644 products/maka/workbench/src/composer_input/message.rs
 create mode 100644 products/maka/workbench/src/composer_input/model.rs
 create mode 100644 products/maka/workbench/tests/fixtures/skill-input.tsx
 create mode 100644 products/maka/workbench/tests/skill-token.test.mjs

diff --git a/packages/plugin-sdk/src/composer-view.ts b/packages/plugin-sdk/src/composer-view.ts
index ce498f180bd..69875e85824 100644
--- a/packages/plugin-sdk/src/composer-view.ts
+++ b/packages/plugin-sdk/src/composer-view.ts
@@ -44,6 +44,7 @@ import type { UiSubscription } from './workbench.js';
 
 export interface ComposerFocusHandle {
   focus(): void;
+  bindKey(key: string, action: () => void): () => void;
 }
 
 export interface ComposerCommand {
diff --git a/plugins/agent/composer/ui/Composer.tsx b/plugins/agent/composer/ui/Composer.tsx
index 730346bb543..3534e67924d 100644
--- a/plugins/agent/composer/ui/Composer.tsx
+++ b/plugins/agent/composer/ui/Composer.tsx
@@ -22,7 +22,7 @@ import { ProjectMcp } from '../../../../products/maka/workbench/app/ProjectMcpCo
 import { tr } from '../../../../products/maka/workbench/app/locale';
 import { cleanup, effect, inputAction, signal, Text, View, Image } from 'nsh';
 import { ContextMenu, Input, MenuItem, Popover } from 'nsh/base';
-import type { InputRef, JSX, ViewRef } from 'nsh';
+import type { JSX, ViewRef } from 'nsh';
 import { Button } from 'nsh/base';
 import { platform, windowSize } from 'nsh';
 import { keymap } from 'nsh';
@@ -55,21 +55,10 @@ import { FileDropHint } from '../../../../products/maka/workbench/app/FileDropHi
 import { matchComposerCommand } from '../../../../products/maka/workbench/app/composerCommands';
 import { ComposerCompletion, createComposerCompletion } from './ComposerCompletion';
 import { createComposerPaste } from './composerPaste';
+import { SkillInput } from '../../../../products/maka/workbench/app/SkillInput';
+import type { ComposerEditor } from '../../../../products/maka/workbench/app/ComposerEditor';
 import logo from '../../../../products/maka/workbench/app/assets/maka.png';
 
-// Match the skill invocation grammar; the surrounding whitespace is not part of the chip.
-const skillTokens = () => [
-  {
-    pattern: String.raw`(?:^|[\t-\r \u{00a0}\u{1680}\u{2000}-\u{200a}\u{2028}\u{2029}\u{202f}\u{205f}\u{3000}\u{feff}])(?P<token>/skill:[A-Za-z0-9._-]+)`,
-    style: {
-      color: C.accent,
-      backgroundColor: `${C.accent}20`,
-      borderRadius: 4,
-    },
-    atomic: true,
-  },
-];
-
 export function Composer(props: ComposerViewInput<JSX.Element>) {
   const pendingAdd = signal(false);
   const completion = createComposerCompletion({
@@ -77,7 +66,7 @@ export function Composer(props: ComposerViewInput<JSX.Element>) {
     commands: props.commands,
     active: props.active,
   });
-  const predictionEditor = signal<{ owner: ComposerSession; node: InputRef } | null>(null);
+  const predictionEditor = signal<{ owner: ComposerSession; node: ComposerEditor } | null>(null);
   const suggestedMessage = () => {
     const owner = props.session();
     if (
@@ -136,10 +125,7 @@ export function Composer(props: ComposerViewInput<JSX.Element>) {
       text: suggestion.text,
     };
     const bindings = ['tab', 'right', 'enter'].map((key) =>
-      keymap.bind(key, () => acceptSuggestedMessage(offered), {
-        when: 'always',
-        within: editor.node,
-      }),
+      editor.node.bindKey(key, () => acceptSuggestedMessage(offered)),
     );
     return () => bindings.forEach((unbind) => unbind());
   });
@@ -279,6 +265,12 @@ export function Composer(props: ComposerViewInput<JSX.Element>) {
   let unbind = () => {};
   cleanup(() => unbind());
   const cardRoot = signal<ViewRef | null>(null);
+  const toggleAttachments = () => {
+    const owner = props.session();
+    if (owner && owner.editable())
+      owner.attachments.open({ owner: owner.sessionId, value: !owner.attachments.picker() });
+    else if (pending()) pending()!.openPicker(!pending()!.picking());
+  };
   // A file drag over the editor leaves the conversation's own drop target.
   const draggingOverEditor = signal(false);
   const fileDragging = () =>
@@ -290,25 +282,33 @@ export function Composer(props: ComposerViewInput<JSX.Element>) {
     const node = cardRoot();
     if (node && props.active() && owner?.editable() && owner.invocation() === null && owner.draft())
       return keymap.bind('ctrl+c', completion.clearDraft, {
-        when: 'always',
+        when: 'notEditing',
         within: node,
         fallback: true,
       });
   });
   effect(() => {
-    const stop = props.stopAction();
+    const owner = props.session();
+    const current = predictionEditor();
+    if (
+      owner &&
+      current?.owner === owner &&
+      props.active() &&
+      owner.editable() &&
+      owner.invocation() === null &&
+      owner.draft()
+    )
+      return current.node.bindKey('ctrl+c', completion.clearDraft, { fallback: true });
+  });
+  const escapeComposer = () => {
+    if (completion.composing()) return;
+    const suggestion = suggestedMessage();
+    if (suggestion) props.session()!.prediction.dismiss(suggestion.sourceTurnId);
+    else props.stopAction()();
+  };
+  effect(() => {
     const node = cardRoot();
-    if (node)
-      return keymap.bind(
-        'escape',
-        () => {
-          if (completion.composing()) return;
-          const suggestion = suggestedMessage();
-          if (suggestion) props.session()!.prediction.dismiss(suggestion.sourceTurnId);
-          else stop();
-        },
-        { when: 'always', within: node },
-      );
+    if (node) return keymap.bind('escape', escapeComposer, { when: 'notEditing', within: node });
   });
   const workspaceLabel = () => {
     const path = props.session()?.workspace() ?? pending()?.workspace();
@@ -570,13 +570,7 @@ export function Composer(props: ComposerViewInput<JSX.Element>) {
             unbind = keymap.bind(
               'mod+u',
               () => {
-                const owner = props.session();
-                if (owner && owner.editable())
-                  owner.attachments.open({
-                    owner: owner.sessionId,
-                    value: !owner.attachments.picker(),
-                  });
-                else if (pending()) pending()!.openPicker(!pending()!.picking());
+                toggleAttachments();
               },
               { when: 'always', within: node },
             );
@@ -607,7 +601,7 @@ export function Composer(props: ComposerViewInput<JSX.Element>) {
               const owner = session();
               const local = owner === null ? pending() : null;
               const path = signal('');
-              const editor = signal<InputRef | null>(null);
+              const editor = signal<ComposerEditor | null>(null);
               const selection = signal({ start: 0, end: 0 });
               const paste = local
                 ? createComposerPaste({
@@ -719,19 +713,18 @@ export function Composer(props: ComposerViewInput<JSX.Element>) {
                         maxHeight: compact() ? 64 : 144,
                       }}
                     >
-                      <Input
+                      <SkillInput
                         ref={(node) => {
                           editor.set(node);
                           props.attach(node);
+                          node.bindKey('mod+u', toggleAttachments);
                           completion.attach(owner?.sessionId ?? null, node);
                           predictionEditor.set(owner ? { owner, node } : null);
                         }}
+                        onEscape={escapeComposer}
                         testID="message"
                         accessibilityLabel={tr('Message composer')}
                         autoFocus={owner !== null || local !== null}
-                        multiline
-                        submitBehavior="submit"
-                        tokens={skillTokens()}
                         value={owner?.draft() ?? local?.draft() ?? ''}
                         readonly={owner ? !owner.editable() : !local || local.sending()}
                         onChange={
@@ -791,14 +784,6 @@ export function Composer(props: ComposerViewInput<JSX.Element>) {
                               : undefined
                         }
                         onCaretMove={owner ? (event) => completion.caret(owner, event) : undefined}
-                        onCompositionChange={
-                          owner || local
-                            ? (event) => {
-                                if (owner || pending() === local)
-                                  completion.composition(owner, event);
-                              }
-                            : undefined
-                        }
                         onSubmit={
                           owner
                             ? (event) => {
@@ -828,7 +813,6 @@ export function Composer(props: ComposerViewInput<JSX.Element>) {
                             flexGrow: 1,
                             flexShrink: 1,
                             color: C.text,
-                            placeholderColor: C.muted,
                             ...bodyTextStyle,
                             ...(owner !== null && suggestedMessage() !== null
                               ? {
diff --git a/plugins/agent/composer/ui/ComposerCompletion.tsx b/plugins/agent/composer/ui/ComposerCompletion.tsx
index 5d82e248457..0eb62c388eb 100644
--- a/plugins/agent/composer/ui/ComposerCompletion.tsx
+++ b/plugins/agent/composer/ui/ComposerCompletion.tsx
@@ -43,13 +43,17 @@ import type { CompletionToken, Selection } from './composerCompletionSyntax.ts';
 import { C, bodyTextStyle, captionTextStyle } from '../../../../products/maka/workbench/app/ui';
 import { Icon } from '../../../../products/maka/workbench/app/Icon';
 import { createComposerPaste } from './composerPaste';
+import {
+  inputEditor,
+  type ComposerEditor,
+} from '../../../../products/maka/workbench/app/ComposerEditor';
 
 type Source = 'add' | 'files' | 'skills' | 'commands' | 'slash';
-type Editor = { sessionId: string | null; node: InputRef };
+type Editor = { sessionId: string | null; node: ComposerEditor };
 type Read = {
   serial: number;
   owner: ComposerSession;
-  editor: InputRef;
+  editor: ComposerEditor;
   text: string;
   selection: Selection;
   token: CompletionToken | null;
@@ -65,7 +69,7 @@ type Row = {
   id: string;
   title: string;
   detail?: string;
-  icon: 'paperclip' | 'file' | 'folder' | 'code' | 'command';
+  icon: 'paperclip' | 'file' | 'folder' | 'book' | 'code' | 'command';
   disabled?: boolean;
   action: { read: number; id: string };
 } & (
@@ -97,10 +101,10 @@ export function createComposerCompletion(options: Options) {
   const editor = signal<Editor | null>(null);
   const caret = signal<Bounds | null>(null);
   const selection = signal<Selection>({ start: 0, end: 0 });
-  const composing = signal(false);
+  const composing = () => !!editor()?.node.composing();
   const explicit = signal<Source | null>(null);
   const query = signal('');
-  const queryInput = signal<InputRef | null>(null);
+  const queryInput = signal<ComposerEditor | null>(null);
   const querySelection = signal<Selection>({ start: 0, end: 0 });
   const queryComposing = signal(false);
   const opened = signal<Read | null>(null);
@@ -248,7 +252,7 @@ export function createComposerCompletion(options: Options) {
             return tr('Use a skill');
           },
           detail: '/',
-          icon: 'code',
+          icon: 'book',
         }),
         ...options
           .commands()
@@ -370,7 +374,7 @@ export function createComposerCompletion(options: Options) {
           insert: skill.invocation,
           title: skill.name,
           detail: skill.description,
-          icon: 'code',
+          icon: 'book',
         }),
       ),
     );
@@ -635,46 +639,42 @@ export function createComposerCompletion(options: Options) {
     if (!target) return;
     const valid = () => current === read && owns(read);
     const unbind = [
-      keymap.bind(
+      target.bindKey(
         'escape',
         () => {
           if (valid()) dismiss();
         },
-        { when: 'always', within: target },
+        {},
       ),
     ];
     if (loading() || rows().some((item) => !item.disabled)) {
       unbind.push(
-        keymap.bind(
+        target.bindKey(
           'down',
           () => {
             if (valid()) move(1);
           },
           {
-            when: 'always',
             repeat: true,
-            within: target,
           },
         ),
-        keymap.bind(
+        target.bindKey(
           'up',
           () => {
             if (valid()) move(-1);
           },
           {
-            when: 'always',
             repeat: true,
-            within: target,
           },
         ),
-        keymap.bind(
+        target.bindKey(
           'enter',
           () => {
             if (!valid()) return;
             const item = rows()[index()];
             if (item) accept(item.action);
           },
-          { when: 'always', within: target },
+          {},
         ),
       );
     }
@@ -724,16 +724,15 @@ export function createComposerCompletion(options: Options) {
       });
       close();
     },
-    anchor: () => (opened()?.explicit ? addAnchor : (caret() ?? editor()?.node)),
+    anchor: () => (opened()?.explicit ? addAnchor : (caret() ?? editor()?.node.anchor)),
     addButton(node: ViewRef) {
       addAnchor = node;
     },
-    attach(sessionId: string | null, node: InputRef) {
+    attach(sessionId: string | null, node: ComposerEditor) {
       directoryHint = null;
       editor.set({ sessionId, node });
       selection.set({ start: 0, end: 0 });
       caret.set(null);
-      composing.set(false);
       queryComposing.set(false);
       explicit.set(null);
     },
@@ -748,9 +747,6 @@ export function createComposerCompletion(options: Options) {
     selection(owner: ComposerSession, event: Selection) {
       if (options.session() === owner) selection.set({ ...event });
     },
-    composition(owner: ComposerSession | null, event: { composing: boolean }) {
-      if (options.session() === owner) composing.set(event.composing);
-    },
     toggleAdd(target: { sessionId: string | null }) {
       const owner = options.session();
       if (
@@ -788,7 +784,7 @@ export function createComposerCompletion(options: Options) {
       list = node;
     },
     queryInput(node: InputRef) {
-      queryInput.set(node);
+      queryInput.set(inputEditor(node, queryComposing));
       querySelection.set({ start: 0, end: 0 });
       node.focus();
     },
diff --git a/plugins/agent/composer/ui/composerPaste.ts b/plugins/agent/composer/ui/composerPaste.ts
index d7077143943..dee54b4105b 100644
--- a/plugins/agent/composer/ui/composerPaste.ts
+++ b/plugins/agent/composer/ui/composerPaste.ts
@@ -17,10 +17,9 @@
  * under the License.
  */
 
-import { effect, platform } from 'nsh';
+import { effect, keymap, platform } from 'nsh';
 import { Window } from 'nsh/desktop';
-import type { InputRef } from 'nsh';
-import { keymap } from 'nsh';
+import type { ComposerEditor } from '../../../../products/maka/workbench/app/ComposerEditor';
 import type {
   ComposerSession,
   ComposerViewInput,
@@ -39,7 +38,7 @@ const report = (owner: PasteOwner, reason: unknown) => {
 
 type Target<Owner> = {
   owner: Owner;
-  node: InputRef;
+  node: ComposerEditor;
   text: string;
   selection: Selection;
 };
@@ -47,7 +46,7 @@ type Target<Owner> = {
 export function createComposerPaste<Owner extends PasteOwner>(options: {
   owner(): Owner | null;
   active(): boolean;
-  editor(owner: Owner): InputRef | null;
+  editor(owner: Owner): ComposerEditor | null;
   selection(): Selection;
   composing(): boolean;
   dismiss(): void;
@@ -111,14 +110,17 @@ export function createComposerPaste<Owner extends PasteOwner>(options: {
     const owner = options.owner();
     const node = owner && options.editor(owner);
     if (!node || !owner || !options.active() || !editable(owner) || options.composing()) return;
-    const unbind = ['mod+v', 'alt+v', 'ctrl+alt+v'].map((key) =>
-      keymap.bind(
+    // Pixel terminals render natively but retain Control-key shortcuts.
+    const controlKeys = keymap.label('mod+v') === keymap.label('ctrl+v');
+    const keys = controlKeys ? ['mod+v', 'alt+v', 'ctrl+alt+v'] : ['mod+v'];
+    const unbind = keys.map((key) =>
+      node.bindKey(
         key,
         () => {
           const target = capture(owner);
           if (target) clipboard(target);
         },
-        { when: 'always', within: node },
+        {},
       ),
     );
     return () => unbind.forEach((remove) => remove());
diff --git a/plugins/agent/conversations/ui/SessionSurface.tsx b/plugins/agent/conversations/ui/SessionSurface.tsx
index df6c1caef46..d42e51fd227 100644
--- a/plugins/agent/conversations/ui/SessionSurface.tsx
+++ b/plugins/agent/conversations/ui/SessionSurface.tsx
@@ -56,6 +56,7 @@ import {
   type ConversationPreviewInput,
   type ConversationSessionHandle,
   type ComposerSession,
+  type ComposerFocusHandle,
   type ComposerViewInput,
 } from '../../../../packages/plugin-sdk/src/workbench-views.js';
 import { delayed } from '../../../../products/maka/workbench/app/delayed';
@@ -354,7 +355,7 @@ export function createConversationUi(
   };
   let dropFiles: ((event: { uris: string[] }) => void) | null = null;
   const fileDragging = signal(false);
-  let editor: { focus(): void } | undefined;
+  let editor: ComposerFocusHandle | undefined;
   const composerSession = computed(() => {
     const owner = handle();
     return owner && owner.sessionId === selected() ? projectComposerSession(owner, host) : null;
@@ -1570,23 +1571,28 @@ export function createConversationUi(
   // A side pane binds its conversation's keys within itself, so they take
   // over from the main pane's only while focus is there.
   const unbindKeys: (() => void)[] = [];
+  const unbindEditorKeys: (() => void)[] = [];
   cleanup(() => {
-    for (const unbind of unbindKeys.splice(0)) unbind();
+    for (const unbind of [...unbindKeys.splice(0), ...unbindEditorKeys.splice(0)]) unbind();
   });
-  const bindKeys = (within?: ViewRef) => {
+  const bindKeys = (within?: ViewRef, input?: ComposerFocusHandle) => {
     const options = within ? { when: 'always' as const, within } : { when: 'always' as const };
-    unbindKeys.push(keymap.bind('mod+p', () => invokeOwn('commands'), options));
-    if (ownTitleBar) unbindKeys.push(keymap.bind('mod+f', () => invokeOwn('find'), options));
-    unbindKeys.push(keymap.bind('mod+g', () => invokeOwn('models'), options));
-    unbindKeys.push(keymap.bind('mod+l', () => invokeOwn('latest'), options));
-    unbindKeys.push(keymap.bind('alt+up', () => invokeOwn('history-focus'), options));
-    unbindKeys.push(keymap.bind('alt+down', () => invokeOwn('activity-focus'), options));
-    if (within) return;
-    unbindKeys.push(keymap.bind('mod+o', () => invokeOwn('sessions'), options));
-    unbindKeys.push(keymap.bind('mod+n', () => invokeOwn('new'), options));
+    const bind = (key: string, action: () => void) => {
+      const unbind = input ? input.bindKey(key, action) : keymap.bind(key, action, options);
+      (input ? unbindEditorKeys : unbindKeys).push(unbind);
+    };
+    bind('mod+p', () => invokeOwn('commands'));
+    if (ownTitleBar) bind('mod+f', () => invokeOwn('find'));
+    bind('mod+g', () => invokeOwn('models'));
+    bind('mod+l', () => invokeOwn('latest'));
+    bind('alt+up', () => invokeOwn('history-focus'));
+    bind('alt+down', () => invokeOwn('activity-focus'));
+    if (side) return;
+    bind('mod+o', () => invokeOwn('sessions'));
+    bind('mod+n', () => invokeOwn('new'));
     if (ownTitleBar) {
-      unbindKeys.push(keymap.bind('mod+shift+]', () => stepSession(1), options));
-      unbindKeys.push(keymap.bind('mod+shift+[', () => stepSession(-1), options));
+      bind('mod+shift+]', () => stepSession(1));
+      bind('mod+shift+[', () => stepSession(-1));
     }
   };
   let sideKeys: ViewRef | undefined;
@@ -2376,7 +2382,9 @@ export function createConversationUi(
                 </View>
               }
               attach={(node) => {
+                for (const unbind of unbindEditorKeys.splice(0)) unbind();
                 editor = node;
+                bindKeys(side ? paneRoot : undefined, node);
               }}
               commands={composerCommands}
               models={
diff --git a/products/maka/terminal-shell/tests/real_host/desktop_new_session.rs b/products/maka/terminal-shell/tests/real_host/desktop_new_session.rs
index ea3a74a4f1c..5c93f32103b 100644
--- a/products/maka/terminal-shell/tests/real_host/desktop_new_session.rs
+++ b/products/maka/terminal-shell/tests/real_host/desktop_new_session.rs
@@ -2442,9 +2442,10 @@ async fn desktop_composer_large_paste_keeps_controls_on_screen() {
     )
     .await;
     let before = desktop.control("Focus message composer").await;
-    let draft = (0..200)
+    let mut draft = (0..200)
         .map(|i| format!("Traceback line {i}: a long pasted diagnostic with paths and details\n"))
         .collect::<String>();
+    draft.push_str("请检查 /skill:review 这个问题");
     // TerminalPlatform::paste injects IME text, which strips control characters.
     // Native clipboard paste keeps the diagnostic's line breaks.
     desktop
diff --git a/products/maka/workbench/app/ComposerEditor.ts b/products/maka/workbench/app/ComposerEditor.ts
new file mode 100644
index 00000000000..2d7692dcdb2
--- /dev/null
+++ b/products/maka/workbench/app/ComposerEditor.ts
@@ -0,0 +1,46 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { keymap } from 'nsh';
+import type { InputRef, ViewRef } from 'nsh';
+
+export type EditorKeyOptions = { repeat?: boolean; fallback?: boolean };
+
+/** All offsets and replacement expectations refer to the original draft's UTF-16 text. */
+export interface ComposerEditor {
+  readonly anchor: ViewRef;
+  focus(): void;
+  blur(): void;
+  composing(): boolean;
+  replaceRange: InputRef['replaceRange'];
+  bindKey(key: string, action: () => void, options?: EditorKeyOptions): () => void;
+}
+
+/** Ordinary query fields use their native input and keyboard scope. */
+export function inputEditor(node: InputRef, composing: () => boolean): ComposerEditor {
+  return {
+    anchor: node,
+    focus: () => node.focus(),
+    blur: () => node.blur(),
+    composing,
+    replaceRange: (request) => node.replaceRange(request),
+    bindKey: (key, action, options) =>
+      keymap.bind(key, action, { when: 'always', within: node, ...options }),
+  };
+}
diff --git a/products/maka/workbench/app/Icon.tsx b/products/maka/workbench/app/Icon.tsx
index 4353ce9179a..f3252c2c797 100644
--- a/products/maka/workbench/app/Icon.tsx
+++ b/products/maka/workbench/app/Icon.tsx
@@ -7,6 +7,7 @@ import { platform } from 'nsh';
 import { lucide, type LucideElement } from './lucide';
 
 const icons = {
+  book: { lucide: 'book', glyph: '📖' },
   back: { lucide: 'chevron-left', glyph: '‹' },
   sidebar: { lucide: 'panel-left', glyph: '◫' },
   split: { lucide: 'columns-2', glyph: '◫' },
diff --git a/products/maka/workbench/app/MessageRow.tsx b/products/maka/workbench/app/MessageRow.tsx
index f01d80f6aca..5c877870ced 100644
--- a/products/maka/workbench/app/MessageRow.tsx
+++ b/products/maka/workbench/app/MessageRow.tsx
@@ -29,6 +29,7 @@ import { messageKey, senderSession, type Row } from './history';
 import type { MessageOrigin } from '../../../../packages/plugin-sdk/src/index.js';
 import { MarkdownBody } from './MarkdownBody';
 import { SourceText } from './SourceText';
+import { SkillMessage } from './SkillMessage';
 import {
   C,
   bodyTextStyle,
@@ -483,9 +484,7 @@ export function MessageRow({
                   gap: 8,
                 }}
               >
-                <Text style={[{ color: C.text, ...bodyTextStyle }, { userSelect: 'text' }]}>
-                  <SourceText row={row} sourceId={sourceId()} />
-                </Text>
+                <SkillMessage row={row} sourceId={sourceId()} />
                 <If when={(row().attachments?.length ?? 0) > 0}>
                   <HistoryAttachments
                     userScroll={userScroll}
diff --git a/products/maka/workbench/app/SkillInput.tsx b/products/maka/workbench/app/SkillInput.tsx
new file mode 100644
index 00000000000..7b0d95ed624
--- /dev/null
+++ b/products/maka/workbench/app/SkillInput.tsx
@@ -0,0 +1,228 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { ComposerInput } from 'maka/host';
+import { cleanup, effect, keymap, signal, untracked, View } from 'nsh';
+import type { Bounds, CaretEvent, InputRef, StyleProp, ViewRef, TextStyle } from 'nsh';
+import type { ComposerEditor, EditorKeyOptions } from './ComposerEditor';
+import { lucide } from './lucide';
+import { C, bodyTextStyle } from './ui';
+
+type Selection = { start: number; end: number };
+type NativeEditor = {
+  focus(): void;
+  blur(): void;
+  status(): Promise<{ readonly composing: boolean; readonly selection: Selection }>;
+  caretBounds(): Promise<Bounds | null>;
+  contentHeight(): Promise<number | null>;
+  replaceRange: InputRef['replaceRange'];
+};
+type Props = {
+  ref?(node: ComposerEditor): void;
+  testID?: string;
+  accessibilityLabel: string;
+  value: string;
+  readonly: boolean;
+  sourceId?: string;
+  sourceOffset?: number;
+  placeholder: string;
+  autoFocus: boolean;
+  style?: StyleProp<TextStyle>;
+  onChange?(event: { value: string }): void;
+  onSelectionChange?(event: Selection): void;
+  onCaretMove?(event: CaretEvent): void;
+  onSubmit?(event: { text: string }): void;
+  onPaste?(event: { text: string; uris: string[]; files: unknown[] }): void;
+  onFocus?(): void;
+  onBlur?(): void;
+  onEscape?(): void;
+  onFileDrop?(event: { uris: string[] }): void;
+  onFileDragEnter?(): void;
+  onFileDragLeave?(): void;
+};
+type Binding = { key: string; action: () => void; options?: EditorKeyOptions };
+
+/** Product-owned plain-text composer; skills are inline atoms in the existing rich editor. */
+export function SkillInput(props: Props) {
+  const native = signal<NativeEditor | null>(null);
+  const scope = signal<ViewRef | null>(null);
+  const status = signal<{ readonly composing: boolean; readonly selection: Selection } | null>(
+    null,
+  );
+  const valueCount = signal(0);
+  const height = signal(bodyTextStyle.lineHeight);
+  let alive = true;
+  let frame: ReturnType<typeof requestAnimationFrame> | undefined;
+  const captureKeys = signal<{ key: string; fallback: boolean }[]>([]);
+  const bindings = new Map<object, Binding>();
+  const refreshKeys = () => {
+    const current = new Map<string, Binding>();
+    for (const binding of bindings.values()) current.set(binding.key, binding);
+    captureKeys.set([
+      ...(!props.readonly && !current.has('escape') ? [{ key: 'escape', fallback: false }] : []),
+      ...Array.from(current.values(), (binding) => ({
+        key: binding.key,
+        fallback: binding.options?.fallback ?? false,
+      })),
+    ]);
+  };
+  cleanup(() => {
+    alive = false;
+    bindings.clear();
+    if (frame !== undefined) cancelAnimationFrame(frame);
+  });
+  effect(() => {
+    props.readonly;
+    untracked(refreshKeys);
+  });
+  const bindKey = (key: string, action: () => void, options?: EditorKeyOptions) => {
+    const target = scope();
+    // These keystrokes reach the native input instead of RichEditor's key table.
+    if (key === 'mod+v' || key === 'alt+v')
+      return target
+        ? keymap.bind(key, action, { when: 'always', within: target, ...options })
+        : () => {};
+    const ticket = {};
+    bindings.set(ticket, { key, action, options });
+    untracked(refreshKeys);
+    return () => {
+      if (!alive) return;
+      bindings.delete(ticket);
+      untracked(refreshKeys);
+    };
+  };
+  effect(() => {
+    const node = native();
+    if (!node) return;
+    let current = true;
+    void node.status().then(
+      (state) => {
+        if (current && alive) {
+          status.set(state);
+          caretMoved();
+        }
+      },
+      (error) => {
+        if (current && alive) throw error;
+      },
+    );
+    return () => {
+      current = false;
+    };
+  });
+  effect(() => {
+    const node = native();
+    const anchor = scope();
+    const state = status();
+    if (!node || !anchor || !state) return;
+    untracked(() => {
+      props.ref?.({
+        anchor,
+        focus: () => node.focus(),
+        blur: () => node.blur(),
+        composing: () => state.composing,
+        replaceRange: (request) => node.replaceRange(request),
+        bindKey,
+      });
+      props.onSelectionChange?.(state.selection);
+    });
+  });
+  effect(() => {
+    const node = native();
+    if (node && status() && props.autoFocus) node.focus();
+  });
+  const caretMoved = () => {
+    if (frame !== undefined || !alive) return;
+    frame = requestAnimationFrame(async () => {
+      frame = undefined;
+      if (!alive) return;
+      const node = native();
+      if (!node) return;
+      try {
+        const [measured, pageBounds] = await Promise.all([
+          node.contentHeight(),
+          node.caretBounds(),
+        ]);
+        if (!alive || native() !== node) return;
+        if (measured !== null && measured > 0) height.set(measured);
+        if (pageBounds) props.onCaretMove?.({ bounds: pageBounds, pageBounds });
+      } catch (error) {
+        if (alive) throw error;
+      }
+    });
+  };
+  const key = ({ key }: { key: string }) => {
+    if (status()?.composing) return;
+    const binding = Array.from(bindings.values())
+      .reverse()
+      .find((binding) => binding.key === key);
+    if (binding) binding.action();
+    else if (key === 'escape') props.onEscape?.();
+  };
+  return (
+    <View
+      ref={(node) => scope.set(node)}
+      style={[props.style, { height: height(), minHeight: bodyTextStyle.lineHeight }]}
+      onFileDrop={props.onFileDrop}
+      onFileDragEnter={props.onFileDragEnter}
+      onFileDragLeave={props.onFileDragLeave}
+      onLayout={caretMoved}
+    >
+      <ComposerInput
+        ref={(node) => native.set(node)}
+        testID={props.testID}
+        accessibilityLabel={props.accessibilityLabel}
+        value={props.value}
+        sourceId={props.sourceId}
+        sourceOffset={props.sourceOffset ?? 0}
+        valueCount={valueCount()}
+        readOnly={props.readonly}
+        placeholder={props.placeholder}
+        tokenColor={C.accent}
+        tokenBackgroundColor={`${C.accent}20`}
+        tokenIcon={lucide.book[0].d}
+        captureKeys={captureKeys()}
+        styles={{
+          root: { ...bodyTextStyle, color: C.text },
+          content: { padding: 0 },
+          caret: { backgroundColor: C.text },
+          placeholder: { color: C.muted },
+          nodes: { paragraph: bodyTextStyle },
+        }}
+        style={{ flexGrow: 1, flexShrink: 1, minHeight: 0 }}
+        onChange={(event) => {
+          valueCount.set(event.count);
+          props.onChange?.({ value: event.value });
+          caretMoved();
+        }}
+        onSelectionChange={(event) => {
+          props.onSelectionChange?.(event);
+          caretMoved();
+        }}
+        onSubmit={props.onSubmit}
+        onKey={key}
+        onPasteFiles={(event) =>
+          props.onPaste?.({ text: '', uris: event.uris, files: event.files })
+        }
+        onFocus={props.onFocus}
+        onBlur={props.onBlur}
+      />
+    </View>
+  );
+}
diff --git a/products/maka/workbench/app/SkillMessage.tsx b/products/maka/workbench/app/SkillMessage.tsx
new file mode 100644
index 00000000000..2f247a99454
--- /dev/null
+++ b/products/maka/workbench/app/SkillMessage.tsx
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { computed, Text, View } from 'nsh';
+import { SkillInput } from './SkillInput';
+import { SourceText } from './SourceText';
+import { hasSkillToken, skillTextGroups } from './skillTokenText';
+import { C, bodyTextStyle } from './ui';
+import type { Row } from './history';
+
+/** Message selection uses the same atom model and source serializer as the composer. */
+export function SkillMessage(props: { row(): Row; sourceId: string }) {
+  const fragments = () => props.row().fragments ?? [{ offset: 0, text: props.row().text }];
+  const groups = computed(() => skillTextGroups(fragments()));
+  const hasSkills = computed(() => groups().some(hasSkillToken));
+  return (
+    <If
+      when={hasSkills()}
+      else={
+        <Text style={[{ color: C.text, ...bodyTextStyle }, { userSelect: 'text' }]}>
+          <SourceText row={props.row} sourceId={props.sourceId} />
+        </Text>
+      }
+    >
+      <View style={{ width: '100%', minWidth: 0 }}>
+        <Each of={groups()} key={(group) => group.offset}>
+          {(group) => (
+            <SkillInput
+              accessibilityLabel={group().text}
+              value={group().text}
+              readonly
+              autoFocus={false}
+              placeholder=""
+              sourceId={props.sourceId}
+              sourceOffset={group().offset}
+              style={{ width: '100%', minWidth: 0, flexShrink: 0 }}
+            />
+          )}
+        </Each>
+      </View>
+    </If>
+  );
+}
diff --git a/products/maka/workbench/app/lucide.ts b/products/maka/workbench/app/lucide.ts
index 3c99db03bc7..68bbd00dea2 100644
--- a/products/maka/workbench/app/lucide.ts
+++ b/products/maka/workbench/app/lucide.ts
@@ -22,6 +22,12 @@ export const lucide = {
     { tag: 'path', d: 'm5 12 7-7 7 7' },
     { tag: 'path', d: 'M12 19V5' },
   ],
+  book: [
+    {
+      tag: 'path',
+      d: 'M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20',
+    },
+  ],
   brain: [
     { tag: 'path', d: 'M12 18V5' },
     { tag: 'path', d: 'M15 13a4.17 4.17 0 01-3-4 4.17 4.17 0 01-3 4' },
diff --git a/products/maka/workbench/app/skillTokenText.ts b/products/maka/workbench/app/skillTokenText.ts
new file mode 100644
index 00000000000..c2b47d3ddd2
--- /dev/null
+++ b/products/maka/workbench/app/skillTokenText.ts
@@ -0,0 +1,46 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { messageBytes } from './history.ts';
+
+// Keep the whitespace boundary identical to the host's skill invocation grammar.
+export const SKILL_TOKEN_PATTERN = String.raw`(?:^|[\t-\r \u{00a0}\u{1680}\u{2000}-\u{200a}\u{2028}\u{2029}\u{202f}\u{205f}\u{3000}\u{feff}])(?P<token>/skill:(?P<label>[A-Za-z0-9._-]+))`;
+
+/** Loaded gaps remain separate source regions. */
+export function skillTextGroups(fragments: readonly { offset: number; text: string }[]) {
+  const groups: { offset: number; text: string }[] = [];
+  let next = -1;
+  for (const fragment of fragments) {
+    if (fragment.offset === next) groups[groups.length - 1].text += fragment.text;
+    else groups.push({ ...fragment });
+    next = fragment.offset + messageBytes(fragment.text);
+  }
+  return groups;
+}
+
+/** A loaded suffix cannot establish the boundary before its first character. */
+export function hasSkillToken(group: { text: string; offset: number }): boolean {
+  const pattern = new RegExp(SKILL_TOKEN_PATTERN.replaceAll('(?P<', '(?<'), 'gu');
+  for (const found of group.text.matchAll(pattern)) {
+    const token = found.groups!.token;
+    const start = found.index + found[0].length - token.length;
+    if (start > 0 || group.offset === 0) return true;
+  }
+  return false;
+}
diff --git a/products/maka/workbench/examples/ui_types.rs b/products/maka/workbench/examples/ui_types.rs
index b2518468bdc..e15057725bb 100644
--- a/products/maka/workbench/examples/ui_types.rs
+++ b/products/maka/workbench/examples/ui_types.rs
@@ -38,6 +38,7 @@ const SOURCES: &[&str] = &[
     "products/maka/workbench/app/ComputerAppRequest.tsx",
     "products/maka/workbench/app/CapabilityRequest.tsx",
     "products/maka/workbench/tests/fixtures/composer-completion.tsx",
+    "products/maka/workbench/tests/fixtures/skill-input.tsx",
     "products/maka/workbench/tests/fixtures/mermaid-view.tsx",
     "plugins/agent/conversations/ui/index.tsx",
     "plugins/agent/composer/ui/index.tsx",
diff --git a/products/maka/workbench/scripts/lucide.py b/products/maka/workbench/scripts/lucide.py
index 4408eee2d2e..62edaf0350b 100644
--- a/products/maka/workbench/scripts/lucide.py
+++ b/products/maka/workbench/scripts/lucide.py
@@ -16,6 +16,7 @@
     'archive',
     'arrow-down',
     'arrow-up',
+    'book',
     'brain',
     'check',
     'chevron-down',
diff --git a/products/maka/workbench/src/bindings.rs b/products/maka/workbench/src/bindings.rs
index 6c5f09a5e32..11e9f00881c 100644
--- a/products/maka/workbench/src/bindings.rs
+++ b/products/maka/workbench/src/bindings.rs
@@ -220,6 +220,8 @@ pub fn ui_set_description() -> nsh_core::element::description::SetDescription {
 
 fn registry(make_host: impl Fn() -> Instance<ApplicationHost> + Send + Sync + 'static) -> Registry {
     let mut registry = Registry::ui_set("maka/host");
+    registry.register::<crate::composer_input::ComposerInput>();
+    registry.class::<crate::composer_input::ComposerInputState>();
     registry.register::<uploads::AttachmentPicker>();
     registry.class::<terminal_grid::TerminalGrid>();
     registry.class::<uploads::UploadIntake>();
diff --git a/products/maka/workbench/src/composer_input.rs b/products/maka/workbench/src/composer_input.rs
new file mode 100644
index 00000000000..cd78b4ec0fb
--- /dev/null
+++ b/products/maka/workbench/src/composer_input.rs
@@ -0,0 +1,628 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+//! The message composer owns plain source text; inline skill nodes only
+//! determine its presentation and native editing boundaries.
+
+mod message;
+mod model;
+
+use std::sync::{Arc, Mutex};
+
+use nsh_base::rich_editor::{
+    commands::split_block,
+    extensions::history::{history, redo, undo},
+    model::{Node, ResolvedPos, Slice},
+    state::{
+        EditorState, EditorStateConfig, KeyEvent, Plugin, PluginSpec, Transaction,
+        TransactionOrigin,
+    },
+    view::{
+        EditorSession, NodeView, NodeViewCx, NodeViews, RichEditorPastedFiles, RichEditorStyles,
+        rich_editor,
+    },
+};
+use nsh_core::{
+    Color,
+    canvas::{LineCap, LineJoin},
+    keymap::{Key as NativeKey, Keystroke, Modifiers},
+    prelude::*,
+};
+
+#[derive(Clone, Copy, Debug, PartialEq, Props)]
+pub(crate) struct ComposerInputProps {
+    pub value: Prop<String>,
+    #[prop(default)]
+    pub value_count: Prop<u32>,
+    #[prop(default)]
+    pub read_only: Prop<bool>,
+    #[prop(default)]
+    pub placeholder: Prop<String>,
+    #[prop(default)]
+    pub accessibility_label: Prop<String>,
+    pub token_color: Prop<Color>,
+    pub token_background_color: Prop<Color>,
+    pub token_icon: Prop<String>,
+    #[prop(default)]
+    pub capture_keys: Prop<Vec<ComposerKeyCapture>>,
+    #[prop(default)]
+    pub styles: Prop<RichEditorStyles>,
+    #[prop(default)]
+    pub source_id: Prop<Option<SharedString>>,
+    #[prop(default)]
+    pub source_offset: Prop<u64>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, JsObject)]
+pub(crate) struct ComposerKeyCapture {
+    pub key: String,
+    #[prop(default)]
+    pub fallback: bool,
+}
+
+#[derive(Debug)]
+struct Receipt {
+    source: String,
+    count: u32,
+    pending: Option<(String, u32)>,
+}
+
+#[derive(Clone)]
+struct Events {
+    receipt: Arc<Mutex<Receipt>>,
+    cx: Scope<ComposerInputEvent>,
+}
+
+impl Events {
+    fn changed(&self, value: String) {
+        let count = {
+            let mut receipt = self.receipt.lock().expect("composer receipt lock poisoned");
+            if receipt.source == value {
+                return;
+            }
+            receipt.source.clone_from(&value);
+            receipt.count = receipt
+                .count
+                .checked_add(1)
+                .expect("composer edit receipt overflow");
+            receipt.count
+        };
+        self.cx
+            .emit(ComposerInputEvent::Change(ComposerChange { value, count }));
+    }
+
+    fn apply_value(
+        &self,
+        session: &EditorSession,
+        schema: &nsh_base::rich_editor::model::Schema,
+        plugins: &[Plugin],
+        value: String,
+        count: u32,
+        source: &message::Source,
+    ) {
+        if session.composing() {
+            self.receipt
+                .lock()
+                .expect("composer receipt lock poisoned")
+                .pending = Some((value, count));
+            return;
+        }
+        let current_state = session.state();
+        let current = model::source(current_state.doc());
+        {
+            let mut receipt = self.receipt.lock().expect("composer receipt lock poisoned");
+            if count < receipt.count || (current == value && source.matches(current_state.doc())) {
+                return;
+            }
+            receipt.source.clone_from(&value);
+            receipt.pending = None;
+        }
+        session.update_state(state(schema, &value, plugins.to_vec(), source));
+    }
+
+    fn apply_pending(
+        &self,
+        session: &EditorSession,
+        schema: &nsh_base::rich_editor::model::Schema,
+        plugins: &[Plugin],
+        source: &message::Source,
+    ) {
+        let pending = self
+            .receipt
+            .lock()
+            .expect("composer receipt lock poisoned")
+            .pending
+            .take();
+        if let Some((value, count)) = pending {
+            self.apply_value(session, schema, plugins, value, count, source);
+        }
+    }
+}
+
+#[class]
+pub(crate) struct ComposerInputState {
+    session: EditorSession,
+}
+
+#[class]
+impl ComposerInputState {
+    #[getter]
+    pub fn composing(&self) -> bool {
+        self.session.composing()
+    }
+
+    #[getter]
+    pub fn selection(&self) -> ComposerSelection {
+        let state = self.session.state();
+        selection(&state, &model::Projection::new(state.doc()))
+    }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, JsObject)]
+pub(crate) struct ComposerChange {
+    pub value: String,
+    pub count: u32,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, JsObject)]
+pub(crate) struct ComposerSelection {
+    pub start: u32,
+    pub end: u32,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, JsObject)]
+pub(crate) struct ComposerSubmit {
+    pub text: String,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, JsObject)]
+pub(crate) struct ComposerKey {
+    pub key: String,
+    pub text: String,
+    pub selection: ComposerSelection,
+}
+
+#[derive(Clone, Debug, PartialEq, Event)]
+pub(crate) enum ComposerInputEvent {
+    #[args(event)]
+    Change(ComposerChange),
+    #[args(event)]
+    SelectionChange(ComposerSelection),
+    #[args(event)]
+    Submit(ComposerSubmit),
+    #[args(event)]
+    Key(ComposerKey),
+    Focus,
+    Blur,
+    #[args(event)]
+    PasteFiles(RichEditorPastedFiles),
+}
+
+#[derive(Clone, Debug, Default, PartialEq, JsObject)]
+pub(crate) struct ComposerReplacement {
+    pub start: u32,
+    pub end: u32,
+    pub text: String,
+    pub expected_text: String,
+    pub expected_selection: ComposerSelection,
+}
+
+pub(crate) struct ComposerInputApi {
+    session: EditorSession,
+    props: ComposerInputProps,
+}
+
+#[methods]
+impl ComposerInputApi {
+    pub fn focus(&self) {
+        self.session.focus();
+    }
+    pub fn blur(&self) {
+        self.session.blur();
+    }
+    pub fn status(&self) -> Instance<ComposerInputState> {
+        Instance::new(ComposerInputState {
+            session: self.session.clone(),
+        })
+    }
+    pub fn caret_bounds(&self) -> Option<Bounds<Points>> {
+        self.session
+            .page_coords_at_pos(self.session.state().selection().head())
+    }
+    pub fn content_height(&self) -> Option<Points> {
+        let state = self.session.state();
+        let first = self.session.coords_at_pos(1)?;
+        let last = self
+            .session
+            .coords_at_pos(state.doc().content().size().checked_sub(1)?)?;
+        Some(last.origin.y + last.size.height - first.origin.y)
+    }
+    pub fn replace_range(&self, request: ComposerReplacement) -> bool {
+        if self.props.read_only.get_untracked() || self.session.composing() {
+            return false;
+        }
+        let state = self.session.state();
+        let projection = model::Projection::new(state.doc());
+        if projection.source != request.expected_text
+            || selection(&state, &projection) != request.expected_selection
+        {
+            return false;
+        }
+        let Some(mut tr) = model::replace(&state, request.start, request.end, &request.text) else {
+            return false;
+        };
+        tr.set_origin(TransactionOrigin::User).scroll_into_view();
+        self.session.dispatch(tr).is_ok()
+    }
+}
+
+struct SkillView(ComposerInputProps);
+
+impl NodeView for SkillView {
+    fn create(&self, _cx: &NodeViewCx, node: &Node) -> AnyElement {
+        let props = self.0;
+        let name = node.attrs()["name"]
+            .as_str()
+            .expect("a skill node's name is text")
+            .to_owned();
+        let icon = if is_terminal() {
+            text("📖").into_element()
+        } else {
+            canvas(move || {
+                Painter::new()
+                    .scale(14.0 / 24.0, 14.0 / 24.0)
+                    .stroke_color(Hsla::from(props.token_color.get()))
+                    .line_width(2.0)
+                    .line_cap(LineCap::Round)
+                    .line_join(LineJoin::Round)
+                    .stroke_svg(&props.token_icon.get())
+            })
+            .w(px(14.0))
+            .h(px(14.0))
+            .into_element()
+        };
+        let chip = view()
+            .flex_row()
+            .items_center()
+            .gap(px(4.0))
+            .px(px(6.0))
+            .rounded(px(4.0))
+            .bg(move || AdaptiveColor::from(Hsla::from(props.token_background_color.get())))
+            .text_color(move || AdaptiveColor::from(Hsla::from(props.token_color.get())))
+            .pointer_events(PointerEvents::None)
+            .child(icon)
+            .child(text(name))
+            .into_element();
+        message::attachment(node, chip)
+    }
+}
+
+struct ComposerBehavior {
+    props: ComposerInputProps,
+    events: Events,
+}
+
+impl PluginSpec for ComposerBehavior {
+    fn append_transaction(
+        &self,
+        trs: &[Transaction],
+        _old: &EditorState,
+        new: &EditorState,
+    ) -> Option<Transaction> {
+        if self.props.read_only.get_untracked() {
+            return None;
+        }
+        if !trs.iter().any(|tr| tr.doc_changed() || tr.selection_set()) {
+            return None;
+        }
+        model::tokenize(new, false)
+    }
+
+    fn handle_key_down(
+        &self,
+        state: &EditorState,
+        event: &KeyEvent,
+        dispatch: &mut dyn FnMut(Transaction),
+    ) -> bool {
+        if self.props.read_only.get_untracked() {
+            return false;
+        }
+        if let Some(stroke) = keystroke(event) {
+            let apple = event.apple_keyboard.unwrap_or(cfg!(target_os = "macos"));
+            for binding in self.props.capture_keys.get_untracked() {
+                if binding.fallback && !state.selection().empty() {
+                    continue;
+                }
+                if Keystroke::parse_with(&binding.key, apple)
+                    .is_ok_and(|candidate| candidate == stroke)
+                {
+                    let projection = model::Projection::new(state.doc());
+                    self.events.changed(projection.source.clone());
+                    self.events.cx.emit(ComposerInputEvent::Key(ComposerKey {
+                        key: binding.key,
+                        text: projection.source.clone(),
+                        selection: selection(state, &projection),
+                    }));
+                    return true;
+                }
+            }
+        }
+        if matches!(event.key.as_str(), "Backspace" | "Delete")
+            && !event.mod_key
+            && !event.ctrl
+            && !event.alt
+            && !(event.shift && event.key == "Delete")
+            && let Some(tr) = model::delete_atom(state, event.key == "Delete")
+        {
+            dispatch(tr);
+            return true;
+        }
+        if event.key == "Enter" {
+            if event.shift || event.alt {
+                return split_block(state, Some(dispatch));
+            }
+            let source = model::source(state.doc());
+            self.events.changed(source.clone());
+            self.events
+                .cx
+                .emit(ComposerInputEvent::Submit(ComposerSubmit { text: source }));
+            return true;
+        }
+        if event.mod_key && !event.alt && event.key.eq_ignore_ascii_case("z") {
+            return if event.shift {
+                redo(state, Some(dispatch))
+            } else {
+                undo(state, Some(dispatch))
+            };
+        }
+        if event.mod_key && !event.alt && event.key.eq_ignore_ascii_case("y") {
+            return redo(state, Some(dispatch));
+        }
+        false
+    }
+
+    fn handle_paste(
+        &self,
+        state: &EditorState,
+        slice: &Slice,
+        dispatch: &mut dyn FnMut(Transaction),
+    ) -> bool {
+        let projection = model::Projection::new(state.doc());
+        let selected = selection(state, &projection);
+        let text = model::fragment_source(&slice.content);
+        let Some(mut tr) = model::replace(state, selected.start, selected.end, &text) else {
+            return false;
+        };
+        tr.set_origin(TransactionOrigin::Paste).scroll_into_view();
+        dispatch(tr);
+        true
+    }
+
+    fn clipboard_text_parser(
+        &self,
+        state: &EditorState,
+        text: &str,
+        _context: &ResolvedPos,
+        _plain: bool,
+    ) -> Option<Slice> {
+        Some(model::slice(state.schema(), text))
+    }
+
+    fn mark_views(&self) -> Vec<(String, nsh_base::rich_editor::state::ViewFactory)> {
+        message::mark_views()
+    }
+
+    fn clipboard_text_serializer(&self, _state: &EditorState, slice: &Slice) -> Option<String> {
+        Some(model::fragment_source(&slice.content))
+    }
+}
+
+fn keystroke(event: &KeyEvent) -> Option<Keystroke> {
+    let key = match event.key.as_str() {
+        "Enter" => NativeKey::Enter,
+        "Escape" => NativeKey::Escape,
+        "Tab" => NativeKey::Tab,
+        "Backspace" => NativeKey::Backspace,
+        "Delete" => NativeKey::Delete,
+        "ArrowLeft" => NativeKey::Left,
+        "ArrowRight" => NativeKey::Right,
+        "ArrowUp" => NativeKey::Up,
+        "ArrowDown" => NativeKey::Down,
+        "Home" => NativeKey::Home,
+        "End" => NativeKey::End,
+        "PageUp" => NativeKey::PageUp,
+        "PageDown" => NativeKey::PageDown,
+        value if value.chars().count() == 1 => {
+            NativeKey::Char(value.chars().next()?.to_ascii_lowercase())
+        }
+        _ => return None,
+    };
+    Some(Keystroke {
+        key,
+        modifiers: Modifiers {
+            ctrl: event.ctrl,
+            alt: event.alt,
+            shift: event.shift,
+            cmd: event.meta,
+        },
+    })
+}
+
+fn selection(state: &EditorState, projection: &model::Projection) -> ComposerSelection {
+    ComposerSelection {
+        start: projection.source_at(state.selection().from()),
+        end: projection.source_at(state.selection().to()),
+    }
+}
+
+fn state(
+    schema: &nsh_base::rich_editor::model::Schema,
+    source: &str,
+    plugins: Vec<Plugin>,
+    annotation: &message::Source,
+) -> EditorState {
+    let doc = annotation.annotate(schema, model::document(schema, source, true));
+    let end = model::Projection::new(&doc)
+        .doc_at(source.encode_utf16().count() as u32, true)
+        .expect("the source end is a valid caret");
+    let selection = nsh_base::rich_editor::state::TextSelection::create(&doc, end, None);
+    EditorState::create(
+        EditorStateConfig::new(schema.clone())
+            .doc(doc)
+            .selection(selection)
+            .plugins(plugins),
+    )
+    .expect("the composer creates a valid plain-text document")
+}
+
+#[component(methods = ComposerInputApi)]
+pub(crate) fn ComposerInput(
+    props: ComposerInputProps,
+    cx: Scope<ComposerInputEvent>,
+) -> impl IntoElement {
+    let schema = model::schema();
+    let initial = props.value.get_untracked();
+    let events = Events {
+        receipt: Arc::new(Mutex::new(Receipt {
+            source: initial.clone(),
+            count: props.value_count.get_untracked(),
+            pending: None,
+        })),
+        cx,
+    };
+    let plugins: Vec<Plugin> = vec![
+        Arc::new(ComposerBehavior {
+            props,
+            events: events.clone(),
+        }),
+        history(Default::default()),
+    ];
+    let session = EditorSession::new(
+        state(&schema, &initial, plugins.clone(), &source(props)),
+        NodeViews::new().with("skill", Arc::new(SkillView(props))),
+    );
+    cx.methods(ComposerInputApi {
+        session: session.clone(),
+        props,
+    });
+    {
+        let (session, events, schema, plugins) = (
+            session.clone(),
+            events.clone(),
+            schema.clone(),
+            plugins.clone(),
+        );
+        effect(move || {
+            props.value.get();
+            props.value_count.get();
+            props.source_id.get();
+            props.source_offset.get();
+            let (session, events, schema, plugins) = (
+                session.clone(),
+                events.clone(),
+                schema.clone(),
+                plugins.clone(),
+            );
+            after_answer(move || {
+                events.apply_value(
+                    &session,
+                    &schema,
+                    &plugins,
+                    props.value.get_untracked(),
+                    props.value_count.get_untracked(),
+                    &message::Source {
+                        id: props.source_id.get_untracked(),
+                        offset: props.source_offset.get_untracked(),
+                    },
+                );
+            });
+        });
+    }
+    let changed = session.clone();
+    let selected = session.clone();
+    let blurred = session.clone();
+    let (change_schema, change_plugins, change_events) =
+        (schema.clone(), plugins.clone(), events.clone());
+    view().flex_1().child(
+        rich_editor()
+            .editor(session)
+            .flex_1()
+            .editable(move || !props.read_only.get())
+            .placeholder(move || Some(props.placeholder.get().into()))
+            .accessibility_label(move || Some(props.accessibility_label.get().into()))
+            .styles(move || props.styles.get())
+            .on_change(move |_: &_| {
+                change_events.changed(model::source(changed.state().doc()));
+                change_events.apply_pending(
+                    &changed,
+                    &change_schema,
+                    &change_plugins,
+                    &source(props),
+                );
+            })
+            .on_selection_change(move |_: &_| {
+                let state = selected.state();
+                cx.emit(ComposerInputEvent::SelectionChange(selection(
+                    &state,
+                    &model::Projection::new(state.doc()),
+                )));
+            })
+            .on_focus(move || cx.emit(ComposerInputEvent::Focus))
+            .on_blur(move || {
+                events.apply_pending(&blurred, &schema, &plugins, &source(props));
+                cx.emit(ComposerInputEvent::Blur);
+            })
+            .on_paste_files(move |event: &RichEditorPastedFiles| {
+                cx.emit(ComposerInputEvent::PasteFiles(event.clone()))
+            }),
+    )
+}
+
+fn source(props: ComposerInputProps) -> message::Source {
+    message::Source {
+        id: props.source_id.get(),
+        offset: props.source_offset.get(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use nsh_base::rich_editor::extensions::history::undo_depth;
+
+    #[test]
+    fn replacing_the_controlled_value_discards_the_previous_draft_history() {
+        let schema = model::schema();
+        let plugins = vec![history(Default::default())];
+        let original = state(
+            &schema,
+            "draft",
+            plugins.clone(),
+            &message::Source::default(),
+        );
+        let edited = original
+            .apply(model::replace(&original, 5, 5, " /skill:review").unwrap())
+            .unwrap();
+        assert_eq!(model::source(edited.doc()), "draft /skill:review");
+        assert_eq!(undo_depth(&edited), 1);
+        let reset = state(&schema, "", plugins, &message::Source::default());
+        assert_eq!(model::source(reset.doc()), "");
+        assert_eq!(undo_depth(&reset), 0);
+    }
+}
diff --git a/products/maka/workbench/src/composer_input/message.rs b/products/maka/workbench/src/composer_input/message.rs
new file mode 100644
index 00000000000..7a07771d2de
--- /dev/null
+++ b/products/maka/workbench/src/composer_input/message.rs
@@ -0,0 +1,217 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+//! Canonical history addresses for the readonly rendering of a message.
+
+use std::sync::Arc;
+
+use nsh_base::rich_editor::{
+    model::{Fragment, Mark, Node, Schema},
+    state::ViewFactory,
+    view::MarkView,
+};
+use nsh_core::{TextSource, TextSourceKind, TextSourceSegment, prelude::*};
+use serde_json::{Value, json};
+
+#[derive(Clone, Default)]
+pub(super) struct Source {
+    pub id: Option<SharedString>,
+    pub offset: u64,
+}
+
+impl Source {
+    pub fn matches(&self, doc: &Node) -> bool {
+        doc.attrs().get("sourceId").and_then(Value::as_str) == self.id.as_deref()
+            && doc
+                .attrs()
+                .get("sourceOffset")
+                .and_then(Value::as_u64)
+                .unwrap_or(0)
+                == self.offset
+    }
+
+    pub fn annotate(&self, schema: &Schema, doc: Node) -> Node {
+        let Some(id) = &self.id else {
+            return doc;
+        };
+        let mut offset = self.offset;
+        let mut paragraphs = Vec::new();
+        for (paragraph_index, paragraph) in doc.content().iter().enumerate() {
+            let mut nodes = Vec::new();
+            for (node_index, original) in paragraph.content().iter().enumerate() {
+                let raw = if original.ty().name() == "skill" {
+                    format!(
+                        "/skill:{}",
+                        original.attrs()["name"]
+                            .as_str()
+                            .expect("a skill name is text")
+                    )
+                } else {
+                    original
+                        .text()
+                        .expect("composer inline nodes are text or skills")
+                        .to_owned()
+                };
+                // A loaded suffix cannot prove the boundary before its first
+                // character. Never turn it into a new invocation at the gap.
+                let node = if self.offset > 0
+                    && paragraph_index == 0
+                    && node_index == 0
+                    && original.ty().name() == "skill"
+                {
+                    schema.text(&raw, vec![])
+                } else {
+                    original.clone()
+                };
+                if node.is_text() {
+                    let mark = schema
+                        .mark(
+                            "source",
+                            Some(
+                                [
+                                    ("id".to_owned(), json!(id.as_ref())),
+                                    ("offset".to_owned(), json!(offset)),
+                                ]
+                                .into(),
+                            ),
+                        )
+                        .expect("a source mark has an identity and byte offset");
+                    nodes.push(node.mark(vec![mark]));
+                } else {
+                    let mut attrs = node.attrs().clone();
+                    attrs.insert("sourceId".to_owned(), json!(id.as_ref()));
+                    attrs.insert("sourceOffset".to_owned(), json!(offset));
+                    nodes.push(
+                        schema
+                            .node("skill", Some(attrs), Fragment::empty(), vec![])
+                            .expect("source metadata preserves a skill node"),
+                    );
+                }
+                offset += raw.len() as u64;
+            }
+            paragraphs.push(paragraph.copy(Fragment::from(nodes)));
+            if paragraph_index + 1 < doc.child_count() {
+                offset += paragraph
+                    .attrs()
+                    .get("ending")
+                    .and_then(Value::as_str)
+                    .unwrap_or("\n")
+                    .len() as u64;
+            }
+        }
+        let mut attrs = doc.attrs().clone();
+        attrs.insert("sourceId".to_owned(), json!(id.as_ref()));
+        attrs.insert("sourceOffset".to_owned(), json!(self.offset));
+        schema
+            .node("doc", Some(attrs), Fragment::from(paragraphs), vec![])
+            .expect("source annotations preserve the composer schema")
+    }
+}
+
+struct SourceMark;
+
+impl MarkView for SourceMark {
+    fn create(&self, mark: &Mark, value: &str) -> AnyElement {
+        text(value.to_owned())
+            .text_source(Some(Arc::new(TextSource::Literal {
+                id: Arc::from(
+                    mark.attrs()["id"]
+                        .as_str()
+                        .expect("a source mark has an id"),
+                ),
+                offset: mark.attrs()["offset"]
+                    .as_u64()
+                    .expect("a source mark has a byte offset"),
+            })))
+            .into_element()
+    }
+}
+
+pub(super) fn mark_views() -> Vec<(String, ViewFactory)> {
+    let view: Arc<dyn MarkView> = Arc::new(SourceMark);
+    vec![("source".to_owned(), Arc::new(view))]
+}
+
+pub(super) fn attachment(node: &Node, chip: AnyElement) -> AnyElement {
+    let Some(id) = node.attrs().get("sourceId").and_then(Value::as_str) else {
+        return chip;
+    };
+    let offset = node.attrs()["sourceOffset"]
+        .as_u64()
+        .expect("skill source offset is a byte offset");
+    let length = 7 + node.attrs()["name"]
+        .as_str()
+        .expect("a skill name is text")
+        .len() as u64;
+    text("")
+        .text_source(Some(Arc::new(TextSource::Mapped {
+            id: Arc::from(id),
+            segments: vec![TextSourceSegment {
+                start: 0,
+                end: 1,
+                source_start: offset,
+                source_end: offset + length,
+                kind: TextSourceKind::Replacement,
+            }],
+        })))
+        .child(chip)
+        .into_element()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::composer_input::model;
+
+    #[test]
+    fn history_annotations_preserve_utf8_addresses_and_plain_copy_text() {
+        let schema = model::schema();
+        let doc = model::document(&schema, "🦀 /skill:review\r\n尾部", true);
+        let source = Source {
+            id: Some("message".into()),
+            offset: 100,
+        };
+        let doc = source.annotate(&schema, doc);
+        assert_eq!(model::source(&doc), "🦀 /skill:review\r\n尾部");
+        assert!(source.matches(&doc));
+        assert_eq!(
+            doc.child(0).child(0).marks()[0].attrs()["offset"],
+            json!(100)
+        );
+        assert_eq!(doc.child(0).child(1).attrs()["sourceOffset"], json!(105));
+        assert_eq!(
+            doc.child(1).child(0).marks()[0].attrs()["offset"],
+            json!(120)
+        );
+    }
+
+    #[test]
+    fn a_loaded_suffix_does_not_invent_a_skill_boundary_at_its_start() {
+        let schema = model::schema();
+        let doc = model::document(&schema, "/skill:partial /skill:valid", true);
+        let doc = Source {
+            id: Some("message".into()),
+            offset: 20,
+        }
+        .annotate(&schema, doc);
+        assert_eq!(doc.child(0).child(0).text(), Some("/skill:partial"));
+        assert_eq!(doc.child(0).child(2).ty().name(), "skill");
+        assert_eq!(model::source(&doc), "/skill:partial /skill:valid");
+    }
+}
diff --git a/products/maka/workbench/src/composer_input/model.rs b/products/maka/workbench/src/composer_input/model.rs
new file mode 100644
index 00000000000..47b8005c057
--- /dev/null
+++ b/products/maka/workbench/src/composer_input/model.rs
@@ -0,0 +1,502 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+use std::{ops::Range, sync::LazyLock};
+
+use nsh_core::input_tokens::{InputTokenRule, InputTokens};
+
+use nsh_base::rich_editor::{
+    model::{Fragment, Node, Schema, SchemaSpec, Slice},
+    state::{EditorState, TextSelection, Transaction},
+};
+use serde_json::{Value, json};
+
+pub(super) fn schema() -> Schema {
+    SchemaSpec::from_json(&json!({
+        "nodes": [
+            ["doc", {"content":"paragraph+", "attrs":{"sourceId":{"default":null},"sourceOffset":{"default":0}}}],
+            ["paragraph", {"content":"inline*", "group":"block", "attrs":{
+                "ending":{"default":"\n"}
+            }}],
+            ["skill", {"inline":true, "group":"inline", "atom":true,
+                "attrs":{"name":{"validate":"string"},"sourceId":{"default":null},"sourceOffset":{"default":0}}, "renderText":"/skill:{name}"}],
+            ["text", {"group":"inline"}]
+        ],
+        "marks":[["source", {"attrs":{"id":{"validate":"string"},"offset":{"validate":"number"}}}]]
+    }))
+    .expect("the composer schema is valid")
+}
+
+pub(super) fn skill(schema: &Schema, name: &str) -> Node {
+    schema
+        .node(
+            "skill",
+            Some([("name".to_owned(), json!(name))].into()),
+            Fragment::empty(),
+            vec![],
+        )
+        .expect("a skill node has its required name")
+}
+
+pub(super) fn token_ranges(text: &str) -> Vec<Range<usize>> {
+    static RULE: LazyLock<InputTokenRule> = LazyLock::new(|| {
+        InputTokenRule::new(
+            r"(?:^|[\t-\r \u{00a0}\u{1680}\u{2000}-\u{200a}\u{2028}\u{2029}\u{202f}\u{205f}\u{3000}\u{feff}])(?P<token>/skill:[A-Za-z0-9._-]+)",
+            Default::default(),
+            true,
+        ).expect("the skill invocation token pattern is valid")
+    });
+    let mut tokens = InputTokens::default();
+    tokens.set_rules(std::slice::from_ref(&RULE), text);
+    tokens
+        .spans()
+        .iter()
+        .map(|span| span.range.clone())
+        .collect()
+}
+
+fn inline(schema: &Schema, text: &str, atoms: bool) -> Vec<Node> {
+    let mut out = Vec::new();
+    let mut at = 0;
+    if atoms {
+        for range in token_ranges(text) {
+            if at < range.start {
+                out.push(schema.text(&text[at..range.start], vec![]));
+            }
+            out.push(skill(
+                schema,
+                &text[range.start + "/skill:".len()..range.end],
+            ));
+            at = range.end;
+        }
+    }
+    if at < text.len() {
+        out.push(schema.text(&text[at..], vec![]));
+    }
+    out
+}
+
+pub(super) fn document(schema: &Schema, source: &str, atoms: bool) -> Node {
+    let mut paragraphs = Vec::new();
+    let mut rest = source;
+    loop {
+        let split = rest.find(['\r', '\n']);
+        let (text, ending, remaining) = match split {
+            Some(at) => {
+                let width = if rest[at..].starts_with("\r\n") { 2 } else { 1 };
+                (
+                    &rest[..at],
+                    &rest[at..at + width],
+                    Some(&rest[at + width..]),
+                )
+            }
+            None => (rest, "\n", None),
+        };
+        paragraphs.push(
+            schema
+                .node(
+                    "paragraph",
+                    Some([("ending".to_owned(), json!(ending))].into()),
+                    Fragment::from(inline(schema, text, atoms)),
+                    vec![],
+                )
+                .expect("composer paragraphs contain only inline nodes"),
+        );
+        match remaining {
+            Some(next) => rest = next,
+            None => break,
+        }
+    }
+    schema
+        .node("doc", None, Fragment::from(paragraphs), vec![])
+        .expect("a composer document contains at least one paragraph")
+}
+
+pub(super) fn slice(schema: &Schema, source: &str) -> Slice {
+    let doc = document(schema, source, true);
+    Slice::new(doc.content().clone(), 1, 1)
+}
+
+fn node_source(node: &Node) -> String {
+    if let Some(text) = node.text() {
+        text.to_owned()
+    } else if node.ty().name() == "skill" {
+        format!(
+            "/skill:{}",
+            node.attrs()["name"].as_str().expect("a skill name is text")
+        )
+    } else {
+        node.content().iter().map(node_source).collect()
+    }
+}
+
+pub(super) fn fragment_source(fragment: &Fragment) -> String {
+    let mut source = String::new();
+    for (i, node) in fragment.iter().enumerate() {
+        source.push_str(&node_source(node));
+        if node.ty().name() == "paragraph" && i + 1 < fragment.child_count() {
+            source.push_str(
+                node.attrs()
+                    .get("ending")
+                    .and_then(Value::as_str)
+                    .unwrap_or("\n"),
+            );
+        }
+    }
+    source
+}
+
+pub(super) fn source(doc: &Node) -> String {
+    fragment_source(doc.content())
+}
+
+#[derive(Debug)]
+struct Span {
+    source: Range<usize>,
+    doc: Range<usize>,
+    atom: bool,
+}
+
+/// One action's conversion table. Source offsets remain UTF-16, including
+/// the full invocation; an inline atom occupies one document position.
+#[derive(Debug)]
+pub(super) struct Projection {
+    pub source: String,
+    spans: Vec<Span>,
+    end: usize,
+}
+
+impl Projection {
+    pub fn new(doc: &Node) -> Self {
+        let mut source = String::new();
+        let mut spans = Vec::new();
+        let mut offset = 0;
+        let mut end = 1;
+        doc.for_each(&mut |paragraph, block_at, index| {
+            paragraph.for_each(&mut |node, inline_at, _| {
+                let text = node_source(node);
+                let length = text.encode_utf16().count();
+                let at = block_at + 1 + inline_at;
+                spans.push(Span {
+                    source: offset..offset + length,
+                    doc: at..at + node.node_size(),
+                    atom: !node.is_text(),
+                });
+                source.push_str(&text);
+                offset += length;
+            });
+            end = block_at + 1 + paragraph.content().size();
+            if index + 1 < doc.child_count() {
+                let ending = paragraph
+                    .attrs()
+                    .get("ending")
+                    .and_then(Value::as_str)
+                    .unwrap_or("\n");
+                let length = ending.encode_utf16().count();
+                spans.push(Span {
+                    source: offset..offset + length,
+                    doc: end..end + 2,
+                    atom: true,
+                });
+                source.push_str(ending);
+                offset += length;
+            }
+        });
+        Self { source, spans, end }
+    }
+
+    pub fn source_at(&self, pos: usize) -> u32 {
+        for span in &self.spans {
+            if pos < span.doc.start {
+                return span.source.start as u32;
+            }
+            if pos <= span.doc.end {
+                return if span.atom {
+                    if pos == span.doc.start {
+                        span.source.start
+                    } else {
+                        span.source.end
+                    }
+                } else {
+                    span.source.start + pos - span.doc.start
+                } as u32;
+            }
+        }
+        self.source.encode_utf16().count() as u32
+    }
+
+    pub fn doc_at(&self, offset: u32, end: bool) -> Option<usize> {
+        byte_at(&self.source, offset)?;
+        let offset = offset as usize;
+        for span in &self.spans {
+            if offset < span.source.start {
+                return Some(span.doc.start);
+            }
+            if offset <= span.source.end {
+                return Some(if offset == span.source.start {
+                    span.doc.start
+                } else if offset == span.source.end {
+                    span.doc.end
+                } else if span.atom {
+                    if end { span.doc.end } else { span.doc.start }
+                } else {
+                    span.doc.start + offset - span.source.start
+                });
+            }
+        }
+        Some(self.end)
+    }
+}
+
+pub(super) fn byte_at(source: &str, offset: u32) -> Option<usize> {
+    let mut units = 0;
+    for (at, ch) in source.char_indices() {
+        if units == offset {
+            return Some(at);
+        }
+        units += ch.len_utf16() as u32;
+        if units > offset {
+            return None;
+        }
+    }
+    (units == offset).then_some(source.len())
+}
+
+pub(super) fn tokenize(state: &EditorState, force: bool) -> Option<Transaction> {
+    let projection = Projection::new(state.doc());
+    let caret = projection.source_at(state.selection().head()) as usize;
+    let anchor = projection.source_at(state.selection().anchor()) as usize;
+    let mut replacements = Vec::new();
+    for range in token_ranges(&projection.source) {
+        let start = projection.source[..range.start].encode_utf16().count();
+        let end = projection.source[..range.end].encode_utf16().count();
+        let from = projection
+            .doc_at(start as u32, false)
+            .expect("token starts at a character boundary");
+        let to = projection
+            .doc_at(end as u32, true)
+            .expect("token ends at a character boundary");
+        if state.doc().node_at(from).is_some_and(|node| {
+            node.ty().name() == "skill"
+                && from + node.node_size() == to
+                && node_source(&node) == projection.source[range.clone()]
+        }) {
+            continue;
+        }
+        if !force && anchor >= start && anchor <= end && caret >= start && caret <= end {
+            continue;
+        }
+        replacements.push((
+            from,
+            to,
+            skill(
+                state.schema(),
+                &projection.source[range.start + 7..range.end],
+            ),
+        ));
+    }
+    if replacements.is_empty() {
+        return None;
+    }
+    let mut tr = state.tr();
+    for (start, end, node) in replacements.into_iter().rev() {
+        tr.replace_with(start, end, Fragment::from(vec![node]))
+            .expect("a token replaces its source range");
+    }
+    Some(tr)
+}
+
+pub(super) fn replace(
+    state: &EditorState,
+    start: u32,
+    end: u32,
+    text: &str,
+) -> Option<Transaction> {
+    if start > end {
+        return None;
+    }
+    let projection = Projection::new(state.doc());
+    let from = projection.doc_at(start, false)?;
+    let to = projection.doc_at(end, true)?;
+    let start = projection.source_at(from);
+    let end = projection.source_at(to);
+    let first = byte_at(&projection.source, start)?;
+    let last = byte_at(&projection.source, end)?;
+    let mut raw = String::with_capacity(projection.source.len() + text.len());
+    raw.push_str(&projection.source[..first]);
+    raw.push_str(text);
+    raw.push_str(&projection.source[last..]);
+    let doc = document(state.schema(), &raw, true);
+    let next = Projection::new(&doc);
+    let caret = next.doc_at(start + text.encode_utf16().count() as u32, true)?;
+    let mut tr = state.tr();
+    tr.replace_with(0, state.doc().content().size(), doc.content().clone())
+        .ok()?;
+    let selected = TextSelection::create(tr.doc(), caret, None);
+    tr.set_selection(selected);
+    nsh_base::rich_editor::extensions::history::close_history(&mut tr);
+    Some(tr)
+}
+
+pub(super) fn delete_atom(state: &EditorState, forward: bool) -> Option<Transaction> {
+    if !state.selection().empty() {
+        return None;
+    }
+    let caret = state.selection().head();
+    let at = if forward {
+        caret
+    } else {
+        caret.checked_sub(1)?
+    };
+    let node = state.doc().node_at(at)?;
+    if node.ty().name() != "skill" {
+        return None;
+    }
+    let mut tr = state.tr();
+    tr.delete(at, at + node.node_size()).ok()?;
+    nsh_base::rich_editor::extensions::history::close_history(&mut tr);
+    Some(tr)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use nsh_base::rich_editor::{
+        extensions::history::{history, redo, undo},
+        state::EditorStateConfig,
+    };
+
+    #[test]
+    fn source_round_trips_skills_unicode_and_line_endings() {
+        let schema = schema();
+        let raw = "🦀 /skill:review, /skill:fix\r\n\n尾部\r";
+        let doc = document(&schema, raw, true);
+        assert_eq!(source(&doc), raw);
+        let p = Projection::new(&doc);
+        assert_eq!(p.source_at(p.doc_at(4, false).unwrap()), 3);
+        assert_eq!(p.source_at(p.doc_at(4, true).unwrap()), 16);
+        assert_eq!(p.source_at(p.doc_at(33, true).unwrap()), 33);
+        assert!(p.doc_at(1, false).is_none(), "a surrogate cannot be split");
+    }
+
+    #[test]
+    fn typed_skill_remains_editable_until_the_caret_leaves() {
+        let schema = schema();
+        let doc = document(&schema, "a /skill:review", false);
+        let selection = TextSelection::create(&doc, 16, None);
+        let state =
+            EditorState::create(EditorStateConfig::new(schema).doc(doc).selection(selection))
+                .unwrap();
+        assert!(tokenize(&state, false).is_none());
+        let mut tr = state.tr();
+        tr.set_selection(TextSelection::create(state.doc(), 1, None));
+        let state = state.apply(tr).unwrap();
+        let state = state.apply(tokenize(&state, false).unwrap()).unwrap();
+        assert_eq!(state.doc().child(0).child(1).ty().name(), "skill");
+        assert_eq!(source(state.doc()), "a /skill:review");
+    }
+
+    #[test]
+    fn typing_a_delimiter_confirms_the_skill_without_changing_its_source() {
+        let schema = schema();
+        let doc = document(&schema, "/skill:review", false);
+        let selection = TextSelection::create(&doc, 14, None);
+        let state =
+            EditorState::create(EditorStateConfig::new(schema).doc(doc).selection(selection))
+                .unwrap();
+        let mut tr = state.tr();
+        tr.insert_text(" ", None, None);
+        let state = state.apply(tr).unwrap();
+        let state = state.apply(tokenize(&state, false).unwrap()).unwrap();
+        assert_eq!(source(state.doc()), "/skill:review ");
+        assert_eq!(state.doc().child(0).child(0).ty().name(), "skill");
+        assert_eq!(state.doc().child(0).child(1).text(), Some(" "));
+    }
+
+    #[test]
+    fn explicit_replace_and_atomic_delete_are_separate_undoable_actions() {
+        let schema = schema();
+        let doc = document(&schema, "🦀 ", true);
+        let state = EditorState::create(
+            EditorStateConfig::new(schema)
+                .doc(doc)
+                .plugins(vec![history(Default::default())]),
+        )
+        .unwrap();
+        let state = state
+            .apply(replace(&state, 3, 3, "/skill:review ").unwrap())
+            .unwrap();
+        assert_eq!(source(state.doc()), "🦀 /skill:review ");
+        assert_eq!(state.doc().child(0).child(1).ty().name(), "skill");
+        let projection = Projection::new(state.doc());
+        let caret = projection.doc_at(16, true).unwrap();
+        let mut tr = state.tr();
+        tr.set_selection(TextSelection::create(state.doc(), caret, None));
+        let state = state.apply(tr).unwrap();
+        let deleted = state.apply(delete_atom(&state, false).unwrap()).unwrap();
+        assert_eq!(source(deleted.doc()), "🦀  ");
+        let mut restored = None;
+        assert!(undo(
+            &deleted,
+            Some(&mut |tr| restored = Some(deleted.apply(tr).unwrap()))
+        ));
+        let restored = restored.unwrap();
+        assert_eq!(source(restored.doc()), "🦀 /skill:review ");
+        let mut redone = None;
+        assert!(redo(
+            &restored,
+            Some(&mut |tr| redone = Some(restored.apply(tr).unwrap()))
+        ));
+        assert_eq!(source(redone.unwrap().doc()), "🦀  ");
+        let mut initial = None;
+        assert!(undo(
+            &restored,
+            Some(&mut |tr| initial = Some(restored.apply(tr).unwrap()))
+        ));
+        assert_eq!(source(initial.unwrap().doc()), "🦀 ");
+    }
+
+    #[test]
+    fn grammar_uses_js_whitespace_and_the_full_surrounding_source() {
+        assert_eq!(token_ranges("\u{feff}/skill:one"), vec![3..13]);
+        assert!(token_ranges("\u{85}/skill:one").is_empty());
+        let schema = schema();
+        let doc = document(&schema, "/skill:one", true);
+        let state = EditorState::create(EditorStateConfig::new(schema).doc(doc)).unwrap();
+        let state = state
+            .apply(replace(&state, 10, 10, "/skill:two").unwrap())
+            .unwrap();
+        assert_eq!(source(state.doc()), "/skill:one/skill:two");
+        assert_eq!(state.doc().child(0).child_count(), 2);
+        assert_eq!(state.doc().child(0).child(1).text(), Some("/skill:two"));
+    }
+    #[test]
+    fn skill_chips_never_separate_a_unicode_grapheme() {
+        let schema = schema();
+        let accented = document(&schema, "/skill:e\u{301}", true);
+        assert_eq!(accented.child(0).child_count(), 1);
+        assert_eq!(accented.child(0).child(0).text(), Some("/skill:e\u{301}"));
+        let joined = document(&schema, "/skill:review\u{200d}👩\u{200d}💻", true);
+        assert_eq!(joined.child(0).child_count(), 1);
+        assert_eq!(source(&joined), "/skill:review\u{200d}👩\u{200d}💻");
+        let separate = document(&schema, "/skill:review 👩\u{200d}💻", true);
+        assert_eq!(separate.child(0).child(0).ty().name(), "skill");
+        assert_eq!(separate.child(0).child(1).text(), Some(" 👩\u{200d}💻"));
+    }
+}
diff --git a/products/maka/workbench/src/lib.rs b/products/maka/workbench/src/lib.rs
index 9c5f9dbdd5d..26750dc2193 100644
--- a/products/maka/workbench/src/lib.rs
+++ b/products/maka/workbench/src/lib.rs
@@ -23,6 +23,7 @@
 mod attachment_paths;
 pub mod bindings;
 mod clipboard;
+mod composer_input;
 pub mod host;
 pub mod reload;
 
@@ -126,4 +127,102 @@ mod tests {
         app.press("role:button[skill-15]").unwrap();
         app.wait_for("text:/2:skill:skill-15/").unwrap();
     }
+
+    fn skill_input_fixture() -> nsh_testing::Headless {
+        let mut registry = nsh_core::element::Registry::ui_set("maka/host");
+        registry.value("host", || Instance::new(CompletionHost));
+        registry.register::<crate::composer_input::ComposerInput>();
+        registry.class::<crate::composer_input::ComposerInputState>();
+        let sets = vec![nsh_base::registry(), registry];
+        let bundle = nsh_bundler::bundle(&nsh_bundler::BundleOptions {
+            entry: std::path::Path::new("tests/fixtures/skill-input.tsx")
+                .canonicalize()
+                .unwrap(),
+            minify: false,
+            split: false,
+            ui_sets: sets.iter().map(Into::into).collect(),
+        })
+        .unwrap();
+        let mut app = nsh_testing::Headless::start(nsh_engine::EngineConfig {
+            viewport: Size::new(px(640.0), px(480.0)),
+            environment: Environment {
+                os: Os::MacOs,
+                renderer: Renderer::Native,
+                ..Environment::default()
+            },
+            ui_sets: sets,
+            ..nsh_engine::EngineConfig::new(nsh_engine::Bundle::source(bundle.code))
+        })
+        .unwrap();
+        app.wait_for("label:Draft").unwrap();
+        app.wait_for("text:Editor ready").unwrap();
+        app
+    }
+
+    #[test]
+    fn skill_input_edits_and_copies_invocations_as_whole_nodes() {
+        let mut app = skill_input_fixture();
+        app.wait_for("text:Selection 19:19").unwrap();
+        app.type_text("label:Draft", "").unwrap();
+        for key in ["mod+right", "left", "left", "left"] {
+            app.press_key(key).unwrap();
+        }
+        app.wait_for("text:Selection 4:4").unwrap();
+        app.press_key("shift+right").unwrap();
+        app.wait_for("text:Selection 4:17").unwrap();
+        app.press_key("mod+c").unwrap();
+        assert_eq!(app.screen().clipboard(), Some("/skill:review"));
+        app.press_key("backspace").unwrap();
+        app.wait_for(r#"text:Source "前😀  后""#).unwrap();
+        app.press_key("mod+z").unwrap();
+        app.wait_for(r#"text:Source "前😀 /skill:review 后""#)
+            .unwrap();
+        app.press_key("mod+a").unwrap();
+        app.press_key("mod+c").unwrap();
+        assert_eq!(app.screen().clipboard(), Some("前😀 /skill:review 后"));
+        app.press_key("enter").unwrap();
+        app.wait_for(r#"text:Submitted "前😀 /skill:review 后""#)
+            .unwrap();
+        app.press("label:Reset").unwrap();
+        app.wait_for(r#"text:Source """#).unwrap();
+        app.press_key("mod+z").unwrap();
+        assert!(app.shows("Source \"\""));
+        app.wait_for("text:Selection 0:0").unwrap();
+        app.press_key("tab").unwrap();
+        app.wait_for(r#"text:Source "/skill:fix ""#).unwrap();
+    }
+
+    #[test]
+    fn skill_input_paste_grows_the_viewport_and_message_selection_keeps_source() {
+        let mut app = skill_input_fixture();
+        app.type_text("label:Draft", "").unwrap();
+        app.press_key("mod+a").unwrap();
+        app.paste(
+            "label:Draft",
+            &nsh_core::PasteEvent::new(
+                "one\ntwo\nthree\nfour\nfive\nsix\nseven\neight\nnine\nten\n/skill:review",
+            ),
+        )
+        .unwrap();
+        assert_eq!(
+            app.screen()
+                .span_style("id:draft-field >> text:one")
+                .unwrap()
+                .line_height,
+            px(24.0)
+        );
+        app.wait_for("text:Height 144").unwrap();
+        app.press_key("mod+a").unwrap();
+        app.press_key("mod+c").unwrap();
+        assert_eq!(
+            app.screen().clipboard(),
+            Some("one\ntwo\nthree\nfour\nfive\nsix\nseven\neight\nnine\nten\n/skill:review")
+        );
+        app.type_text("label:前😀 /skill:review 后", "").unwrap();
+        app.press_key("mod+a").unwrap();
+        app.press_key("mod+c").unwrap();
+        assert_eq!(app.screen().clipboard(), Some("前😀 /skill:review 后"));
+        app.press_key("mod+n").unwrap();
+        app.wait_for("text:App shortcut received").unwrap();
+    }
 }
diff --git a/products/maka/workbench/tests/fixtures/skill-input.tsx b/products/maka/workbench/tests/fixtures/skill-input.tsx
new file mode 100644
index 00000000000..52083770de2
--- /dev/null
+++ b/products/maka/workbench/tests/fixtures/skill-input.tsx
@@ -0,0 +1,90 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { keymap, mount, signal, Text, View } from 'nsh';
+import { Button } from 'nsh/base';
+import { SkillInput } from '../../app/SkillInput';
+import { SkillMessage } from '../../app/SkillMessage';
+import type { ComposerEditor } from '../../app/ComposerEditor';
+import type { Row } from '../../app/history';
+
+mount(() => {
+  const initial = '前😀 /skill:review 后';
+  const draft = signal(initial);
+  const selected = signal({ start: 0, end: 0 });
+  const submitted = signal('');
+  const height = signal(0);
+  const ready = signal(false);
+  const appShortcut = signal(false);
+  keymap.bind('mod+n', () => appShortcut.set(true), { when: 'always' });
+  let editor: ComposerEditor | undefined;
+  return (
+    <View style={{ width: 600, gap: 8 }}>
+      <View
+        style={{ maxHeight: 144, minHeight: 24 }}
+        onLayout={({ bounds }) => height.set(bounds.size.height)}
+      >
+        <SkillInput
+          ref={(node) => {
+            editor = node;
+            node.bindKey('tab', () => {
+              if (node.composing()) return;
+              node.replaceRange({
+                start: selected().start,
+                end: selected().end,
+                text: '/skill:fix ',
+                expectedText: draft(),
+                expectedSelection: selected(),
+              });
+            });
+            ready.set(true);
+          }}
+          testID="draft-field"
+          accessibilityLabel="Draft"
+          value={draft()}
+          readonly={false}
+          autoFocus
+          placeholder="Message"
+          onChange={({ value }) => draft.set(value)}
+          onSelectionChange={(range) => selected.set(range)}
+          onSubmit={({ text }) => submitted.set(text)}
+          style={{ flexShrink: 1 }}
+        />
+      </View>
+      <Text>{`Source ${JSON.stringify(draft())}`}</Text>
+      <Text>{`Selection ${selected().start}:${selected().end}`}</Text>
+      <Text>{`Submitted ${JSON.stringify(submitted())}`}</Text>
+      <Text>{`Height ${height()}`}</Text>
+      <Text>{ready() ? 'Editor ready' : 'Starting editor'}</Text>
+      <Text>{appShortcut() ? 'App shortcut received' : 'App shortcut idle'}</Text>
+      <Button
+        accessibilityLabel="Reset"
+        onPress={() => {
+          draft.set('');
+          editor?.focus();
+        }}
+      >
+        <Text>Reset</Text>
+      </Button>
+      <View style={{ width: 500 }}>
+        <SkillMessage row={() => ({ text: initial }) as Row} sourceId="fixture/message" />
+      </View>
+    </View>
+  );
+});
diff --git a/products/maka/workbench/tests/skill-token.test.mjs b/products/maka/workbench/tests/skill-token.test.mjs
new file mode 100644
index 00000000000..b540ecf2d2d
--- /dev/null
+++ b/products/maka/workbench/tests/skill-token.test.mjs
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { hasSkillToken, skillTextGroups } from '../app/skillTokenText.ts';
+
+test('skill messages join adjacent Unicode chunks and preserve gaps and source addresses', () => {
+  const groups = skillTextGroups([
+    { offset: 0, text: '前😀 /ski' },
+    { offset: 12, text: 'll:review 后' },
+    { offset: 100, text: 'suffix /skill:fix' },
+  ]);
+  assert.deepEqual(groups, [
+    { offset: 0, text: '前😀 /skill:review 后' },
+    { offset: 100, text: 'suffix /skill:fix' },
+  ]);
+  assert.equal(groups.every(hasSkillToken), true);
+});
+
+test('skill messages require a known invocation boundary', () => {
+  for (const group of [
+    { offset: 0, text: 'x/skill:no' },
+    { offset: 0, text: '/skill:' },
+    { offset: 80, text: '/skill:unknown-boundary' },
+  ])
+    assert.equal(hasSkillToken(group), false, JSON.stringify(group));
+  for (const group of [
+    { offset: 0, text: '/skill:yes-2.0_' },
+    { offset: 80, text: ' /skill:known-boundary' },
+    { offset: 0, text: '前\u3000/skill:one\n/skill:two' },
+  ])
+    assert.equal(hasSkillToken(group), true, JSON.stringify(group));
+  const groups = skillTextGroups([
+    { offset: 0, text: '/ski' },
+    { offset: 80, text: 'll:no' },
+  ]);
+  assert.equal(groups.some(hasSkillToken), false);
+});
diff --git a/scripts/ci/suites.mjs b/scripts/ci/suites.mjs
index ea8dbc4f89f..cb6db63b10e 100644
--- a/scripts/ci/suites.mjs
+++ b/scripts/ci/suites.mjs
@@ -185,7 +185,7 @@ export const suites = {
       '--lib',
     ],
     filter:
-      'test(native::tests::animated_props_) | test(=input::tests::nonpressable_focusable_views_join_native_stops_without_stealing_presses) | test(=tests::windows) | test(kitty::tests::)',
+      'test(native::tests::animated_props_) | test(=input::tests::nonpressable_focusable_views_join_native_stops_without_stealing_presses) | test(=text_input::tests::shortcuts_wait_for_focus_even_without_queued_text) | test(=tests::windows) | test(kitty::tests::)',
   },
   'windows-desktop': {
     workspace: 'root',
diff --git a/skills/maka-plugin-authoring/assets/composer-ui/index.tsx b/skills/maka-plugin-authoring/assets/composer-ui/index.tsx
index 784d81ff983..5eaf8d19dbc 100644
--- a/skills/maka-plugin-authoring/assets/composer-ui/index.tsx
+++ b/skills/maka-plugin-authoring/assets/composer-ui/index.tsx
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-import { effect, inputAction, signal, Text, View } from 'nsh';
+import { effect, inputAction, keymap, signal, Text, View } from 'nsh';
 import type { InputRef, JSX } from 'nsh';
 import { Button, Input } from 'nsh/base';
 import type { ComposerViewInput, UiActivation, UiEmbeddedViewProps } from '@maka-agent/plugin-sdk';
@@ -102,7 +102,11 @@ function Composer(props: UiEmbeddedViewProps<ComposerViewInput<JSX.Element>, JSX
               <Input
                 ref={(node) => {
                   editor.set(node);
-                  input.attach(node);
+                  input.attach({
+                    focus: () => node.focus(),
+                    bindKey: (key, action) =>
+                      keymap.bind(key, action, { when: 'always', within: node }),
+                  });
                 }}
                 value={session.draft()}
                 readonly={blocked()}
diff --git a/third-party/nsh/crates/gpui/nsh-platform-gpui/src/text_input.rs b/third-party/nsh/crates/gpui/nsh-platform-gpui/src/text_input.rs
index 37deead7ff2..2aedbae0675 100644
--- a/third-party/nsh/crates/gpui/nsh-platform-gpui/src/text_input.rs
+++ b/third-party/nsh/crates/gpui/nsh-platform-gpui/src/text_input.rs
@@ -1056,8 +1056,8 @@ pub(crate) fn engine_caught_up(surface: &Rc<Surface>) {
     }
 }
 
-/// Keeps editing keys and their releases behind the text waiting for the
-/// next field. Character keys deliver their text through the input method.
+/// Keeps editing keys and shortcuts behind an unsettled focus transition
+/// or queued text. Character keys deliver text through the input method.
 pub(crate) fn hold_key(surface: &Surface, event: &KeyEvent) -> bool {
     let m = event.modifiers;
     let edits = matches!(
@@ -1079,12 +1079,13 @@ pub(crate) fn hold_key(surface: &Surface, event: &KeyEvent) -> bool {
     if (event.down && !(edits || chord)) || !armed(surface) {
         return false;
     }
+    let waiting_for_engine = behind(surface);
     FOCUS.with(|f| {
         let mut map = f.borrow_mut();
         let Some(focus) = map.get_mut(&surface.key()) else {
             return false;
         };
-        if focus.pending.is_empty() {
+        if focus.pending.is_empty() && !waiting_for_engine {
             return false;
         }
         if !event.down
@@ -2930,6 +2931,51 @@ mod blink {
 mod tests {
     use super::*;
 
+    #[test]
+    fn shortcuts_wait_for_focus_even_without_queued_text() {
+        let surface = Surface::new(nsh_engine::Environment::default());
+        FOCUS.with(|focuses| {
+            focuses.borrow_mut().insert(
+                surface.key(),
+                Focus {
+                    armed: true,
+                    after: 1,
+                    ..Default::default()
+                },
+            );
+        });
+        let mut shortcut = KeyEvent {
+            vk: 0x55,
+            down: true,
+            repeat: false,
+            modifiers: Modifiers {
+                ctrl: true,
+                ..Default::default()
+            },
+        };
+        assert!(
+            hold_key(&surface, &shortcut),
+            "shortcut bypassed the pending focus acknowledgement"
+        );
+        shortcut.down = false;
+        assert!(
+            hold_key(&surface, &shortcut),
+            "the held shortcut lost its key release"
+        );
+        FOCUS.with(|focuses| focuses.borrow_mut().get_mut(&surface.key()).unwrap().after = 0);
+        engine_caught_up(&surface);
+        assert!(
+            !has_pending(&surface),
+            "the acknowledged focus did not replay its shortcuts"
+        );
+        shortcut.down = true;
+        assert!(
+            !hold_key(&surface, &shortcut),
+            "a settled focus kept delaying shortcuts"
+        );
+        surface_stopped(surface.key());
+    }
+
     #[test]
     fn alignment() {
         let mut c = InputConfig::default();
diff --git a/third-party/nsh/crates/nsh-base/src/rich_editor/view/controller.rs b/third-party/nsh/crates/nsh-base/src/rich_editor/view/controller.rs
index 15c8289147b..ac3f51dec6f 100644
--- a/third-party/nsh/crates/nsh-base/src/rich_editor/view/controller.rs
+++ b/third-party/nsh/crates/nsh-base/src/rich_editor/view/controller.rs
@@ -323,12 +323,20 @@ impl Rv {
                 }
             });
         });
+        let editable = {
+            let rv = self.clone();
+            computed(move || {
+                rv.notified.get();
+                rv.props.editable.get();
+                rv.editable()
+            })
+        };
         let rv = self.clone();
         effect(move || {
-            if !rv.focused.get() {
+            if !rv.focused.get() || rv.composition.get().is_some() {
                 return;
             }
-            for spec in keys::key_table() {
+            for spec in keys::key_table(editable.get()) {
                 let rv = rv.clone();
                 let event = spec.event.clone();
                 on_key_with(
@@ -662,8 +670,7 @@ impl Rv {
         if let Some(held) = held {
             self.sink_edited(&held);
         }
-        self.composition
-            .set((composing && !text.is_empty()).then(|| text.to_owned()));
+        self.composition.set(composing.then(|| text.to_owned()));
     }
 
     /// A key the sink reports itself (soft keyboards: Backspace in an
diff --git a/third-party/nsh/crates/nsh-base/src/rich_editor/view/keys.rs b/third-party/nsh/crates/nsh-base/src/rich_editor/view/keys.rs
index 466d1eaf652..744877100ad 100644
--- a/third-party/nsh/crates/nsh-base/src/rich_editor/view/keys.rs
+++ b/third-party/nsh/crates/nsh-base/src/rich_editor/view/keys.rs
@@ -56,8 +56,19 @@ struct Mods {
 }
 
 /// Every keystroke the view binds on this platform.
-pub(crate) fn key_table() -> Vec<KeySpec> {
-    key_table_for(apple_keys(), reserved_key_os())
+pub(crate) fn key_table(editable: bool) -> Vec<KeySpec> {
+    let apple = apple_keys();
+    let mut table = key_table_for(apple, reserved_key_os());
+    if !editable {
+        table.retain(|spec| {
+            movement_for(&spec.event, apple).is_some()
+                || (spec.event.mod_key
+                    && !spec.event.alt
+                    && !spec.event.shift
+                    && matches!(spec.event.key.as_str(), "a" | "c" | "x"))
+        });
+    }
+    table
 }
 
 fn key_table_for(apple: bool, reserved_os: Os) -> Vec<KeySpec> {
@@ -90,7 +101,7 @@ fn key_table_for(apple: bool, reserved_os: Os) -> Vec<KeySpec> {
         for m in combos.iter().filter(|m| m.ctrl || m.cmd) {
             let s = c.to_string();
             // Pastes are the native input's (an event with the text).
-            if c == 'v' && !m.shift && !m.alt && (if apple { m.cmd && !m.ctrl } else { m.ctrl }) {
+            if c == 'v' && !m.alt && (if apple { m.cmd && !m.ctrl } else { m.ctrl }) {
                 continue;
             }
             let key = if m.shift && c.is_ascii_alphabetic() {
@@ -242,6 +253,7 @@ mod tests {
             assert!(find(&table, "ctrl+x").event.mod_key);
             assert!(find(&table, "ctrl+a").event.mod_key);
             assert!(!table.iter().any(|s| s.keystroke == "ctrl+v"));
+            assert!(!table.iter().any(|s| s.keystroke == "ctrl+shift+v"));
             assert!(!table.iter().any(|s| s.event.meta));
             assert_eq!(table.iter().any(|s| s.keystroke == "ctrl+q"), os == Os::Web);
         }
@@ -260,6 +272,7 @@ mod tests {
             assert!(find(&table, "cmd+x").event.mod_key);
             assert!(!find(&table, "ctrl+c").event.mod_key);
             assert!(!table.iter().any(|s| s.keystroke == "cmd+v"));
+            assert!(!table.iter().any(|s| s.keystroke == "cmd+shift+v"));
             assert!(!find(&table, "ctrl+v").event.mod_key);
             assert_eq!(table.iter().any(|s| s.keystroke == "cmd+q"), os == Os::Web);
         }
diff --git a/third-party/nsh/crates/nsh-base/src/rich_editor/view/render.rs b/third-party/nsh/crates/nsh-base/src/rich_editor/view/render.rs
index 74b8787c77e..1ab99af4b84 100644
--- a/third-party/nsh/crates/nsh-base/src/rich_editor/view/render.rs
+++ b/third-party/nsh/crates/nsh-base/src/rich_editor/view/render.rs
@@ -1310,11 +1310,7 @@ fn sink(rv: Rv) -> impl IntoElement {
         .top(move || Length::from(at.get().y))
         .w(px(1.0))
         .h(px(SINK_HEIGHT))
-        .pointer_events(if is_terminal() {
-            PointerEvents::BoxNone
-        } else {
-            PointerEvents::None
-        })
+        .pointer_events(PointerEvents::BoxNone)
         .p_0()
         .border(px(0.0))
         .bg(AdaptiveColor::TRANSPARENT)
diff --git a/third-party/nsh/crates/nsh-base/tests/base/rich_editor/typing.rs b/third-party/nsh/crates/nsh-base/tests/base/rich_editor/typing.rs
index 9de286c7ecb..3f6754b3a98 100644
--- a/third-party/nsh/crates/nsh-base/tests/base/rich_editor/typing.rs
+++ b/third-party/nsh/crates/nsh-base/tests/base/rich_editor/typing.rs
@@ -339,6 +339,98 @@ fn backspace_at_a_paragraph_start_joins_into_the_previous() {
 
 // Composition.
 
+#[test]
+fn composition_leaves_candidate_keys_to_the_native_input_method() {
+    use nsh_core::{
+        MountItem, ViewKind,
+        keymap::{KeyMatch, Keystroke},
+    };
+    use std::time::Instant;
+
+    let (engine, batches) =
+        nsh_testing::start(EngineConfig::new(Root::new::<Harness>(|| HarnessProps {
+            session: Some(session(paragraphs(&["ab"]))),
+        })))
+        .unwrap();
+    let deadline = Instant::now() + Duration::from_secs(5);
+    let sink = 'mounted: loop {
+        let batch = batches
+            .recv_timeout(deadline.saturating_duration_since(Instant::now()))
+            .unwrap();
+        for item in batch.items {
+            if let MountItem::Create {
+                id,
+                kind: ViewKind::Input,
+            } = item
+            {
+                break 'mounted id;
+            }
+        }
+    };
+    let control = engine.control();
+    control.dispatch_event(sink, EventKind::Focus, EventPayload::None);
+    let next_bindings = || {
+        let deadline = Instant::now() + Duration::from_secs(5);
+        loop {
+            let batch = batches
+                .recv_timeout(deadline.saturating_duration_since(Instant::now()))
+                .unwrap();
+            for item in batch.items {
+                if let MountItem::Keymap(table) = item {
+                    return table;
+                }
+            }
+        }
+    };
+    let enter = Keystroke::parse("enter", Os::MacOs).unwrap();
+    // Skip a possible initial table emitted before the input took focus.
+    loop {
+        if matches!(next_bindings().find(enter, true, false), KeyMatch::Fire(_)) {
+            break;
+        }
+    }
+    for preedit in ["", "に"] {
+        control.dispatch_event(
+            sink,
+            EventKind::CompositionChange,
+            EventPayload::Map(vec![
+                ("composing", PayloadValue::Bool(true)),
+                ("text", PayloadValue::Str(preedit.to_owned())),
+            ]),
+        );
+        // Enter, arrows and deletion must reach the native input method,
+        // including when it has started an empty preedit.
+        let table = if preedit.is_empty() {
+            Some(next_bindings())
+        } else {
+            None
+        };
+        if let Some(table) = table {
+            for key in ["enter", "left", "backspace", "escape"] {
+                assert!(
+                    !matches!(
+                        table.find(Keystroke::parse(key, Os::MacOs).unwrap(), true, false),
+                        KeyMatch::Fire(_)
+                    ),
+                    "editor intercepted IME key {key}"
+                );
+            }
+        }
+    }
+    control.dispatch_event(
+        sink,
+        EventKind::CompositionChange,
+        EventPayload::Map(vec![
+            ("composing", PayloadValue::Bool(false)),
+            ("text", PayloadValue::Str(String::new())),
+        ]),
+    );
+    assert!(matches!(
+        next_bindings().find(enter, true, false),
+        KeyMatch::Fire(_)
+    ));
+}
+
 #[test]
 fn composition_shows_its_text_without_changing_the_document() {
     let mut app = start(paragraphs(&["ab"]));
diff --git a/tools/ui-build/src/lib.rs b/tools/ui-build/src/lib.rs
index a4a2e20cdff..2e9781d6a41 100644
--- a/tools/ui-build/src/lib.rs
+++ b/tools/ui-build/src/lib.rs
@@ -122,7 +122,13 @@ pub fn compile(entry: &Path, output: &Path) -> Result<CompiledUi> {
     let entry = fs::canonicalize(entry)?;
     let output = std::path::absolute(output)?;
     let mut host = nsh_core::element::Registry::ui_set("maka/host");
-    host.native_values(&["host", "AttachmentPicker", "TerminalGrid", "UploadIntake"]);
+    host.native_values(&[
+        "host",
+        "AttachmentPicker",
+        "ComposerInput",
+        "TerminalGrid",
+        "UploadIntake",
+    ]);
     let bundled = nsh_bundler::bundle(&nsh_bundler::BundleOptions {
         entry: entry.clone(),
         minify: false,

From ac283a39d9e25dd8e948cb62ab1c21118980ad2d Mon Sep 17 00:00:00 2001
From: M4n5ter <m4n5terrr@gmail.com>
Date: Fri, 6 Nov 2026 18:50:36 +0800
Subject: [PATCH 2/2] fix(composer): preserve native editing and focus behavior

Keep source and selection current across composition, paste and application shortcuts. Cover atomic skill editing through behavioral tests and update native editor consumers.

Generated-by: Codex
---
 packages/plugin-sdk/src/composer-view.ts      |   2 +-
 .../agent/composer/ui/ComposerCompletion.tsx  |  24 +-
 plugins/agent/composer/ui/composerPaste.ts    |  12 +-
 .../agent/conversations/ui/SessionSurface.tsx |   2 +
 .../src/terminal/pixels/tests/rail.rs         |   4 +-
 .../maka/terminal-shell/src/terminal/ui.rs    |   4 +-
 .../tests/fixtures/components.tsx             |   1 +
 .../tests/real_host/attachments.rs            |  50 ++--
 .../tests/real_host/components.rs             |  54 +---
 .../tests/real_host/desktop_new_session.rs    | 176 +++++++----
 .../tests/real_host/keyboard.rs               |   1 +
 .../terminal-shell/tests/real_host/mod.rs     |   6 +-
 .../tests/real_host/resumable.rs              |  26 +-
 .../tests/real_host/send_hold.rs              |   4 +-
 products/maka/workbench/app/SkillInput.tsx    |  38 +--
 .../maka/workbench/app/TerminalInterrupt.tsx  |   1 +
 products/maka/workbench/src/bindings.rs       |   9 +-
 products/maka/workbench/src/composer_input.rs | 138 ++++-----
 .../workbench/src/composer_input/message.rs   |  56 +---
 .../workbench/src/composer_input/model.rs     | 279 ++++++++----------
 products/maka/workbench/src/lib.rs            | 116 ++++----
 .../workbench/tests/fixtures/skill-input.tsx  |  76 +++--
 .../maka/workbench/tests/history.test.mjs     |  14 +
 .../maka/workbench/tests/skill-token.test.mjs |  55 ----
 scripts/ci/suites.mjs                         |   2 +-
 .../assets/composer-ui/index.tsx              |   4 +-
 .../gpui/nsh-platform-gpui/src/navigation.rs  |   4 +-
 .../gpui/nsh-platform-gpui/src/text_input.rs  |  49 +--
 .../src/rich_editor/view/controller.rs        |  16 +
 .../nsh-base/src/rich_editor/view/keys.rs     |   2 -
 .../nsh-base/src/rich_editor/view/mod.rs      |   7 +
 .../nsh-base/src/rich_editor/view/render.rs   |   5 +-
 .../nsh-base/tests/base/rich_editor/typing.rs |  92 ------
 33 files changed, 555 insertions(+), 774 deletions(-)
 delete mode 100644 products/maka/workbench/tests/skill-token.test.mjs

diff --git a/packages/plugin-sdk/src/composer-view.ts b/packages/plugin-sdk/src/composer-view.ts
index 69875e85824..591e3957f25 100644
--- a/packages/plugin-sdk/src/composer-view.ts
+++ b/packages/plugin-sdk/src/composer-view.ts
@@ -44,7 +44,7 @@ import type { UiSubscription } from './workbench.js';
 
 export interface ComposerFocusHandle {
   focus(): void;
-  bindKey(key: string, action: () => void): () => void;
+  bindKey(key: string, action: () => void, options?: { fallback?: boolean }): () => void;
 }
 
 export interface ComposerCommand {
diff --git a/plugins/agent/composer/ui/ComposerCompletion.tsx b/plugins/agent/composer/ui/ComposerCompletion.tsx
index 0eb62c388eb..77b42c285da 100644
--- a/plugins/agent/composer/ui/ComposerCompletion.tsx
+++ b/plugins/agent/composer/ui/ComposerCompletion.tsx
@@ -639,13 +639,9 @@ export function createComposerCompletion(options: Options) {
     if (!target) return;
     const valid = () => current === read && owns(read);
     const unbind = [
-      target.bindKey(
-        'escape',
-        () => {
-          if (valid()) dismiss();
-        },
-        {},
-      ),
+      target.bindKey('escape', () => {
+        if (valid()) dismiss();
+      }),
     ];
     if (loading() || rows().some((item) => !item.disabled)) {
       unbind.push(
@@ -667,15 +663,11 @@ export function createComposerCompletion(options: Options) {
             repeat: true,
           },
         ),
-        target.bindKey(
-          'enter',
-          () => {
-            if (!valid()) return;
-            const item = rows()[index()];
-            if (item) accept(item.action);
-          },
-          {},
-        ),
+        target.bindKey('enter', () => {
+          if (!valid()) return;
+          const item = rows()[index()];
+          if (item) accept(item.action);
+        }),
       );
     }
     return () => unbind.forEach((remove) => remove());
diff --git a/plugins/agent/composer/ui/composerPaste.ts b/plugins/agent/composer/ui/composerPaste.ts
index dee54b4105b..4bdecd1102d 100644
--- a/plugins/agent/composer/ui/composerPaste.ts
+++ b/plugins/agent/composer/ui/composerPaste.ts
@@ -114,14 +114,10 @@ export function createComposerPaste<Owner extends PasteOwner>(options: {
     const controlKeys = keymap.label('mod+v') === keymap.label('ctrl+v');
     const keys = controlKeys ? ['mod+v', 'alt+v', 'ctrl+alt+v'] : ['mod+v'];
     const unbind = keys.map((key) =>
-      node.bindKey(
-        key,
-        () => {
-          const target = capture(owner);
-          if (target) clipboard(target);
-        },
-        {},
-      ),
+      node.bindKey(key, () => {
+        const target = capture(owner);
+        if (target) clipboard(target);
+      }),
     );
     return () => unbind.forEach((remove) => remove());
   });
diff --git a/plugins/agent/conversations/ui/SessionSurface.tsx b/plugins/agent/conversations/ui/SessionSurface.tsx
index d42e51fd227..85384095b27 100644
--- a/plugins/agent/conversations/ui/SessionSurface.tsx
+++ b/plugins/agent/conversations/ui/SessionSurface.tsx
@@ -1576,6 +1576,8 @@ export function createConversationUi(
     for (const unbind of [...unbindKeys.splice(0), ...unbindEditorKeys.splice(0)]) unbind();
   });
   const bindKeys = (within?: ViewRef, input?: ComposerFocusHandle) => {
+    if (input)
+      unbindEditorKeys.push(input.bindKey('ctrl+c', interrupt.interrupt, { fallback: true }));
     const options = within ? { when: 'always' as const, within } : { when: 'always' as const };
     const bind = (key: string, action: () => void) => {
       const unbind = input ? input.bindKey(key, action) : keymap.bind(key, action, options);
diff --git a/products/maka/terminal-shell/src/terminal/pixels/tests/rail.rs b/products/maka/terminal-shell/src/terminal/pixels/tests/rail.rs
index d52ae6bcbc2..dc1c789a4f7 100644
--- a/products/maka/terminal-shell/src/terminal/pixels/tests/rail.rs
+++ b/products/maka/terminal-shell/src/terminal/pixels/tests/rail.rs
@@ -85,7 +85,7 @@ fn every_visible_turn_mark_can_be_clicked_with_cell_coordinates() {
         );
         return;
     }
-    let mut host = Registry::ui_set("maka/host");
+    let mut host = maka_workbench::bindings::ui_registry();
     host.native_values(&["host"]);
     let bundle = nsh_bundler::bundle(&nsh_bundler::BundleOptions {
         entry: std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
@@ -152,7 +152,7 @@ fn check_marks(source: &str) {
                         cx,
                     );
                     view.on_error(move |message| *failed.borrow_mut() = Some(message.to_owned()));
-                    let mut host = Registry::ui_set("maka/host");
+                    let mut host = maka_workbench::bindings::ui_registry();
                     host.value("host", move || {
                         Instance::new(RailHost {
                             active_scale: host_scale.clone(),
diff --git a/products/maka/terminal-shell/src/terminal/ui.rs b/products/maka/terminal-shell/src/terminal/ui.rs
index 5cdb0c32729..b52b3fa2d4f 100644
--- a/products/maka/terminal-shell/src/terminal/ui.rs
+++ b/products/maka/terminal-shell/src/terminal/ui.rs
@@ -571,7 +571,7 @@ mod tests {
 
     fn collapsed_workspace_pages(scenario: &'static str) {
         use nsh_core::platform::{Idiom, Renderer};
-        use nsh_core::prelude::{Instance, Registry, class};
+        use nsh_core::prelude::{Instance, class};
 
         #[class]
         struct Presentation {
@@ -607,7 +607,7 @@ mod tests {
                 thread::yield_now();
             }
         };
-        let mut registry = Registry::ui_set("maka/host");
+        let mut registry = maka_workbench::bindings::ui_registry();
         registry.value("host", move || {
             Instance::new(Presentation {
                 scenario: scenario.into(),
diff --git a/products/maka/terminal-shell/tests/fixtures/components.tsx b/products/maka/terminal-shell/tests/fixtures/components.tsx
index ca441a9fd3c..69755571ff1 100644
--- a/products/maka/terminal-shell/tests/fixtures/components.tsx
+++ b/products/maka/terminal-shell/tests/fixtures/components.tsx
@@ -308,6 +308,7 @@ function CompletionComposer(props: { prediction?: boolean }) {
     <View style={{ flex: 1, justifyContent: 'flex-end' }}>
       <Text>{action()}</Text>
       <Text>{lookup()}</Text>
+      <Text accessibilityLabel={`Draft ${draft()}`}>{draft()}</Text>
       <Composer
         session={() => owner}
         active={() => true}
diff --git a/products/maka/terminal-shell/tests/real_host/attachments.rs b/products/maka/terminal-shell/tests/real_host/attachments.rs
index 5a9e9668d19..78a16b7eb4e 100644
--- a/products/maka/terminal-shell/tests/real_host/attachments.rs
+++ b/products/maka/terminal-shell/tests/real_host/attachments.rs
@@ -23,19 +23,32 @@ use maka_app_client::{Client, Draft};
 
 const ORIGINAL_PNG: &str = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR4nGMQNE5uAAACKAEoAfdvjgAAAABJRU5ErkJggg==";
 
-async fn stored_draft(client: &Client, session: &str, expected: impl Fn(&Draft) -> bool) -> Draft {
+async fn stored_draft(
+    view: &mut AppView,
+    client: &Client,
+    session: &str,
+    expected: impl Fn(&Draft) -> bool,
+) -> Draft {
+    let mut observed = None;
     tokio::time::timeout(support::WAIT_TIMEOUT, async {
         loop {
-            if let Some(draft) = client.load_draft("agent", session, EDITOR).await.unwrap()
-                && expected(&draft)
-            {
-                return draft;
+            support::tick(view);
+            if let Some(draft) = client.load_draft("agent", session, EDITOR).await.unwrap() {
+                if expected(&draft) {
+                    return draft;
+                }
+                observed = Some(draft.text);
             }
             tokio::time::sleep(Duration::from_millis(5)).await;
         }
     })
     .await
-    .expect("the complete attachment draft did not commit")
+    .unwrap_or_else(|_| {
+        panic!(
+            "the complete attachment draft did not commit: {observed:?}; screen: {}",
+            view.snapshot()
+        )
+    })
 }
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
@@ -50,13 +63,11 @@ async fn directory_path_paste_remains_text_in_an_existing_composer() {
     view.handle_event(Event::Paste("查看 ".into()));
     commit_native_events(&mut view).await;
     view.handle_event(Event::Paste(format!("'{}'", directory.display())));
-    wait_view_state(&mut view, |view, _| {
-        view.surface()
-            .input_context()
-            .is_some_and(|input| input.text.as_deref() == Some(expected.as_str()))
+    commit_native_events(&mut view).await;
+    let draft = stored_draft(&mut view, &client, &fixture.session, |draft| {
+        draft.text == expected
     })
     .await;
-    let draft = stored_draft(&client, &fixture.session, |draft| draft.text == expected).await;
     assert!(draft.attachments.is_empty());
     drop(view);
     bindings.close().await.unwrap();
@@ -115,7 +126,8 @@ async fn attachment_only_send_uses_the_selected_bytes_after_the_local_file_chang
     let (mut view, bindings) = fixture.view(client.clone(), Some(fixture.session.clone()));
     wait_editable_composer(&mut view).await;
     view.handle_event(Event::Paste(format!("'{}'", path.display())));
-    let stored = stored_draft(&client, &fixture.session, |draft| {
+    commit_native_events(&mut view).await;
+    let stored = stored_draft(&mut view, &client, &fixture.session, |draft| {
         draft.attachments.len() == 1
     })
     .await;
@@ -124,15 +136,9 @@ async fn attachment_only_send_uses_the_selected_bytes_after_the_local_file_chang
     let dropped = fixture.directory.path().join("dropped image.png");
     std::fs::write(&dropped, &bytes).unwrap();
     wait_editable_composer(&mut view).await;
-    let composer = view.surface().focused().unwrap();
-    view.control().unwrap().dispatch_event(
-        composer,
-        nsh_core::EventKind::FileDrop,
-        nsh_core::EventPayload::FileDrop(vec![
-            reqwest::Url::from_file_path(&dropped).unwrap().into(),
-        ]),
-    );
-    let stored = stored_draft(&client, &fixture.session, |draft| {
+    view.handle_event(Event::Paste(format!("'{}'", dropped.display())));
+    commit_native_events(&mut view).await;
+    let stored = stored_draft(&mut view, &client, &fixture.session, |draft| {
         draft.attachments.len() == 2
     })
     .await;
@@ -177,7 +183,7 @@ async fn attachment_only_send_uses_the_selected_bytes_after_the_local_file_chang
     request.finish().await;
     fixture.idle(&client, &fixture.session).await;
     wait_view(&mut view, |screen| screen.contains("Attachment received")).await;
-    stored_draft(&client, &fixture.session, |draft| {
+    stored_draft(&mut view, &client, &fixture.session, |draft| {
         draft.attachments.is_empty() && draft.text.is_empty()
     })
     .await;
diff --git a/products/maka/terminal-shell/tests/real_host/components.rs b/products/maka/terminal-shell/tests/real_host/components.rs
index 3007aed2289..43824658227 100644
--- a/products/maka/terminal-shell/tests/real_host/components.rs
+++ b/products/maka/terminal-shell/tests/real_host/components.rs
@@ -42,7 +42,7 @@ impl Presentation {
 }
 
 async fn component(scenario: &'static str) -> AppView {
-    let mut registry = Registry::ui_set("maka/host");
+    let mut registry = maka_workbench::bindings::ui_registry();
     registry.value("host", move || {
         Instance::new(Presentation {
             scenario: scenario.into(),
@@ -74,6 +74,12 @@ async fn component(scenario: &'static str) -> AppView {
     view
 }
 
+fn draft_is(view: &AppView, expected: &str) -> bool {
+    view.accessibility_snapshot()
+        .iter()
+        .any(|node| node.label == format!("Draft {expected}"))
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn activity_resumes_following_after_reading_an_expanded_tool() {
     let mut view = component("activity-follow").await;
@@ -179,19 +185,12 @@ async fn composer_slash_command_and_workspace_reference_edit_the_native_draft()
     view.handle_event(TerminalEvent::Paste("/insp".into()));
     support::click_button(&mut view, "/inspect").await;
     wait_view(&mut view, |screen| screen.contains("command:inspect")).await;
-    wait_view_state(&mut view, |view, _| {
-        view.surface()
-            .input_context()
-            .is_some_and(|input| input.text.as_deref() == Some(""))
-    })
-    .await;
+    wait_view_state(&mut view, |view, _| draft_is(view, "")).await;
     view.handle_event(TerminalEvent::Paste("check @docs/Rel".into()));
+    wait_view(&mut view, |screen| screen.contains("files:Rel:ZG9jcw==")).await;
     support::click_button(&mut view, "docs/Release Notes.md").await;
-    wait_view_state(&mut view, |view, screen| {
-        screen.contains("files:Rel:ZG9jcw==")
-            && view.surface().input_context().is_some_and(|input| {
-                input.text.as_deref() == Some("check @\"docs/Release Notes.md\" ")
-            })
+    wait_view_state(&mut view, |view, _| {
+        draft_is(view, "check @\"docs/Release Notes.md\" ")
     })
     .await;
 }
@@ -207,10 +206,7 @@ async fn composer_tab_accepts_prediction_as_an_undoable_draft_then_navigates() {
     )));
     wait_view_state(&mut view, |view, screen| {
         screen.contains("No command")
-            && view
-                .surface()
-                .input_context()
-                .is_some_and(|input| input.text.as_deref() == Some("Review the changes."))
+            && draft_is(view, "Review the changes.")
             && !view
                 .accessibility_snapshot()
                 .iter()
@@ -233,12 +229,7 @@ async fn composer_tab_accepts_prediction_as_an_undoable_draft_then_navigates() {
     )));
     wait_focused_input(&mut view, "Message composer").await;
     shortcut(&mut view, 'z');
-    wait_view_state(&mut view, |view, _| {
-        view.surface()
-            .input_context()
-            .is_some_and(|input| input.text.as_deref() == Some(""))
-    })
-    .await;
+    wait_view_state(&mut view, |view, _| draft_is(view, "")).await;
     view.handle_event(TerminalEvent::Key(KeyEvent::new(
         KeyCode::Tab,
         KeyModifiers::NONE,
@@ -271,10 +262,7 @@ async fn composer_prediction_preserves_reverse_tab_and_escape_restores_forward_t
         KeyModifiers::NONE,
     )));
     wait_focused_input(&mut view, "Message composer").await;
-    assert_eq!(
-        view.surface().input_context().unwrap().text.as_deref(),
-        Some("")
-    );
+    assert!(draft_is(&view, ""));
     wait_enabled_node(&mut view, "Use suggested message").await;
     view.handle_event(TerminalEvent::Key(KeyEvent::new(
         KeyCode::Esc,
@@ -311,12 +299,7 @@ async fn skill_completion_is_inserted_and_backspace_deletes_the_whole_native_chi
     })
     .await;
     support::click_button(&mut view, "Review changes").await;
-    wait_view_state(&mut view, |view, _| {
-        view.surface()
-            .input_context()
-            .is_some_and(|input| input.text.as_deref() == Some("before /skill:review "))
-    })
-    .await;
+    wait_view_state(&mut view, |view, _| draft_is(view, "before /skill:review ")).await;
     view.handle_event(TerminalEvent::Key(KeyEvent::new(
         KeyCode::Backspace,
         KeyModifiers::NONE,
@@ -326,10 +309,5 @@ async fn skill_completion_is_inserted_and_backspace_deletes_the_whole_native_chi
         KeyCode::Backspace,
         KeyModifiers::NONE,
     )));
-    wait_view_state(&mut view, |view, _| {
-        view.surface()
-            .input_context()
-            .is_some_and(|input| input.text.as_deref() == Some("before "))
-    })
-    .await;
+    wait_view_state(&mut view, |view, _| draft_is(view, "before ")).await;
 }
diff --git a/products/maka/terminal-shell/tests/real_host/desktop_new_session.rs b/products/maka/terminal-shell/tests/real_host/desktop_new_session.rs
index 5c93f32103b..f12ec450804 100644
--- a/products/maka/terminal-shell/tests/real_host/desktop_new_session.rs
+++ b/products/maka/terminal-shell/tests/real_host/desktop_new_session.rs
@@ -306,13 +306,20 @@ impl Desktop {
     }
 
     fn key(&self, name: &str, control: bool) {
-        let keystroke = Keystroke {
-            key: name.into(),
-            key_char: None,
-            modifiers: Modifiers {
+        self.key_with(
+            name,
+            Modifiers {
                 control,
                 ..Default::default()
             },
+        );
+    }
+
+    fn key_with(&self, name: &str, modifiers: Modifiers) {
+        let keystroke = Keystroke {
+            key: name.into(),
+            key_char: None,
+            modifiers,
         };
         self.platform
             .dispatch_input(PlatformInput::KeyDown(gpui::KeyDownEvent {
@@ -343,26 +350,24 @@ impl Desktop {
         .await;
     }
 
-    fn copy_input(&self) -> Option<String> {
-        // Outside an editor Ctrl+C interrupts, and its dialog refuses the focus
-        // being waited for.
-        self.platform.text_input_target()?;
+    async fn copy_input(&self) -> String {
+        self.target_after(None).await;
+        let _ = self.platform.take_clipboard_write();
         self.key("a", true);
         self.key("c", true);
-        self.platform
-            .take_clipboard_write()
-            .and_then(|item| item.text())
+        self.until("the selected draft was not copied", || {
+            self.platform
+                .take_clipboard_write()
+                .and_then(|item| item.text())
+        })
+        .await
     }
 
     async fn type_text(&self, text: &str) {
-        let _ = self.platform.take_clipboard_write();
-        self.until("the editor did not accept the draft", || {
-            self.platform.text_input_target()?;
-            self.key("a", true);
-            self.platform.paste(text).unwrap();
-            self.copy_input().filter(|copied| copied == text)
-        })
-        .await;
+        self.target_after(None).await;
+        self.key("a", true);
+        self.platform.paste(text).unwrap();
+        self.expect_text(text).await;
     }
 
     /// Enter does nothing until the typed draft can be sent.
@@ -372,25 +377,15 @@ impl Desktop {
     }
 
     async fn expect_text(&self, text: &str) {
-        let _ = self.platform.take_clipboard_write();
-        self.until("the expected draft did not appear in the editor", || {
-            self.copy_input().filter(|copied| copied == text)
-        })
-        .await;
-    }
-
-    async fn expect_editor_text(&self, expected: &str) {
-        self.until(
-            &format!("the native editor did not contain {expected:?}"),
-            || {
-                self.app
-                    .update(|cx| {
-                        self.window.update(cx, |view, window, cx| {
-                            view.text_for_range(0..u32::MAX as usize, &mut None, window, cx)
-                        })
-                    })
-                    .unwrap()
-                    .filter(|text| text == expected)
+        self.wait(
+            &format!("the expected draft {text:?} did not appear in the editor"),
+            async {
+                loop {
+                    let copied = self.copy_input().await;
+                    if copied == text {
+                        break;
+                    }
+                }
             },
         )
         .await;
@@ -456,6 +451,21 @@ impl Desktop {
         })
     }
 
+    async fn composer_height(
+        &self,
+        stage: &str,
+        ready: impl Fn(gpui::Pixels) -> bool,
+    ) -> gpui::Pixels {
+        self.until(stage, || {
+            let fields = self.controls("Focus message composer");
+            let [field] = fields.as_slice() else {
+                return None;
+            };
+            (field.size.height > px(0.) && ready(field.size.height)).then_some(field.size.height)
+        })
+        .await
+    }
+
     /// Where the window shows the one control labelled `label`, once it does.
     async fn control(&self, label: &str) -> Bounds<gpui::Pixels> {
         self.until(&format!("no single control labelled {label}"), || {
@@ -677,7 +687,7 @@ async fn desktop_remembers_folders_without_restoring_unsent_drafts() {
         .unwrap();
     desktop.target_after(None).await;
     let _ = desktop.platform.take_clipboard_write();
-    assert_eq!(desktop.copy_input().unwrap_or_default(), "");
+    assert!(desktop.controls("Send message").is_empty());
     assert!(
         desktop
             .controls(&format!(
@@ -1313,13 +1323,21 @@ async fn desktop_steering_freezes_each_message_and_queue_is_one_shot() {
 async fn desktop_file_gestures_preserve_drafts_and_stage_an_image() {
     let fixture = images_fixture().await;
     let desktop = Desktop::open(&fixture, &fixture.address).await;
-    let directory = fixture.directory.path().join("未命名文件夹 2");
+    // Observe the wrapped path before copying: Select All would cancel an
+    // insertion whose file intake is still pending.
+    let directory = fixture
+        .directory
+        .path()
+        .join(format!("{}未命名文件夹 2", "x".repeat(220)));
     std::fs::create_dir(&directory).unwrap();
     for (pending, blur) in [(false, false), (false, true), (true, true)] {
-        if pending {
+        let pending_height = if pending {
             desktop.new_draft().await;
             desktop.type_text("查看 ").await;
             desktop.key("right", false);
+            let before = desktop
+                .composer_height("the pending composer did not lay out", |_| true)
+                .await;
             assert!(desktop.app.update(|cx| {
                 desktop
                     .window
@@ -1331,20 +1349,49 @@ async fn desktop_file_gestures_preserve_drafts_and_stage_an_image() {
                     })
                     .unwrap()
             }));
+            let height = desktop
+                .composer_height("the pasted directory did not wrap", |height| {
+                    height > before
+                })
+                .await;
             desktop
-                .expect_editor_text(&format!("查看 {}", directory.display()))
+                .expect_text(&format!("查看 {}", directory.display()))
                 .await;
-        }
+            Some(height)
+        } else {
+            None
+        };
         let original = "前😀待替换 后";
         desktop.type_text(original).await;
-        desktop.app.update(|cx| {
-            desktop
-                .window
-                .update(cx, |view, window, cx| {
-                    view.set_selected_text_range(3..6, window, cx);
-                })
-                .unwrap();
-        });
+        let before = desktop
+            .composer_height("the short draft did not lay out", |height| {
+                pending_height.is_none_or(|pending| height < pending)
+            })
+            .await;
+        desktop.key("home", false);
+        for _ in 0..2 {
+            desktop.key("right", false);
+        }
+        for _ in 0..3 {
+            desktop.key_with(
+                "right",
+                Modifiers {
+                    shift: true,
+                    ..Default::default()
+                },
+            );
+        }
+        let _ = desktop.platform.take_clipboard_write();
+        desktop
+            .until("the replacement range was not selected", || {
+                desktop.key("c", true);
+                desktop
+                    .platform
+                    .take_clipboard_write()
+                    .and_then(|item| item.text())
+                    .filter(|text| text == "待替换")
+            })
+            .await;
         if blur {
             desktop.key("tab", false);
             desktop
@@ -1376,11 +1423,21 @@ async fn desktop_file_gestures_preserve_drafts_and_stage_an_image() {
             })
             .await;
         desktop.drop_paths(vec![directory.clone()], position);
+        let expanded = desktop
+            .composer_height("the dropped directory did not wrap", |height| {
+                height > before
+            })
+            .await;
         let expected = format!("前😀{} 后", directory.display());
-        desktop.expect_editor_text(&expected).await;
+        desktop.expect_text(&expected).await;
         assert_eq!(desktop.sessions().await.len(), 1);
         desktop.key("z", true);
-        desktop.expect_editor_text(original).await;
+        desktop.expect_text(original).await;
+        desktop
+            .composer_height("the restored draft did not shrink", |height| {
+                height < expanded
+            })
+            .await;
     }
     assert_eq!(fixture.request_count.load(Ordering::SeqCst), 0);
     let (path, _) = image_file(&fixture);
@@ -2209,7 +2266,18 @@ async fn desktop_parent_reviews_child_access_and_opens_attributed_sender_beside(
             .controls("Open source conversation beside this one")
             .is_empty()
     );
-    desktop.press("Turn work details").await;
+    desktop
+        .retry(
+            "the completed child work details did not open",
+            || !desktop.controls("Process group").is_empty(),
+            || {
+                let controls = desktop.controls("Turn work details");
+                if controls.len() == 1 {
+                    desktop.press_at(controls[0].center());
+                }
+            },
+        )
+        .await;
     let group = desktop.control("Process group").await;
     desktop.press("Process group").await;
     let message = desktop.control("Agent message").await;
diff --git a/products/maka/terminal-shell/tests/real_host/keyboard.rs b/products/maka/terminal-shell/tests/real_host/keyboard.rs
index 8d92b00f7a0..b59fd67e438 100644
--- a/products/maka/terminal-shell/tests/real_host/keyboard.rs
+++ b/products/maka/terminal-shell/tests/real_host/keyboard.rs
@@ -135,6 +135,7 @@ async fn editor_copy_and_undo_precede_interrupt_and_ctrl_c_requires_confirming_t
                 screen.contains("Stop the current task?")
             })
             .await;
+            commit_native_events(&mut view).await;
             // A second Ctrl+C dismisses the choice; it cannot confirm Stop.
             shortcut(&mut view, 'c');
             wait_view(&mut view, |screen| {
diff --git a/products/maka/terminal-shell/tests/real_host/mod.rs b/products/maka/terminal-shell/tests/real_host/mod.rs
index 5a090ad421a..19feb0fc678 100644
--- a/products/maka/terminal-shell/tests/real_host/mod.rs
+++ b/products/maka/terminal-shell/tests/real_host/mod.rs
@@ -76,6 +76,7 @@ async fn wait_focused_input(view: &mut AppView, label: &str) {
         })
     })
     .await;
+    commit_native_events(view).await;
 }
 
 async fn editable(view: &mut AppView, label: &str) {
@@ -198,10 +199,7 @@ async fn product_composition_sends_streams_and_restores_history_with_a_later_dra
     })
     .await;
     wait_editable_composer(&mut view).await;
-    assert_eq!(
-        view.surface().input_context().unwrap().text.as_deref(),
-        Some("A later draft remains private")
-    );
+    support::wait_draft(&reopened, &fixture.session, "A later draft remains private").await;
     support::click_button(&mut view, "Copy message").await;
     wait_view(&mut view, |screen| screen.contains("Message copied")).await;
     assert_eq!(fixture.request_count.load(Ordering::SeqCst), 1);
diff --git a/products/maka/terminal-shell/tests/real_host/resumable.rs b/products/maka/terminal-shell/tests/real_host/resumable.rs
index 283910bdf9a..f1dcda2fed8 100644
--- a/products/maka/terminal-shell/tests/real_host/resumable.rs
+++ b/products/maka/terminal-shell/tests/real_host/resumable.rs
@@ -18,9 +18,11 @@
  */
 
 use super::*;
+use maka_app_client::Client;
 use maka_plugin_core::operation::{OperationOutcome, Receipt};
 
-async fn replace_input(view: &mut AppView, label: &str, text: &str) {
+async fn replace_draft(view: &mut AppView, client: &Client, session: &str, text: &str) {
+    let label = "Message composer";
     wait_enabled_node(view, label).await;
     tab_to_label(view, label).await;
     wait_focused_input(view, label).await;
@@ -33,12 +35,8 @@ async fn replace_input(view: &mut AppView, label: &str, text: &str) {
     } else {
         assert!(view.handle_event(Event::Paste(text.into())));
     }
-    wait_view_state(view, |view, _| {
-        view.surface()
-            .input_context()
-            .is_some_and(|context| context.text.as_deref() == Some(text))
-    })
-    .await;
+    commit_native_events(view).await;
+    support::wait_draft(client, session, text).await;
 }
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
@@ -56,7 +54,13 @@ async fn composer_continues_an_interrupted_run_and_preserves_draft_send_priority
     .await;
     let (mut view, bindings) = fixture.view(client.clone(), Some(fixture.session.clone()));
     wait_editable_composer(&mut view).await;
-    replace_input(&mut view, "Message composer", "ORIGINAL_RESUME_INPUT").await;
+    replace_draft(
+        &mut view,
+        &client,
+        &fixture.session,
+        "ORIGINAL_RESUME_INPUT",
+    )
+    .await;
     support::click_button(&mut view, "Send message").await;
     support::wait_enabled_button(&mut view, "Stop response").await;
     let mut request = fixture.next_request().await;
@@ -76,7 +80,7 @@ async fn composer_continues_an_interrupted_run_and_preserves_draft_send_priority
     support::wait_enabled_button(&mut view, "Continue response").await;
     fixture.idle(&client, &fixture.session).await;
     drop(request);
-    replace_input(&mut view, "Message composer", "UNSENT_NEW_REQUEST").await;
+    replace_draft(&mut view, &client, &fixture.session, "UNSENT_NEW_REQUEST").await;
     support::wait_enabled_button(&mut view, "Send message").await;
     assert!(
         !view
@@ -84,7 +88,7 @@ async fn composer_continues_an_interrupted_run_and_preserves_draft_send_priority
             .iter()
             .any(|node| node.label == "Continue response")
     );
-    replace_input(&mut view, "Message composer", "").await;
+    replace_draft(&mut view, &client, &fixture.session, "").await;
     support::click_button(&mut view, "Continue response").await;
     support::wait_enabled_button(&mut view, "Stop response").await;
     let mut continuation = fixture.next_request().await;
@@ -106,7 +110,7 @@ async fn composer_continues_an_interrupted_run_and_preserves_draft_send_priority
         .await
         .unwrap();
     assert_ne!(resumed["run"]["turnId"], source_turn);
-    replace_input(&mut view, "Message composer", "UNSENT_WHILE_RUNNING").await;
+    replace_draft(&mut view, &client, &fixture.session, "UNSENT_WHILE_RUNNING").await;
     support::wait_enabled_button(&mut view, "Send message").await;
     shortcut(&mut view, 'p');
     select_command(&mut view, "Add to queue").await;
diff --git a/products/maka/terminal-shell/tests/real_host/send_hold.rs b/products/maka/terminal-shell/tests/real_host/send_hold.rs
index 249bcaa9ef7..a15bf320ab3 100644
--- a/products/maka/terminal-shell/tests/real_host/send_hold.rs
+++ b/products/maka/terminal-shell/tests/real_host/send_hold.rs
@@ -77,7 +77,9 @@ async fn a_rejected_send_preserves_its_snapshot_and_the_next_draft() {
     support::click_button(&mut view, "Messages").await;
     // Check the composer only once the send has settled.
     let screen = wait_view_state(&mut view, |view, screen| {
-        screen.contains("/skill:missing-fixture first")
+        view.accessibility_snapshot()
+            .iter()
+            .any(|node| node.label == sent)
             && screen.contains("next draft")
             && screen.contains("Retry")
             && view
diff --git a/products/maka/workbench/app/SkillInput.tsx b/products/maka/workbench/app/SkillInput.tsx
index 7b0d95ed624..a2ae9a411e6 100644
--- a/products/maka/workbench/app/SkillInput.tsx
+++ b/products/maka/workbench/app/SkillInput.tsx
@@ -17,22 +17,14 @@
  * under the License.
  */
 
-import { ComposerInput } from 'maka/host';
+import { ComposerInput, type ComposerInputRef, type ComposerInputState } from 'maka/host';
 import { cleanup, effect, keymap, signal, untracked, View } from 'nsh';
-import type { Bounds, CaretEvent, InputRef, StyleProp, ViewRef, TextStyle } from 'nsh';
+import type { CaretEvent, StyleProp, TextStyle } from 'nsh';
 import type { ComposerEditor, EditorKeyOptions } from './ComposerEditor';
 import { lucide } from './lucide';
 import { C, bodyTextStyle } from './ui';
 
 type Selection = { start: number; end: number };
-type NativeEditor = {
-  focus(): void;
-  blur(): void;
-  status(): Promise<{ readonly composing: boolean; readonly selection: Selection }>;
-  caretBounds(): Promise<Bounds | null>;
-  contentHeight(): Promise<number | null>;
-  replaceRange: InputRef['replaceRange'];
-};
 type Props = {
   ref?(node: ComposerEditor): void;
   testID?: string;
@@ -60,11 +52,9 @@ type Binding = { key: string; action: () => void; options?: EditorKeyOptions };
 
 /** Product-owned plain-text composer; skills are inline atoms in the existing rich editor. */
 export function SkillInput(props: Props) {
-  const native = signal<NativeEditor | null>(null);
-  const scope = signal<ViewRef | null>(null);
-  const status = signal<{ readonly composing: boolean; readonly selection: Selection } | null>(
-    null,
-  );
+  const native = signal<ComposerInputRef | null>(null);
+  const status = signal<ComposerInputState | null>(null);
+  const composition = signal(false);
   const valueCount = signal(0);
   const height = signal(bodyTextStyle.lineHeight);
   let alive = true;
@@ -92,9 +82,9 @@ export function SkillInput(props: Props) {
     untracked(refreshKeys);
   });
   const bindKey = (key: string, action: () => void, options?: EditorKeyOptions) => {
-    const target = scope();
+    const target = native()?.node;
     // These keystrokes reach the native input instead of RichEditor's key table.
-    if (key === 'mod+v' || key === 'alt+v')
+    if (key === 'mod+v' || key === 'alt+v' || key === 'tab')
       return target
         ? keymap.bind(key, action, { when: 'always', within: target, ...options })
         : () => {};
@@ -128,15 +118,19 @@ export function SkillInput(props: Props) {
   });
   effect(() => {
     const node = native();
-    const anchor = scope();
     const state = status();
-    if (!node || !anchor || !state) return;
+    if (!node || !state) return;
     untracked(() => {
       props.ref?.({
-        anchor,
+        anchor: node.node,
         focus: () => node.focus(),
         blur: () => node.blur(),
-        composing: () => state.composing,
+        composing: () => {
+          if (!alive) return false;
+          // Subscribe to transitions while reading the native state for action guards.
+          composition();
+          return state.composing;
+        },
         replaceRange: (request) => node.replaceRange(request),
         bindKey,
       });
@@ -177,7 +171,6 @@ export function SkillInput(props: Props) {
   };
   return (
     <View
-      ref={(node) => scope.set(node)}
       style={[props.style, { height: height(), minHeight: bodyTextStyle.lineHeight }]}
       onFileDrop={props.onFileDrop}
       onFileDragEnter={props.onFileDragEnter}
@@ -215,6 +208,7 @@ export function SkillInput(props: Props) {
           props.onSelectionChange?.(event);
           caretMoved();
         }}
+        onCompositionChange={({ composing }) => composition.set(composing)}
         onSubmit={props.onSubmit}
         onKey={key}
         onPasteFiles={(event) =>
diff --git a/products/maka/workbench/app/TerminalInterrupt.tsx b/products/maka/workbench/app/TerminalInterrupt.tsx
index 33a08a9af0d..a509b5450ff 100644
--- a/products/maka/workbench/app/TerminalInterrupt.tsx
+++ b/products/maka/workbench/app/TerminalInterrupt.tsx
@@ -103,6 +103,7 @@ export function createTerminalInterrupt(options: {
     if (timer !== undefined) clearTimeout(timer);
   });
   return {
+    interrupt,
     prompt,
     confirmation,
     dismiss,
diff --git a/products/maka/workbench/src/bindings.rs b/products/maka/workbench/src/bindings.rs
index 11e9f00881c..b72d7d3bde3 100644
--- a/products/maka/workbench/src/bindings.rs
+++ b/products/maka/workbench/src/bindings.rs
@@ -219,6 +219,14 @@ pub fn ui_set_description() -> nsh_core::element::description::SetDescription {
 }
 
 fn registry(make_host: impl Fn() -> Instance<ApplicationHost> + Send + Sync + 'static) -> Registry {
+    let mut registry = ui_registry();
+    registry.value("host", make_host);
+    registry
+}
+
+/// Native workbench components and classes, independent of the Host connection.
+#[must_use]
+pub fn ui_registry() -> Registry {
     let mut registry = Registry::ui_set("maka/host");
     registry.register::<crate::composer_input::ComposerInput>();
     registry.class::<crate::composer_input::ComposerInputState>();
@@ -228,7 +236,6 @@ fn registry(make_host: impl Fn() -> Instance<ApplicationHost> + Send + Sync + 's
     registry.class::<uploads::StagedFile>();
     registry.class::<uploads::StagedClipboard>();
     registry.class::<ui_services::UiScope>();
-    registry.value("host", make_host);
     registry
 }
 
diff --git a/products/maka/workbench/src/composer_input.rs b/products/maka/workbench/src/composer_input.rs
index cd78b4ec0fb..e9d804233aa 100644
--- a/products/maka/workbench/src/composer_input.rs
+++ b/products/maka/workbench/src/composer_input.rs
@@ -107,6 +107,15 @@ impl Events {
             .emit(ComposerInputEvent::Change(ComposerChange { value, count }));
     }
 
+    fn flush_state(&self, state: &EditorState) {
+        let projection = model::Projection::new(state.doc());
+        self.changed(projection.source.clone());
+        self.cx.emit(ComposerInputEvent::SelectionChange(selection(
+            state,
+            &projection,
+        )));
+    }
+
     fn apply_value(
         &self,
         session: &EditorSession,
@@ -194,8 +203,6 @@ pub(crate) struct ComposerSubmit {
 #[derive(Clone, Debug, Default, PartialEq, JsObject)]
 pub(crate) struct ComposerKey {
     pub key: String,
-    pub text: String,
-    pub selection: ComposerSelection,
 }
 
 #[derive(Clone, Debug, PartialEq, Event)]
@@ -204,6 +211,8 @@ pub(crate) enum ComposerInputEvent {
     Change(ComposerChange),
     #[args(event)]
     SelectionChange(ComposerSelection),
+    #[args(composing)]
+    CompositionChange(bool),
     #[args(event)]
     Submit(ComposerSubmit),
     #[args(event)]
@@ -331,7 +340,7 @@ impl PluginSpec for ComposerBehavior {
         if !trs.iter().any(|tr| tr.doc_changed() || tr.selection_set()) {
             return None;
         }
-        model::tokenize(new, false)
+        model::tokenize(new)
     }
 
     fn handle_key_down(
@@ -352,13 +361,10 @@ impl PluginSpec for ComposerBehavior {
                 if Keystroke::parse_with(&binding.key, apple)
                     .is_ok_and(|candidate| candidate == stroke)
                 {
-                    let projection = model::Projection::new(state.doc());
-                    self.events.changed(projection.source.clone());
-                    self.events.cx.emit(ComposerInputEvent::Key(ComposerKey {
-                        key: binding.key,
-                        text: projection.source.clone(),
-                        selection: selection(state, &projection),
-                    }));
+                    self.events.flush_state(state);
+                    self.events
+                        .cx
+                        .emit(ComposerInputEvent::Key(ComposerKey { key: binding.key }));
                     return true;
                 }
             }
@@ -403,9 +409,16 @@ impl PluginSpec for ComposerBehavior {
         slice: &Slice,
         dispatch: &mut dyn FnMut(Transaction),
     ) -> bool {
+        let text = model::fragment_source(&slice.content);
+        if let Some(uris) = nsh_core::platform::clipboard::files_from_text(&text) {
+            self.events.flush_state(state);
+            let mut paste = RichEditorPastedFiles::default();
+            paste.uris = uris;
+            self.events.cx.emit(ComposerInputEvent::PasteFiles(paste));
+            return true;
+        }
         let projection = model::Projection::new(state.doc());
         let selected = selection(state, &projection);
-        let text = model::fragment_source(&slice.content);
         let Some(mut tr) = model::replace(state, selected.start, selected.end, &text) else {
             return false;
         };
@@ -414,6 +427,10 @@ impl PluginSpec for ComposerBehavior {
         true
     }
 
+    fn transform_pasted_html(&self, _state: &EditorState, _html: String) -> String {
+        String::new()
+    }
+
     fn clipboard_text_parser(
         &self,
         state: &EditorState,
@@ -477,7 +494,7 @@ fn state(
     plugins: Vec<Plugin>,
     annotation: &message::Source,
 ) -> EditorState {
-    let doc = annotation.annotate(schema, model::document(schema, source, true));
+    let doc = annotation.annotate(schema, model::document(schema, source));
     let end = model::Projection::new(&doc)
         .doc_at(source.encode_utf16().count() as u32, true)
         .expect("the source end is a valid caret");
@@ -556,42 +573,41 @@ pub(crate) fn ComposerInput(
     }
     let changed = session.clone();
     let selected = session.clone();
-    let blurred = session.clone();
-    let (change_schema, change_plugins, change_events) =
-        (schema.clone(), plugins.clone(), events.clone());
-    view().flex_1().child(
-        rich_editor()
-            .editor(session)
-            .flex_1()
-            .editable(move || !props.read_only.get())
-            .placeholder(move || Some(props.placeholder.get().into()))
-            .accessibility_label(move || Some(props.accessibility_label.get().into()))
-            .styles(move || props.styles.get())
-            .on_change(move |_: &_| {
-                change_events.changed(model::source(changed.state().doc()));
-                change_events.apply_pending(
-                    &changed,
-                    &change_schema,
-                    &change_plugins,
-                    &source(props),
-                );
-            })
-            .on_selection_change(move |_: &_| {
-                let state = selected.state();
-                cx.emit(ComposerInputEvent::SelectionChange(selection(
-                    &state,
-                    &model::Projection::new(state.doc()),
-                )));
-            })
-            .on_focus(move || cx.emit(ComposerInputEvent::Focus))
-            .on_blur(move || {
-                events.apply_pending(&blurred, &schema, &plugins, &source(props));
-                cx.emit(ComposerInputEvent::Blur);
-            })
-            .on_paste_files(move |event: &RichEditorPastedFiles| {
-                cx.emit(ComposerInputEvent::PasteFiles(event.clone()))
-            }),
-    )
+    let composing = session.clone();
+    let change_events = events.clone();
+    let pasted = session.clone();
+    let paste_events = events.clone();
+    rich_editor()
+        .editor(session)
+        .flex_1()
+        .editable(move || !props.read_only.get())
+        .tab_navigation(true)
+        .placeholder(move || Some(props.placeholder.get().into()))
+        .accessibility_label(move || Some(props.accessibility_label.get().into()))
+        .styles(move || props.styles.get())
+        .on_change(move |_: &_| {
+            change_events.changed(model::source(changed.state().doc()));
+        })
+        .on_selection_change(move |_: &_| {
+            let state = selected.state();
+            cx.emit(ComposerInputEvent::SelectionChange(selection(
+                &state,
+                &model::Projection::new(state.doc()),
+            )));
+        })
+        .on_composition_change(move |active: &bool| {
+            if !active {
+                events.changed(model::source(composing.state().doc()));
+                events.apply_pending(&composing, &schema, &plugins, &source(props));
+            }
+            cx.emit(ComposerInputEvent::CompositionChange(*active));
+        })
+        .on_focus(move || cx.emit(ComposerInputEvent::Focus))
+        .on_blur(move || cx.emit(ComposerInputEvent::Blur))
+        .on_paste_files(move |event: &RichEditorPastedFiles| {
+            paste_events.flush_state(&pasted.state());
+            cx.emit(ComposerInputEvent::PasteFiles(event.clone()))
+        })
 }
 
 fn source(props: ComposerInputProps) -> message::Source {
@@ -600,29 +616,3 @@ fn source(props: ComposerInputProps) -> message::Source {
         offset: props.source_offset.get(),
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use nsh_base::rich_editor::extensions::history::undo_depth;
-
-    #[test]
-    fn replacing_the_controlled_value_discards_the_previous_draft_history() {
-        let schema = model::schema();
-        let plugins = vec![history(Default::default())];
-        let original = state(
-            &schema,
-            "draft",
-            plugins.clone(),
-            &message::Source::default(),
-        );
-        let edited = original
-            .apply(model::replace(&original, 5, 5, " /skill:review").unwrap())
-            .unwrap();
-        assert_eq!(model::source(edited.doc()), "draft /skill:review");
-        assert_eq!(undo_depth(&edited), 1);
-        let reset = state(&schema, "", plugins, &message::Source::default());
-        assert_eq!(model::source(reset.doc()), "");
-        assert_eq!(undo_depth(&reset), 0);
-    }
-}
diff --git a/products/maka/workbench/src/composer_input/message.rs b/products/maka/workbench/src/composer_input/message.rs
index 7a07771d2de..b85037aaa2e 100644
--- a/products/maka/workbench/src/composer_input/message.rs
+++ b/products/maka/workbench/src/composer_input/message.rs
@@ -55,19 +55,7 @@ impl Source {
         for (paragraph_index, paragraph) in doc.content().iter().enumerate() {
             let mut nodes = Vec::new();
             for (node_index, original) in paragraph.content().iter().enumerate() {
-                let raw = if original.ty().name() == "skill" {
-                    format!(
-                        "/skill:{}",
-                        original.attrs()["name"]
-                            .as_str()
-                            .expect("a skill name is text")
-                    )
-                } else {
-                    original
-                        .text()
-                        .expect("composer inline nodes are text or skills")
-                        .to_owned()
-                };
+                let raw = super::model::node_source(original);
                 // A loaded suffix cannot prove the boundary before its first
                 // character. Never turn it into a new invocation at the gap.
                 let node = if self.offset > 0
@@ -173,45 +161,3 @@ pub(super) fn attachment(node: &Node, chip: AnyElement) -> AnyElement {
         .child(chip)
         .into_element()
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::composer_input::model;
-
-    #[test]
-    fn history_annotations_preserve_utf8_addresses_and_plain_copy_text() {
-        let schema = model::schema();
-        let doc = model::document(&schema, "🦀 /skill:review\r\n尾部", true);
-        let source = Source {
-            id: Some("message".into()),
-            offset: 100,
-        };
-        let doc = source.annotate(&schema, doc);
-        assert_eq!(model::source(&doc), "🦀 /skill:review\r\n尾部");
-        assert!(source.matches(&doc));
-        assert_eq!(
-            doc.child(0).child(0).marks()[0].attrs()["offset"],
-            json!(100)
-        );
-        assert_eq!(doc.child(0).child(1).attrs()["sourceOffset"], json!(105));
-        assert_eq!(
-            doc.child(1).child(0).marks()[0].attrs()["offset"],
-            json!(120)
-        );
-    }
-
-    #[test]
-    fn a_loaded_suffix_does_not_invent_a_skill_boundary_at_its_start() {
-        let schema = model::schema();
-        let doc = model::document(&schema, "/skill:partial /skill:valid", true);
-        let doc = Source {
-            id: Some("message".into()),
-            offset: 20,
-        }
-        .annotate(&schema, doc);
-        assert_eq!(doc.child(0).child(0).text(), Some("/skill:partial"));
-        assert_eq!(doc.child(0).child(2).ty().name(), "skill");
-        assert_eq!(model::source(&doc), "/skill:partial /skill:valid");
-    }
-}
diff --git a/products/maka/workbench/src/composer_input/model.rs b/products/maka/workbench/src/composer_input/model.rs
index 47b8005c057..b337547e26c 100644
--- a/products/maka/workbench/src/composer_input/model.rs
+++ b/products/maka/workbench/src/composer_input/model.rs
@@ -43,7 +43,7 @@ pub(super) fn schema() -> Schema {
     .expect("the composer schema is valid")
 }
 
-pub(super) fn skill(schema: &Schema, name: &str) -> Node {
+fn skill(schema: &Schema, name: &str) -> Node {
     schema
         .node(
             "skill",
@@ -54,7 +54,7 @@ pub(super) fn skill(schema: &Schema, name: &str) -> Node {
         .expect("a skill node has its required name")
 }
 
-pub(super) fn token_ranges(text: &str) -> Vec<Range<usize>> {
+fn token_ranges(text: &str) -> Vec<Range<usize>> {
     static RULE: LazyLock<InputTokenRule> = LazyLock::new(|| {
         InputTokenRule::new(
             r"(?:^|[\t-\r \u{00a0}\u{1680}\u{2000}-\u{200a}\u{2028}\u{2029}\u{202f}\u{205f}\u{3000}\u{feff}])(?P<token>/skill:[A-Za-z0-9._-]+)",
@@ -71,20 +71,18 @@ pub(super) fn token_ranges(text: &str) -> Vec<Range<usize>> {
         .collect()
 }
 
-fn inline(schema: &Schema, text: &str, atoms: bool) -> Vec<Node> {
+fn inline(schema: &Schema, text: &str) -> Vec<Node> {
     let mut out = Vec::new();
     let mut at = 0;
-    if atoms {
-        for range in token_ranges(text) {
-            if at < range.start {
-                out.push(schema.text(&text[at..range.start], vec![]));
-            }
-            out.push(skill(
-                schema,
-                &text[range.start + "/skill:".len()..range.end],
-            ));
-            at = range.end;
+    for range in token_ranges(text) {
+        if at < range.start {
+            out.push(schema.text(&text[at..range.start], vec![]));
         }
+        out.push(skill(
+            schema,
+            &text[range.start + "/skill:".len()..range.end],
+        ));
+        at = range.end;
     }
     if at < text.len() {
         out.push(schema.text(&text[at..], vec![]));
@@ -92,7 +90,7 @@ fn inline(schema: &Schema, text: &str, atoms: bool) -> Vec<Node> {
     out
 }
 
-pub(super) fn document(schema: &Schema, source: &str, atoms: bool) -> Node {
+pub(super) fn document(schema: &Schema, source: &str) -> Node {
     let mut paragraphs = Vec::new();
     let mut rest = source;
     loop {
@@ -113,7 +111,7 @@ pub(super) fn document(schema: &Schema, source: &str, atoms: bool) -> Node {
                 .node(
                     "paragraph",
                     Some([("ending".to_owned(), json!(ending))].into()),
-                    Fragment::from(inline(schema, text, atoms)),
+                    Fragment::from(inline(schema, text)),
                     vec![],
                 )
                 .expect("composer paragraphs contain only inline nodes"),
@@ -129,11 +127,11 @@ pub(super) fn document(schema: &Schema, source: &str, atoms: bool) -> Node {
 }
 
 pub(super) fn slice(schema: &Schema, source: &str) -> Slice {
-    let doc = document(schema, source, true);
+    let doc = document(schema, source);
     Slice::new(doc.content().clone(), 1, 1)
 }
 
-fn node_source(node: &Node) -> String {
+pub(super) fn node_source(node: &Node) -> String {
     if let Some(text) = node.text() {
         text.to_owned()
     } else if node.ty().name() == "skill" {
@@ -167,40 +165,43 @@ pub(super) fn source(doc: &Node) -> String {
 }
 
 #[derive(Debug)]
-struct Span {
+struct Span<'doc> {
     source: Range<usize>,
     doc: Range<usize>,
-    atom: bool,
+    node: Option<&'doc Node>,
 }
 
 /// One action's conversion table. Source offsets remain UTF-16, including
 /// the full invocation; an inline atom occupies one document position.
 #[derive(Debug)]
-pub(super) struct Projection {
+pub(super) struct Projection<'doc> {
     pub source: String,
-    spans: Vec<Span>,
+    spans: Vec<Span<'doc>>,
     end: usize,
 }
 
-impl Projection {
-    pub fn new(doc: &Node) -> Self {
+impl<'doc> Projection<'doc> {
+    pub fn new(doc: &'doc Node) -> Self {
         let mut source = String::new();
         let mut spans = Vec::new();
         let mut offset = 0;
         let mut end = 1;
-        doc.for_each(&mut |paragraph, block_at, index| {
-            paragraph.for_each(&mut |node, inline_at, _| {
+        let mut block_at = 0;
+        for (index, paragraph) in doc.content().iter().enumerate() {
+            let mut inline_at = 0;
+            for node in paragraph.content() {
                 let text = node_source(node);
                 let length = text.encode_utf16().count();
                 let at = block_at + 1 + inline_at;
                 spans.push(Span {
                     source: offset..offset + length,
                     doc: at..at + node.node_size(),
-                    atom: !node.is_text(),
+                    node: Some(node),
                 });
                 source.push_str(&text);
                 offset += length;
-            });
+                inline_at += node.node_size();
+            }
             end = block_at + 1 + paragraph.content().size();
             if index + 1 < doc.child_count() {
                 let ending = paragraph
@@ -212,22 +213,26 @@ impl Projection {
                 spans.push(Span {
                     source: offset..offset + length,
                     doc: end..end + 2,
-                    atom: true,
+                    node: None,
                 });
                 source.push_str(ending);
                 offset += length;
             }
-        });
+            block_at += paragraph.node_size();
+        }
         Self { source, spans, end }
     }
 
     pub fn source_at(&self, pos: usize) -> u32 {
-        for span in &self.spans {
+        if let Some(span) = self
+            .spans
+            .get(self.spans.partition_point(|span| span.doc.end < pos))
+        {
             if pos < span.doc.start {
                 return span.source.start as u32;
             }
             if pos <= span.doc.end {
-                return if span.atom {
+                return if span.node.is_none_or(|node| !node.is_text()) {
                     if pos == span.doc.start {
                         span.source.start
                     } else {
@@ -238,13 +243,18 @@ impl Projection {
                 } as u32;
             }
         }
-        self.source.encode_utf16().count() as u32
+        self.spans.last().map_or(0, |span| span.source.end) as u32
     }
 
     pub fn doc_at(&self, offset: u32, end: bool) -> Option<usize> {
-        byte_at(&self.source, offset)?;
         let offset = offset as usize;
-        for span in &self.spans {
+        if offset > self.spans.last().map_or(0, |span| span.source.end) {
+            return None;
+        }
+        if let Some(span) = self
+            .spans
+            .get(self.spans.partition_point(|span| span.source.end < offset))
+        {
             if offset < span.source.start {
                 return Some(span.doc.start);
             }
@@ -253,7 +263,7 @@ impl Projection {
                     span.doc.start
                 } else if offset == span.source.end {
                     span.doc.end
-                } else if span.atom {
+                } else if span.node.is_none_or(|node| !node.is_text()) {
                     if end { span.doc.end } else { span.doc.start }
                 } else {
                     span.doc.start + offset - span.source.start
@@ -264,7 +274,7 @@ impl Projection {
     }
 }
 
-pub(super) fn byte_at(source: &str, offset: u32) -> Option<usize> {
+fn byte_at(source: &str, offset: u32) -> Option<usize> {
     let mut units = 0;
     for (at, ch) in source.char_indices() {
         if units == offset {
@@ -278,45 +288,62 @@ pub(super) fn byte_at(source: &str, offset: u32) -> Option<usize> {
     (units == offset).then_some(source.len())
 }
 
-pub(super) fn tokenize(state: &EditorState, force: bool) -> Option<Transaction> {
+pub(super) fn tokenize(state: &EditorState) -> Option<Transaction> {
     let projection = Projection::new(state.doc());
-    let caret = projection.source_at(state.selection().head()) as usize;
-    let anchor = projection.source_at(state.selection().anchor()) as usize;
+    let mut byte = 0;
+    let mut offset = 0;
+    let tokens: Vec<_> = token_ranges(&projection.source)
+        .into_iter()
+        .map(|range| {
+            offset += projection.source[byte..range.start].encode_utf16().count() as u32;
+            let from = projection
+                .doc_at(offset, false)
+                .expect("a token starts at a character boundary");
+            offset += projection.source[range.clone()].encode_utf16().count() as u32;
+            let to = projection
+                .doc_at(offset, true)
+                .expect("a token ends at a character boundary");
+            byte = range.end;
+            (from..to, &projection.source[range])
+        })
+        .collect();
     let mut replacements = Vec::new();
-    for range in token_ranges(&projection.source) {
-        let start = projection.source[..range.start].encode_utf16().count();
-        let end = projection.source[..range.end].encode_utf16().count();
-        let from = projection
-            .doc_at(start as u32, false)
-            .expect("token starts at a character boundary");
-        let to = projection
-            .doc_at(end as u32, true)
-            .expect("token ends at a character boundary");
-        if state.doc().node_at(from).is_some_and(|node| {
-            node.ty().name() == "skill"
-                && from + node.node_size() == to
-                && node_source(&node) == projection.source[range.clone()]
+    for span in &projection.spans {
+        let Some(node) = span.node.filter(|node| node.ty().name() == "skill") else {
+            continue;
+        };
+        let next = tokens.partition_point(|(range, _)| range.end <= span.doc.start);
+        if tokens
+            .get(next)
+            .is_none_or(|(range, _)| range.start >= span.doc.end)
+        {
+            replacements.push((
+                span.doc.clone(),
+                state.schema().text(&node_source(node), vec![]),
+            ));
+        }
+    }
+    for (range, raw) in tokens {
+        let existing = projection
+            .spans
+            .partition_point(|span| span.doc.end <= range.start);
+        if projection.spans.get(existing).is_some_and(|span| {
+            span.doc == range && span.node.is_some_and(|node| node.ty().name() == "skill")
         }) {
             continue;
         }
-        if !force && anchor >= start && anchor <= end && caret >= start && caret <= end {
+        if state.selection().from() >= range.start && state.selection().to() <= range.end {
             continue;
         }
-        replacements.push((
-            from,
-            to,
-            skill(
-                state.schema(),
-                &projection.source[range.start + 7..range.end],
-            ),
-        ));
+        replacements.push((range, skill(state.schema(), &raw[7..])));
     }
     if replacements.is_empty() {
         return None;
     }
+    replacements.sort_unstable_by_key(|(range, _)| range.start);
     let mut tr = state.tr();
-    for (start, end, node) in replacements.into_iter().rev() {
-        tr.replace_with(start, end, Fragment::from(vec![node]))
+    for (range, node) in replacements.into_iter().rev() {
+        tr.replace_with(range.start, range.end, Fragment::from(vec![node]))
             .expect("a token replaces its source range");
     }
     Some(tr)
@@ -332,6 +359,8 @@ pub(super) fn replace(
         return None;
     }
     let projection = Projection::new(state.doc());
+    byte_at(&projection.source, start)?;
+    byte_at(&projection.source, end)?;
     let from = projection.doc_at(start, false)?;
     let to = projection.doc_at(end, true)?;
     let start = projection.source_at(from);
@@ -342,7 +371,7 @@ pub(super) fn replace(
     raw.push_str(&projection.source[..first]);
     raw.push_str(text);
     raw.push_str(&projection.source[last..]);
-    let doc = document(state.schema(), &raw, true);
+    let doc = document(state.schema(), &raw);
     let next = Projection::new(&doc);
     let caret = next.doc_at(start + text.encode_utf16().count() as u32, true)?;
     let mut tr = state.tr();
@@ -378,125 +407,47 @@ pub(super) fn delete_atom(state: &EditorState, forward: bool) -> Option<Transact
 mod tests {
     use super::*;
     use nsh_base::rich_editor::{
-        extensions::history::{history, redo, undo},
+        extensions::history::{history, undo},
         state::EditorStateConfig,
     };
 
     #[test]
-    fn source_round_trips_skills_unicode_and_line_endings() {
-        let schema = schema();
-        let raw = "🦀 /skill:review, /skill:fix\r\n\n尾部\r";
-        let doc = document(&schema, raw, true);
-        assert_eq!(source(&doc), raw);
-        let p = Projection::new(&doc);
-        assert_eq!(p.source_at(p.doc_at(4, false).unwrap()), 3);
-        assert_eq!(p.source_at(p.doc_at(4, true).unwrap()), 16);
-        assert_eq!(p.source_at(p.doc_at(33, true).unwrap()), 33);
-        assert!(p.doc_at(1, false).is_none(), "a surrogate cannot be split");
-    }
-
-    #[test]
-    fn typed_skill_remains_editable_until_the_caret_leaves() {
+    fn replacement_preserves_source_boundaries_and_undo() {
         let schema = schema();
-        let doc = document(&schema, "a /skill:review", false);
-        let selection = TextSelection::create(&doc, 16, None);
-        let state =
-            EditorState::create(EditorStateConfig::new(schema).doc(doc).selection(selection))
-                .unwrap();
-        assert!(tokenize(&state, false).is_none());
-        let mut tr = state.tr();
-        tr.set_selection(TextSelection::create(state.doc(), 1, None));
-        let state = state.apply(tr).unwrap();
-        let state = state.apply(tokenize(&state, false).unwrap()).unwrap();
-        assert_eq!(state.doc().child(0).child(1).ty().name(), "skill");
-        assert_eq!(source(state.doc()), "a /skill:review");
-    }
-
-    #[test]
-    fn typing_a_delimiter_confirms_the_skill_without_changing_its_source() {
-        let schema = schema();
-        let doc = document(&schema, "/skill:review", false);
-        let selection = TextSelection::create(&doc, 14, None);
-        let state =
-            EditorState::create(EditorStateConfig::new(schema).doc(doc).selection(selection))
-                .unwrap();
-        let mut tr = state.tr();
-        tr.insert_text(" ", None, None);
-        let state = state.apply(tr).unwrap();
-        let state = state.apply(tokenize(&state, false).unwrap()).unwrap();
-        assert_eq!(source(state.doc()), "/skill:review ");
-        assert_eq!(state.doc().child(0).child(0).ty().name(), "skill");
-        assert_eq!(state.doc().child(0).child(1).text(), Some(" "));
-    }
-
-    #[test]
-    fn explicit_replace_and_atomic_delete_are_separate_undoable_actions() {
-        let schema = schema();
-        let doc = document(&schema, "🦀 ", true);
+        let doc = document(&schema, "前😀 后");
         let state = EditorState::create(
             EditorStateConfig::new(schema)
                 .doc(doc)
                 .plugins(vec![history(Default::default())]),
         )
         .unwrap();
+        assert!(replace(&state, 2, 2, "x").is_none());
         let state = state
-            .apply(replace(&state, 3, 3, "/skill:review ").unwrap())
+            .apply(replace(&state, 4, 4, "/skill:review\r\n下一行").unwrap())
             .unwrap();
-        assert_eq!(source(state.doc()), "🦀 /skill:review ");
-        assert_eq!(state.doc().child(0).child(1).ty().name(), "skill");
-        let projection = Projection::new(state.doc());
-        let caret = projection.doc_at(16, true).unwrap();
-        let mut tr = state.tr();
-        tr.set_selection(TextSelection::create(state.doc(), caret, None));
-        let state = state.apply(tr).unwrap();
-        let deleted = state.apply(delete_atom(&state, false).unwrap()).unwrap();
-        assert_eq!(source(deleted.doc()), "🦀  ");
+        assert_eq!(source(state.doc()), "前😀 /skill:review\r\n下一行后");
         let mut restored = None;
         assert!(undo(
-            &deleted,
-            Some(&mut |tr| restored = Some(deleted.apply(tr).unwrap()))
-        ));
-        let restored = restored.unwrap();
-        assert_eq!(source(restored.doc()), "🦀 /skill:review ");
-        let mut redone = None;
-        assert!(redo(
-            &restored,
-            Some(&mut |tr| redone = Some(restored.apply(tr).unwrap()))
-        ));
-        assert_eq!(source(redone.unwrap().doc()), "🦀  ");
-        let mut initial = None;
-        assert!(undo(
-            &restored,
-            Some(&mut |tr| initial = Some(restored.apply(tr).unwrap()))
+            &state,
+            Some(&mut |tr| restored = Some(state.apply(tr).unwrap()))
         ));
-        assert_eq!(source(initial.unwrap().doc()), "🦀 ");
+        assert_eq!(source(restored.unwrap().doc()), "前😀 后");
     }
 
     #[test]
-    fn grammar_uses_js_whitespace_and_the_full_surrounding_source() {
-        assert_eq!(token_ranges("\u{feff}/skill:one"), vec![3..13]);
-        assert!(token_ranges("\u{85}/skill:one").is_empty());
+    fn deleting_a_skill_boundary_makes_its_text_editable_again() {
         let schema = schema();
-        let doc = document(&schema, "/skill:one", true);
-        let state = EditorState::create(EditorStateConfig::new(schema).doc(doc)).unwrap();
-        let state = state
-            .apply(replace(&state, 10, 10, "/skill:two").unwrap())
-            .unwrap();
-        assert_eq!(source(state.doc()), "/skill:one/skill:two");
-        assert_eq!(state.doc().child(0).child_count(), 2);
-        assert_eq!(state.doc().child(0).child(1).text(), Some("/skill:two"));
-    }
-    #[test]
-    fn skill_chips_never_separate_a_unicode_grapheme() {
-        let schema = schema();
-        let accented = document(&schema, "/skill:e\u{301}", true);
-        assert_eq!(accented.child(0).child_count(), 1);
-        assert_eq!(accented.child(0).child(0).text(), Some("/skill:e\u{301}"));
-        let joined = document(&schema, "/skill:review\u{200d}👩\u{200d}💻", true);
-        assert_eq!(joined.child(0).child_count(), 1);
-        assert_eq!(source(&joined), "/skill:review\u{200d}👩\u{200d}💻");
-        let separate = document(&schema, "/skill:review 👩\u{200d}💻", true);
-        assert_eq!(separate.child(0).child(0).ty().name(), "skill");
-        assert_eq!(separate.child(0).child(1).text(), Some(" 👩\u{200d}💻"));
+        let state = EditorState::create(
+            EditorStateConfig::new(schema.clone()).doc(document(&schema, "a /skill:review")),
+        )
+        .unwrap();
+        let mut tr = state.tr();
+        tr.delete(2, 3).unwrap();
+        let mut state = state.apply(tr).unwrap();
+        if let Some(tr) = tokenize(&state) {
+            state = state.apply(tr).unwrap();
+        }
+        let state = state.apply(replace(&state, 3, 4, "X").unwrap()).unwrap();
+        assert_eq!(source(state.doc()), "a/sXill:review");
     }
 }
diff --git a/products/maka/workbench/src/lib.rs b/products/maka/workbench/src/lib.rs
index 26750dc2193..e37c051b08f 100644
--- a/products/maka/workbench/src/lib.rs
+++ b/products/maka/workbench/src/lib.rs
@@ -93,7 +93,7 @@ mod tests {
 
     #[test]
     fn recycled_completion_cells_refresh_labels_and_press_actions() {
-        let mut registry = nsh_core::element::Registry::ui_set("maka/host");
+        let mut registry = crate::bindings::ui_registry();
         registry.value("host", || Instance::new(CompletionHost));
         let sets = vec![nsh_base::registry(), registry];
         let bundle = nsh_bundler::bundle(&nsh_bundler::BundleOptions {
@@ -128,11 +128,10 @@ mod tests {
         app.wait_for("text:/2:skill:skill-15/").unwrap();
     }
 
-    fn skill_input_fixture() -> nsh_testing::Headless {
-        let mut registry = nsh_core::element::Registry::ui_set("maka/host");
+    #[test]
+    fn skills_edit_as_units_and_sent_messages_preserve_copy_and_shortcuts() {
+        let mut registry = crate::bindings::ui_registry();
         registry.value("host", || Instance::new(CompletionHost));
-        registry.register::<crate::composer_input::ComposerInput>();
-        registry.class::<crate::composer_input::ComposerInputState>();
         let sets = vec![nsh_base::registry(), registry];
         let bundle = nsh_bundler::bundle(&nsh_bundler::BundleOptions {
             entry: std::path::Path::new("tests/fixtures/skill-input.tsx")
@@ -154,75 +153,78 @@ mod tests {
             ..nsh_engine::EngineConfig::new(nsh_engine::Bundle::source(bundle.code))
         })
         .unwrap();
-        app.wait_for("label:Draft").unwrap();
-        app.wait_for("text:Editor ready").unwrap();
-        app
-    }
-
-    #[test]
-    fn skill_input_edits_and_copies_invocations_as_whole_nodes() {
-        let mut app = skill_input_fixture();
-        app.wait_for("text:Selection 19:19").unwrap();
+        app.wait_for("text:Ready").unwrap();
         app.type_text("label:Draft", "").unwrap();
-        for key in ["mod+right", "left", "left", "left"] {
+        for key in ["left", "left", "left", "shift+right", "mod+c"] {
             app.press_key(key).unwrap();
         }
-        app.wait_for("text:Selection 4:4").unwrap();
-        app.press_key("shift+right").unwrap();
-        app.wait_for("text:Selection 4:17").unwrap();
-        app.press_key("mod+c").unwrap();
         assert_eq!(app.screen().clipboard(), Some("/skill:review"));
         app.press_key("backspace").unwrap();
-        app.wait_for(r#"text:Source "前😀  后""#).unwrap();
+        app.wait_for(r#"text:Draft "前😀  后""#).unwrap();
         app.press_key("mod+z").unwrap();
-        app.wait_for(r#"text:Source "前😀 /skill:review 后""#)
+        app.wait_for(r#"text:Draft "前😀 /skill:review 后""#)
             .unwrap();
         app.press_key("mod+a").unwrap();
-        app.press_key("mod+c").unwrap();
-        assert_eq!(app.screen().clipboard(), Some("前😀 /skill:review 后"));
-        app.press_key("enter").unwrap();
-        app.wait_for(r#"text:Submitted "前😀 /skill:review 后""#)
+        let mut paste = nsh_core::PasteEvent::new("a\nb");
+        paste.html = "<pre>a\nb</pre>".into();
+        app.paste("label:Draft", &paste).unwrap();
+        app.wait_for(r#"text:Draft "a\nb""#).unwrap();
+        let input = app
+            .screen()
+            .commands()
+            .iter()
+            .rev()
+            .find_map(|(id, command)| matches!(command, nsh_core::Command::Focus).then_some(*id))
+            .unwrap();
+        let compose = |app: &mut nsh_testing::Headless, active| {
+            app.engine().control().dispatch_event(
+                input,
+                nsh_core::EventKind::CompositionChange,
+                nsh_core::EventPayload::Map(vec![
+                    ("composing", nsh_core::PayloadValue::Bool(active)),
+                    ("text", nsh_core::PayloadValue::Str(String::new())),
+                ]),
+            );
+            app.wait_for(if active {
+                "text:Composing"
+            } else {
+                "text:Idle"
+            })
             .unwrap();
+        };
+        compose(&mut app, true);
+        app.press_key("left").unwrap();
+        app.wait_for("text:IME key released").unwrap();
         app.press("label:Reset").unwrap();
-        app.wait_for(r#"text:Source """#).unwrap();
+        app.wait_for(r#"text:Draft """#).unwrap();
+        compose(&mut app, false);
         app.press_key("mod+z").unwrap();
-        assert!(app.shows("Source \"\""));
-        app.wait_for("text:Selection 0:0").unwrap();
-        app.press_key("tab").unwrap();
-        app.wait_for(r#"text:Source "/skill:fix ""#).unwrap();
-    }
-
-    #[test]
-    fn skill_input_paste_grows_the_viewport_and_message_selection_keeps_source() {
-        let mut app = skill_input_fixture();
-        app.type_text("label:Draft", "").unwrap();
-        app.press_key("mod+a").unwrap();
-        app.paste(
-            "label:Draft",
-            &nsh_core::PasteEvent::new(
-                "one\ntwo\nthree\nfour\nfive\nsix\nseven\neight\nnine\nten\n/skill:review",
-            ),
-        )
-        .unwrap();
-        assert_eq!(
-            app.screen()
-                .span_style("id:draft-field >> text:one")
-                .unwrap()
-                .line_height,
-            px(24.0)
-        );
-        app.wait_for("text:Height 144").unwrap();
+        assert!(app.shows("Draft \"\""));
+        app.press_key("mod+i").unwrap();
+        app.wait_for(r#"text:Draft "/skill:fix ""#).unwrap();
+        app.press_key("enter").unwrap();
+        app.wait_for(r#"text:Submitted "/skill:fix ""#).unwrap();
         app.press_key("mod+a").unwrap();
-        app.press_key("mod+c").unwrap();
-        assert_eq!(
-            app.screen().clipboard(),
-            Some("one\ntwo\nthree\nfour\nfive\nsix\nseven\neight\nnine\nten\n/skill:review")
+        app.paste("label:Draft", &nsh_core::PasteEvent::new("ab"))
+            .unwrap();
+        compose(&mut app, true);
+        app.press("label:Reset").unwrap();
+        app.wait_for(r#"text:Draft """#).unwrap();
+        app.engine().control().dispatch_event(
+            input,
+            nsh_core::EventKind::ChangeText,
+            nsh_core::EventPayload::Text {
+                text: "文".into(),
+                count: 0,
+            },
         );
+        compose(&mut app, false);
+        app.wait_for(r#"text:Draft "ab文""#).unwrap();
         app.type_text("label:前😀 /skill:review 后", "").unwrap();
         app.press_key("mod+a").unwrap();
         app.press_key("mod+c").unwrap();
         assert_eq!(app.screen().clipboard(), Some("前😀 /skill:review 后"));
         app.press_key("mod+n").unwrap();
-        app.wait_for("text:App shortcut received").unwrap();
+        app.wait_for("text:Shortcut received").unwrap();
     }
 }
diff --git a/products/maka/workbench/tests/fixtures/skill-input.tsx b/products/maka/workbench/tests/fixtures/skill-input.tsx
index 52083770de2..922bf9a140c 100644
--- a/products/maka/workbench/tests/fixtures/skill-input.tsx
+++ b/products/maka/workbench/tests/fixtures/skill-input.tsx
@@ -27,52 +27,44 @@ import type { Row } from '../../app/history';
 mount(() => {
   const initial = '前😀 /skill:review 后';
   const draft = signal(initial);
-  const selected = signal({ start: 0, end: 0 });
+  const selection = signal({ start: 0, end: 0 });
   const submitted = signal('');
-  const height = signal(0);
   const ready = signal(false);
-  const appShortcut = signal(false);
-  keymap.bind('mod+n', () => appShortcut.set(true), { when: 'always' });
+  const shortcut = signal(false);
+  const released = signal(false);
   let editor: ComposerEditor | undefined;
+  keymap.bind('left', () => released.set(true), { when: 'always' });
+  keymap.bind('mod+n', () => shortcut.set(true), { when: 'always' });
   return (
     <View style={{ width: 600, gap: 8 }}>
-      <View
-        style={{ maxHeight: 144, minHeight: 24 }}
-        onLayout={({ bounds }) => height.set(bounds.size.height)}
-      >
-        <SkillInput
-          ref={(node) => {
-            editor = node;
-            node.bindKey('tab', () => {
-              if (node.composing()) return;
-              node.replaceRange({
-                start: selected().start,
-                end: selected().end,
-                text: '/skill:fix ',
-                expectedText: draft(),
-                expectedSelection: selected(),
-              });
-            });
-            ready.set(true);
-          }}
-          testID="draft-field"
-          accessibilityLabel="Draft"
-          value={draft()}
-          readonly={false}
-          autoFocus
-          placeholder="Message"
-          onChange={({ value }) => draft.set(value)}
-          onSelectionChange={(range) => selected.set(range)}
-          onSubmit={({ text }) => submitted.set(text)}
-          style={{ flexShrink: 1 }}
-        />
-      </View>
-      <Text>{`Source ${JSON.stringify(draft())}`}</Text>
-      <Text>{`Selection ${selected().start}:${selected().end}`}</Text>
+      <SkillInput
+        accessibilityLabel="Draft"
+        value={draft()}
+        readonly={false}
+        autoFocus
+        placeholder=""
+        ref={(node) => {
+          editor = node;
+          node.bindKey('mod+i', () =>
+            node.replaceRange({
+              ...selection(),
+              text: '/skill:fix ',
+              expectedText: draft(),
+              expectedSelection: selection(),
+            }),
+          );
+          ready.set(true);
+        }}
+        onChange={({ value }) => draft.set(value)}
+        onSelectionChange={(value) => selection.set(value)}
+        onSubmit={({ text }) => submitted.set(text)}
+      />
+      <Text>{`Draft ${JSON.stringify(draft())}`}</Text>
       <Text>{`Submitted ${JSON.stringify(submitted())}`}</Text>
-      <Text>{`Height ${height()}`}</Text>
-      <Text>{ready() ? 'Editor ready' : 'Starting editor'}</Text>
-      <Text>{appShortcut() ? 'App shortcut received' : 'App shortcut idle'}</Text>
+      <Text>{ready() ? 'Ready' : 'Starting'}</Text>
+      <Text>{ready() && editor?.composing() ? 'Composing' : 'Idle'}</Text>
+      <Text>{shortcut() ? 'Shortcut received' : 'Shortcut idle'}</Text>
+      <Text>{released() ? 'IME key released' : 'IME key held'}</Text>
       <Button
         accessibilityLabel="Reset"
         onPress={() => {
@@ -82,9 +74,7 @@ mount(() => {
       >
         <Text>Reset</Text>
       </Button>
-      <View style={{ width: 500 }}>
-        <SkillMessage row={() => ({ text: initial }) as Row} sourceId="fixture/message" />
-      </View>
+      <SkillMessage row={() => ({ text: initial }) as Row} sourceId="fixture/message" />
     </View>
   );
 });
diff --git a/products/maka/workbench/tests/history.test.mjs b/products/maka/workbench/tests/history.test.mjs
index d6ed031f2de..73a4143d06a 100644
--- a/products/maka/workbench/tests/history.test.mjs
+++ b/products/maka/workbench/tests/history.test.mjs
@@ -27,6 +27,7 @@ import {
   replayStartCursor,
   updateHistoryMetadata,
 } from '../app/history.ts';
+import { hasSkillToken, skillTextGroups } from '../app/skillTokenText.ts';
 import { orderProcessRows, projectProcessGroups } from '../app/processGroups.ts';
 
 const user = (text, turnId, sequence) => ({
@@ -319,3 +320,16 @@ test('a script is shown as the tools it ran, and as itself only when it fails',
   assert.equal(failed.key, running.key, 'showing the script keeps the group open');
   assert.deepEqual(group(tool('exec', 1, [], { isError: false })).toolIds, ['exec']);
 });
+
+test('skill messages preserve adjacent UTF-8 chunks and do not join across unloaded gaps', () => {
+  const groups = skillTextGroups([
+    { offset: 0, text: '前😀 /ski' },
+    { offset: 12, text: 'll:review 后' },
+    { offset: 100, text: '/skill:partial' },
+  ]);
+  assert.deepEqual(groups, [
+    { offset: 0, text: '前😀 /skill:review 后' },
+    { offset: 100, text: '/skill:partial' },
+  ]);
+  assert.deepEqual(groups.map(hasSkillToken), [true, false]);
+});
diff --git a/products/maka/workbench/tests/skill-token.test.mjs b/products/maka/workbench/tests/skill-token.test.mjs
deleted file mode 100644
index b540ecf2d2d..00000000000
--- a/products/maka/workbench/tests/skill-token.test.mjs
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { hasSkillToken, skillTextGroups } from '../app/skillTokenText.ts';
-
-test('skill messages join adjacent Unicode chunks and preserve gaps and source addresses', () => {
-  const groups = skillTextGroups([
-    { offset: 0, text: '前😀 /ski' },
-    { offset: 12, text: 'll:review 后' },
-    { offset: 100, text: 'suffix /skill:fix' },
-  ]);
-  assert.deepEqual(groups, [
-    { offset: 0, text: '前😀 /skill:review 后' },
-    { offset: 100, text: 'suffix /skill:fix' },
-  ]);
-  assert.equal(groups.every(hasSkillToken), true);
-});
-
-test('skill messages require a known invocation boundary', () => {
-  for (const group of [
-    { offset: 0, text: 'x/skill:no' },
-    { offset: 0, text: '/skill:' },
-    { offset: 80, text: '/skill:unknown-boundary' },
-  ])
-    assert.equal(hasSkillToken(group), false, JSON.stringify(group));
-  for (const group of [
-    { offset: 0, text: '/skill:yes-2.0_' },
-    { offset: 80, text: ' /skill:known-boundary' },
-    { offset: 0, text: '前\u3000/skill:one\n/skill:two' },
-  ])
-    assert.equal(hasSkillToken(group), true, JSON.stringify(group));
-  const groups = skillTextGroups([
-    { offset: 0, text: '/ski' },
-    { offset: 80, text: 'll:no' },
-  ]);
-  assert.equal(groups.some(hasSkillToken), false);
-});
diff --git a/scripts/ci/suites.mjs b/scripts/ci/suites.mjs
index cb6db63b10e..ea8dbc4f89f 100644
--- a/scripts/ci/suites.mjs
+++ b/scripts/ci/suites.mjs
@@ -185,7 +185,7 @@ export const suites = {
       '--lib',
     ],
     filter:
-      'test(native::tests::animated_props_) | test(=input::tests::nonpressable_focusable_views_join_native_stops_without_stealing_presses) | test(=text_input::tests::shortcuts_wait_for_focus_even_without_queued_text) | test(=tests::windows) | test(kitty::tests::)',
+      'test(native::tests::animated_props_) | test(=input::tests::nonpressable_focusable_views_join_native_stops_without_stealing_presses) | test(=tests::windows) | test(kitty::tests::)',
   },
   'windows-desktop': {
     workspace: 'root',
diff --git a/skills/maka-plugin-authoring/assets/composer-ui/index.tsx b/skills/maka-plugin-authoring/assets/composer-ui/index.tsx
index 5eaf8d19dbc..036f4cb9e60 100644
--- a/skills/maka-plugin-authoring/assets/composer-ui/index.tsx
+++ b/skills/maka-plugin-authoring/assets/composer-ui/index.tsx
@@ -104,8 +104,8 @@ function Composer(props: UiEmbeddedViewProps<ComposerViewInput<JSX.Element>, JSX
                   editor.set(node);
                   input.attach({
                     focus: () => node.focus(),
-                    bindKey: (key, action) =>
-                      keymap.bind(key, action, { when: 'always', within: node }),
+                    bindKey: (key, action, options) =>
+                      keymap.bind(key, action, { when: 'always', within: node, ...options }),
                   });
                 }}
                 value={session.draft()}
diff --git a/third-party/nsh/crates/gpui/nsh-platform-gpui/src/navigation.rs b/third-party/nsh/crates/gpui/nsh-platform-gpui/src/navigation.rs
index 0d77b1dd7f7..109fc0f9cb9 100644
--- a/third-party/nsh/crates/gpui/nsh-platform-gpui/src/navigation.rs
+++ b/third-party/nsh/crates/gpui/nsh-platform-gpui/src/navigation.rs
@@ -1181,7 +1181,9 @@ pub(crate) fn key_pressed(surface: &Rc<Surface>, event: &KeyEvent) -> bool {
     if event.vk == VK_ESCAPE
         && let Some(field) = crate::text_input::focused(surface)
     {
-        crate::text_input::blur(&field);
+        if !crate::text_input::composing(&field) {
+            crate::text_input::blur(&field);
+        }
         return true;
     }
     go_back(surface)
diff --git a/third-party/nsh/crates/gpui/nsh-platform-gpui/src/text_input.rs b/third-party/nsh/crates/gpui/nsh-platform-gpui/src/text_input.rs
index 2aedbae0675..2aefc8534ee 100644
--- a/third-party/nsh/crates/gpui/nsh-platform-gpui/src/text_input.rs
+++ b/third-party/nsh/crates/gpui/nsh-platform-gpui/src/text_input.rs
@@ -907,6 +907,10 @@ pub(crate) fn focused(surface: &Surface) -> Option<NshView> {
     focused_view(surface).filter(|view| input_of(view).is_some())
 }
 
+pub(crate) fn composing(view: &NshView) -> bool {
+    input_of(view).is_some_and(|input| input.model.borrow().composition.is_some())
+}
+
 pub(crate) fn window_active(surface: &Surface) -> bool {
     FOCUS.with(|f| f.borrow().get(&surface.key()).is_none_or(|f| !f.inactive))
 }
@@ -2931,51 +2935,6 @@ mod blink {
 mod tests {
     use super::*;
 
-    #[test]
-    fn shortcuts_wait_for_focus_even_without_queued_text() {
-        let surface = Surface::new(nsh_engine::Environment::default());
-        FOCUS.with(|focuses| {
-            focuses.borrow_mut().insert(
-                surface.key(),
-                Focus {
-                    armed: true,
-                    after: 1,
-                    ..Default::default()
-                },
-            );
-        });
-        let mut shortcut = KeyEvent {
-            vk: 0x55,
-            down: true,
-            repeat: false,
-            modifiers: Modifiers {
-                ctrl: true,
-                ..Default::default()
-            },
-        };
-        assert!(
-            hold_key(&surface, &shortcut),
-            "shortcut bypassed the pending focus acknowledgement"
-        );
-        shortcut.down = false;
-        assert!(
-            hold_key(&surface, &shortcut),
-            "the held shortcut lost its key release"
-        );
-        FOCUS.with(|focuses| focuses.borrow_mut().get_mut(&surface.key()).unwrap().after = 0);
-        engine_caught_up(&surface);
-        assert!(
-            !has_pending(&surface),
-            "the acknowledged focus did not replay its shortcuts"
-        );
-        shortcut.down = true;
-        assert!(
-            !hold_key(&surface, &shortcut),
-            "a settled focus kept delaying shortcuts"
-        );
-        surface_stopped(surface.key());
-    }
-
     #[test]
     fn alignment() {
         let mut c = InputConfig::default();
diff --git a/third-party/nsh/crates/nsh-base/src/rich_editor/view/controller.rs b/third-party/nsh/crates/nsh-base/src/rich_editor/view/controller.rs
index ac3f51dec6f..0bb009c634f 100644
--- a/third-party/nsh/crates/nsh-base/src/rich_editor/view/controller.rs
+++ b/third-party/nsh/crates/nsh-base/src/rich_editor/view/controller.rs
@@ -336,7 +336,14 @@ impl Rv {
             if !rv.focused.get() || rv.composition.get().is_some() {
                 return;
             }
+            let tab_navigation = rv.props.tab_navigation.get();
             for spec in keys::key_table(editable.get()) {
+                if tab_navigation
+                    && spec.event.key == "Tab"
+                    && !(spec.event.ctrl || spec.event.alt || spec.event.meta)
+                {
+                    continue;
+                }
                 let rv = rv.clone();
                 let event = spec.event.clone();
                 on_key_with(
@@ -671,6 +678,7 @@ impl Rv {
             self.sink_edited(&held);
         }
         self.composition.set(composing.then(|| text.to_owned()));
+        self.cx.emit(RichEditorEvent::CompositionChange(composing));
     }
 
     /// A key the sink reports itself (soft keyboards: Backspace in an
@@ -914,6 +922,14 @@ impl Rv {
                 .word_step(&doc, head, m.dir)
                 .map(|p| (p, Affinity::Downstream, None)),
             Unit::LineEdge => {
+                let head = if sel.as_text().is_none() {
+                    match doc.resolve(head) {
+                        Ok(pos) => Selection::near(&pos, -m.dir).head(),
+                        Err(_) => return,
+                    }
+                } else {
+                    head
+                };
                 let geo = self.geo.borrow();
                 geo.line_edge(head, affinity, m.dir > 0).map(|p| {
                     let side = if m.dir > 0 {
diff --git a/third-party/nsh/crates/nsh-base/src/rich_editor/view/keys.rs b/third-party/nsh/crates/nsh-base/src/rich_editor/view/keys.rs
index 744877100ad..968591982ac 100644
--- a/third-party/nsh/crates/nsh-base/src/rich_editor/view/keys.rs
+++ b/third-party/nsh/crates/nsh-base/src/rich_editor/view/keys.rs
@@ -253,7 +253,6 @@ mod tests {
             assert!(find(&table, "ctrl+x").event.mod_key);
             assert!(find(&table, "ctrl+a").event.mod_key);
             assert!(!table.iter().any(|s| s.keystroke == "ctrl+v"));
-            assert!(!table.iter().any(|s| s.keystroke == "ctrl+shift+v"));
             assert!(!table.iter().any(|s| s.event.meta));
             assert_eq!(table.iter().any(|s| s.keystroke == "ctrl+q"), os == Os::Web);
         }
@@ -272,7 +271,6 @@ mod tests {
             assert!(find(&table, "cmd+x").event.mod_key);
             assert!(!find(&table, "ctrl+c").event.mod_key);
             assert!(!table.iter().any(|s| s.keystroke == "cmd+v"));
-            assert!(!table.iter().any(|s| s.keystroke == "cmd+shift+v"));
             assert!(!find(&table, "ctrl+v").event.mod_key);
             assert_eq!(table.iter().any(|s| s.keystroke == "cmd+q"), os == Os::Web);
         }
diff --git a/third-party/nsh/crates/nsh-base/src/rich_editor/view/mod.rs b/third-party/nsh/crates/nsh-base/src/rich_editor/view/mod.rs
index f83ddf4f6a2..50e266c5c09 100644
--- a/third-party/nsh/crates/nsh-base/src/rich_editor/view/mod.rs
+++ b/third-party/nsh/crates/nsh-base/src/rich_editor/view/mod.rs
@@ -67,6 +67,10 @@ pub struct RichEditorProps {
     /// read-only too. A read-only editor still selects and copies.
     #[prop(default = true)]
     pub editable: Prop<bool>,
+    /// Leaves Tab and Shift+Tab to the platform's focus navigation.
+    /// App key bindings can still capture them explicitly.
+    #[prop(default)]
+    pub tab_navigation: Prop<bool>,
     /// Shown in an empty textblock while the document has no content
     /// (Tiptap's placeholder extension): the one the selection is in, at
     /// the document's top level, while the document can be edited (`showOnlyCurrent`, `includeChildren`,
@@ -196,6 +200,9 @@ pub enum RichEditorEvent {
     /// The selection changed.
     #[args(selection)]
     SelectionChange(RichEditorSelection),
+    /// An input method started or ended composition, including cancellation.
+    #[args(composing)]
+    CompositionChange(bool),
     /// Files were pasted (images, files copied in a file manager): the
     /// selection is where the app inserts them.
     #[args(paste)]
diff --git a/third-party/nsh/crates/nsh-base/src/rich_editor/view/render.rs b/third-party/nsh/crates/nsh-base/src/rich_editor/view/render.rs
index 1ab99af4b84..3bd10d1577a 100644
--- a/third-party/nsh/crates/nsh-base/src/rich_editor/view/render.rs
+++ b/third-party/nsh/crates/nsh-base/src/rich_editor/view/render.rs
@@ -68,7 +68,7 @@ fn rect(b: Bounds<Points>) -> View {
 
 /// The editor.
 pub(crate) fn render(rv: Rv) -> impl IntoElement {
-    let (scroll_rv, layout_rv) = (rv.clone(), rv.clone());
+    let (scroll_rv, layout_rv, focus_rv) = (rv.clone(), rv.clone(), rv.clone());
     let root = part(
         view()
             .relative()
@@ -80,7 +80,9 @@ pub(crate) fn render(rv: Rv) -> impl IntoElement {
     root.child(
         scroll()
             .element_ref(&rv.scroll)
+            .focusable(false)
             .flex_1()
+            .on_press(move || focus_rv.focus())
             .on_scroll(move |e: &ScrollEvent| {
                 scroll_rv.scroll_y.set(e.offset.y);
                 scroll_rv.scrolled.set(e.offset.y);
@@ -102,6 +104,7 @@ fn content(rv: Rv) -> impl IntoElement {
     part(
         view()
             .element_ref(&rv.content)
+            .focusable(false)
             .on_layout(move |b: &Bounds<Points>| {
                 height.set(b.size.height);
                 placed.place();
diff --git a/third-party/nsh/crates/nsh-base/tests/base/rich_editor/typing.rs b/third-party/nsh/crates/nsh-base/tests/base/rich_editor/typing.rs
index 3f6754b3a98..9de286c7ecb 100644
--- a/third-party/nsh/crates/nsh-base/tests/base/rich_editor/typing.rs
+++ b/third-party/nsh/crates/nsh-base/tests/base/rich_editor/typing.rs
@@ -339,98 +339,6 @@ fn backspace_at_a_paragraph_start_joins_into_the_previous() {
 
 // Composition.
 
-#[test]
-fn composition_leaves_candidate_keys_to_the_native_input_method() {
-    use nsh_core::{
-        MountItem, ViewKind,
-        keymap::{KeyMatch, Keystroke},
-    };
-    use std::time::Instant;
-
-    let (engine, batches) =
-        nsh_testing::start(EngineConfig::new(Root::new::<Harness>(|| HarnessProps {
-            session: Some(session(paragraphs(&["ab"]))),
-        })))
-        .unwrap();
-    let deadline = Instant::now() + Duration::from_secs(5);
-    let sink = 'mounted: loop {
-        let batch = batches
-            .recv_timeout(deadline.saturating_duration_since(Instant::now()))
-            .unwrap();
-        for item in batch.items {
-            if let MountItem::Create {
-                id,
-                kind: ViewKind::Input,
-            } = item
-            {
-                break 'mounted id;
-            }
-        }
-    };
-    let control = engine.control();
-    control.dispatch_event(sink, EventKind::Focus, EventPayload::None);
-    let next_bindings = || {
-        let deadline = Instant::now() + Duration::from_secs(5);
-        loop {
-            let batch = batches
-                .recv_timeout(deadline.saturating_duration_since(Instant::now()))
-                .unwrap();
-            for item in batch.items {
-                if let MountItem::Keymap(table) = item {
-                    return table;
-                }
-            }
-        }
-    };
-    let enter = Keystroke::parse("enter", Os::MacOs).unwrap();
-    // Skip a possible initial table emitted before the input took focus.
-    loop {
-        if matches!(next_bindings().find(enter, true, false), KeyMatch::Fire(_)) {
-            break;
-        }
-    }
-    for preedit in ["", "に"] {
-        control.dispatch_event(
-            sink,
-            EventKind::CompositionChange,
-            EventPayload::Map(vec![
-                ("composing", PayloadValue::Bool(true)),
-                ("text", PayloadValue::Str(preedit.to_owned())),
-            ]),
-        );
-        // Enter, arrows and deletion must reach the native input method,
-        // including when it has started an empty preedit.
-        let table = if preedit.is_empty() {
-            Some(next_bindings())
-        } else {
-            None
-        };
-        if let Some(table) = table {
-            for key in ["enter", "left", "backspace", "escape"] {
-                assert!(
-                    !matches!(
-                        table.find(Keystroke::parse(key, Os::MacOs).unwrap(), true, false),
-                        KeyMatch::Fire(_)
-                    ),
-                    "editor intercepted IME key {key}"
-                );
-            }
-        }
-    }
-    control.dispatch_event(
-        sink,
-        EventKind::CompositionChange,
-        EventPayload::Map(vec![
-            ("composing", PayloadValue::Bool(false)),
-            ("text", PayloadValue::Str(String::new())),
-        ]),
-    );
-    assert!(matches!(
-        next_bindings().find(enter, true, false),
-        KeyMatch::Fire(_)
-    ));
-}
-
 #[test]
 fn composition_shows_its_text_without_changing_the_document() {
     let mut app = start(paragraphs(&["ab"]));