dsh-mobile-flow 0.7.1 → 0.7.3

package/README.md

@@ -30,6 +30,7 @@ On viewports ≤720px (the same breakpoint the official question card uses):
 5. **No auto-focus on session switch** — the stock UI returns focus to the input box on every mount / session switch (a desktop convenience), which pops the on-screen keyboard over half the screen on phones. In narrow viewports the programmatic focus is swallowed; tapping the input box still focuses it normally.
 6. **Workspace row actions always visible** — the trailing buttons on workspace and session rows (the ⋯ menu with rename/delete and the ＋ for a new session in that workspace) surface on hover only; touch has no hover, so narrow viewports show them whenever the sidebar list is rendered.
 7. **Native input takeover** — the draft surface is drawn by a native textarea whose metrics match the stock box exactly (geometry is measured from the live composer every frame the card relayouts). Enter still performs the official send gesture (including `/` menu arbitration and the busy-Enter policy), file pastes are forwarded to the official attachment intake, and locked states follow the product's own editability gate.
+8. **The send button follows the field** — as soon as the field holds text, the send button reads as enabled (a live blue circle instead of the disabled grey one) and one tap sends it (queue/steer while a turn streams). While typing that state is painted by pure CSS with **zero DOM writes**, so the "no DOM movement while typing" invariant stands.
 
 Desktop (wide viewports) is completely unaffected.
 
@@ -99,6 +100,7 @@ Open a session on a phone (or a desktop DevTools window narrowed to ≤720px):
 - Swipe up a few screens: the input bar and confirmation cards scroll away with the messages.
 - The draft surface should be a native textarea (the page carries `[data-mobile-input]`). Type with an IME or voice input: text must not be cleared.
 - Send with the send button or Enter (same gesture as the stock composer).
+- Send-button state: **with text in the field the button is live** (the grey→live flip follows the field's content); one tap sends one message, first tap included.
 - The tool row shows **two chips**: 「输入法✓」(the escape hatch) and 「诊断」(open the test bench).
 - The v0.6.0 regression to watch: **no layout movement while typing** — the field's height stays put until focus
   leaves, and only then follows the content.
@@ -190,6 +192,33 @@ mount — completes with nothing focused, then `focus()` to bring the IME back,
 **long-press it for 600ms** to call out the **诊断** (diagnostics) button, long-press again to put it away. While
 diagnostics are on, both 诊断 and 复制日志 (copy log) show up by themselves.
 
+**v0.7.2 (phone report: tapping the input box after "new session" did nothing)**: right after a new session is
+created its **workspace may not be resolved yet** — in that window the product's card is not an input at all but the
+workspace **picker trigger** (`aria-haspopup="menu"`, `contenteditable="false"`, no bound editor). The takeover used
+to claim it anyway and **latched** that non-editability into the native textarea's `readOnly`: tapping the box raised
+no keyboard and no caret, the card's own "open the picker" tap was swallowed, so the user could neither type nor pick
+a workspace — and it did **not** recover once the workspace resolved (only a session switch, i.e. a remount, did).
+That is exactly the reported "first new session dead, switch away and create another and it works" pattern.
+
+Fixes:
+
+- The takeover now **asks the product whether the composer is a real text input** before owning it, using two
+  product-owned attributes it never writes itself: `aria-haspopup="menu"` (picker trigger) and `aria-disabled="true"`
+  (blocked composer / removed session / offline parent). When it is not an input, the takeover stays completely out of
+  the way: no card marker, no seat, no swallowed tap — the product's own picker tap works.
+- That question is answered **live** (`MutationObserver` on those two attributes): the moment the workspace resolves
+  and the composer becomes a real input, the takeover attaches — no latch.
+- Belt and braces: the takeover only ever writes `contenteditable="false"`, so any observed `"true"` is the product
+  making its composer editable again — the field's `readOnly` is cleared then, so a latched field can never outlive
+  the state that caused it.
+
+**v0.7.3 (phone report: with the native input on, typed text left the bottom-right send button grey — it looked like nothing could be sent)**: the button is derived from the MACHINE draft, and the takeover keeps that draft deliberately stale while the user types (the ArkWeb lesson: commit points only). So the product kept believing the composer was empty and left its send button disabled at 40 % opacity. The old bridge (replay the tap on the button the commit enabled) depended on the engine re-testing that control after the pointer had already landed, which differs per engine — and under a running turn the same button wore the Stop square, so a tap could interrupt instead of send.
+
+Two fixes:
+
+- **The look**: the machine draft is stale, but the FIELD knows whether it holds text, and `:placeholder-shown` is the one pure-CSS value probe. While the field holds text and the machine draft is still empty, the takeover paints that button enabled (opacity 1, pointer cursor, pressed feedback) — **zero DOM writes**, the hard rule stands. Once the draft is in sync (e.g. after a commit) the button is left exactly as the product renders it.
+- **The gesture**: the card's capture `pointerdown` now recognises the submit control (the trailing row's last primary button; an interruptible child's extra Stop circle renders before it) and, when a draft is still uncommitted, **takes the gesture**: commit the draft, then run **the product's own send gesture** — the same path Enter takes (slash adjudication, busy policy, steer/queue). One tap, one send, no engine timing involved. Under a running turn the button now wears the send arrow while the field holds text (the Stop square is hidden and the product's own arrow path is painted as a mask), so face and gesture agree.
+
 **Escape hatch**: a small tool-row button (**输入法✓ / 输入法✗**, narrow viewports only) swaps back to the stock
 input box and remembers the choice — no device can be left stuck.
 
@@ -216,14 +245,20 @@ things, that **typing writes nothing to the page DOM**.
 - While the takeover is active, inline chip/decoration rendering inside the draft (e.g. `@` reference decorations) is not shown; entering a command claim switches back to the stock editor automatically.
 - Pasting an image is implemented by forwarding the paste to the official attachment intake; browsers that refuse a constructed paste event fall back to the paperclip picker.
 - IME candidate/assist behavior itself belongs to the system keyboard and is outside the plugin's control.
+- **While a turn streams and the field holds uncommitted text**, that button means Send (queue/steer) and no Stop affordance is offered — clear the field to interrupt. This matches the product's own choice of Send as the primary action whenever a draft exists.
 
 ## Development
 
 ```sh
 npm install --no-save jsdom react@18 react-dom@18
-node test/takeover.test.mjs     # runs the real client bundle in a jsdom composer card
+node test/takeover.test.mjs      # runs the real client bundle in a jsdom composer card
+node test/probe-live.mjs <token> # live app: takeover contract + diagnostics switches (CDP, 390x844)
+node test/probe-send.mjs <token> # live app: the send button's look, one-tap send, the running turn
 ```
 
+The launch token comes from `journalctl --user -u dsh-web | grep -o 'token=[A-Za-z0-9_-]*' | tail -1`
+(a new one per restart; the probes spend it on their first navigation).
+
 The test boots the shipped `lib/client.js`, renders the slot entry through React against a
 composer-card DOM, and asserts the render path, the draft mirror (typing / IME composition /
 machine-side writes), the Enter gesture, and the phase gate that hands the surface back to the

package/README.zh.md

@@ -30,6 +30,7 @@
 5. **切会话不自动聚焦** —— 官方在每次挂载/切换会话时把焦点还给输入框（桌面便利设计），手机上会弹出输入法占掉半屏。窄屏时拦截这类程序化聚焦；你主动点输入框时照常聚焦。
 6. **workspace 行操作按钮常显** —— 分组行与会话行尾部的按钮（⋯ 菜单含重命名/删除、＋ 在该 workspace 新建会话）官方仅在悬停时显示；触屏没有悬停，窄屏下侧边栏列表渲染时常显这两个按钮。
 7. **原生输入框接管** —— 输入区绘制成原生 textarea，外观、内边距、字号行高与官方完全一致（几何按官方输入区实时测量对齐）。回车仍是官方发送手势（含 `/` 菜单仲裁、busy-Enter 策略），粘贴图片转发给官方附件入口，锁定态跟随官方可编辑性开关。
+8. **发送按钮跟「输入框里有什么」走** —— 只要输入框里有字，右下角发送按钮就是**可点的亮色**（不再是灰的），点一下即发送（运行中的回合则是排队/引导）；打字期间这个状态由纯 CSS 驱动，**零 DOM 写入**，不破坏「打字期零 DOM 变动」这条硬约束。
 
 桌面端（宽视口）完全不受影响。
 
@@ -99,6 +100,7 @@ localStorage.removeItem("dsh-mobile-flow:growth");       // 恢复默认
 - 往上滑几屏——输入框和确认卡片应随消息滚出屏幕。
 - 输入区应是原生 textarea（页面里存在 `[data-mobile-input]`）。用输入法打字/语音输入，文字不应被自动清除。
 - 发送：点发按钮或按回车（回车等同官方发送手势）。
+- 发送按钮状态：**输入框里有字时按钮就是亮色可点的**（灰→亮由字段内容驱动）；点一下即发送，一次点击一条消息。
 - 工具行应有**两个小按钮**：「输入法✓」（逃生通道）与「诊断」（开测试台）。
 - 关键回归点（v0.6.0）：**打字期间不要有任何布局跳动**——字段高度在聚焦期间不变，失焦后才按内容长高。
 - 拉宽窗口即恢复官方行为。
@@ -153,6 +155,21 @@ localStorage.removeItem("dsh-mobile-flow:growth");       // 恢复默认
 
 **v0.7.1**：工具行清爽化——日常只留 **「输入法✓/✗」** 一个按钮（逃生通道），**长按 600ms** 才把 **「诊断」** 按钮叫出来（再长按收起）；诊断开着时「诊断」「复制日志」两个按钮自动出现，方便你取日志或关掉。
 
+**v0.7.3（手机反馈：勾选「输入法」后输入文本，右下角发送按钮是灰的，像没法发）**：根因是**按钮读的是机器草稿，而接管期间机器草稿故意是旧的**——打字时插件只在提交点才回写草稿（ArkWeb 收键盘的教训），于是官方发送按钮一直以为输入框是空的，保持禁用（40% 透明度的灰）。旧代码虽然写了「提交后补发点击」的桥接，但它依赖引擎在指针落下之后再复查一次这个刚被"点亮"的按钮，不同引擎结果不一样，且运行中的回合还会把 Stop 方块画在这颗按钮上（点下去可能变成打断）。
+
+改法两条：
+
+- **外观**：机器草稿是旧的，但**字段自己知道有没有字**，而 `:placeholder-shown` 是纯 CSS 里唯一能读字段值的探针。于是接管卡片在「字段有字 + 机器草稿仍为空」时把发送按钮画成启用态（opacity 1、手型光标、按下有反馈）——**零 DOM 写入**，硬约束不破；机器草稿已经同步（如已提交）时不动它，保持官方原样。
+- **手势**：卡片捕获阶段的 `pointerdown` 判断「点的是不是提交按钮（trailing 行里最后一颗 primary，可中断子会话额外的 Stop 圆钮在它前面）」且「还有未提交的文字」，是则**拿走这次手势**：先落草稿，再走**官方自己的发送手势**（与回车同一条路：斜杠仲裁、busy 策略、排队/引导），一次点击一条消息，不再看引擎脸色。运行中的回合里，字段有字时按钮**换成发送箭头**（隐藏官方的 Stop 方块，用官方同一份箭头 path 画 mask），点它就是发送——脸和手势一致。
+
+**v0.7.2（手机反馈：新建会话后点输入框没反应）**：新会话刚建出来、**workspace 还没解析出来**时，官方卡片其实是「选择工作区」的**选择器触发器**（`aria-haspopup="menu"`、`contenteditable="false"`、没有绑编辑器），根本不是输入框。旧版接管照样压上去，还把这份「不可编辑」**锁存**成原生 textarea 的 `readOnly` —— 于是：点输入框**不弹键盘、不出现光标**，同时把官方那记「打开选择器」的点击吞掉，用户既不能打字也打不开选择器；而且 workspace 解析好之后它**不会自愈**（只有换会话重新挂载才恢复），正好对上「第一次新建会话没反应、切走再新建就好」的现象（2026-09-19）。
+
+处理：
+
+- 接管前先问产品一句「**你现在真是输入框吗**」——只看产品自己写、插件从不碰的两个属性：`aria-haspopup="menu"`（workspace 选择器触发器）与 `aria-disabled="true"`（被 blocked / removed / 离线父会话锁住）。不是输入框就**完全不接管**：不标记卡片、不渲染 seat、不吞点击，官方那记点击照常打开选择器。
+- 这份判断**跟着产品实时更新**（`MutationObserver` 盯着这两个属性），workspace 一解析好、产品把 composer 变成真输入框，接管立刻接上——不再有「锁存」。
+- 兜底自愈：插件只会把官方编辑器写成 `contenteditable="false"`，所以只要观测到 `"true"` 就一定是产品自己恢复可编辑 —— 此时同步把字段的 `readOnly` 解开（历史上被锁存的字段不再永久失灵）。
+
 **逃生开关**：输入框工具行新增小按钮 **「输入法✓ / 输入法✗」**（仅窄屏显示）——一键在原生输入框与官方输入框之间切换并记住选择；任何设备上都不会被卡死。
 
 **诊断（工具行「诊断」按钮，或 URL `?dsh-mobile-input=bench` / `,debug`）**：
@@ -175,6 +192,7 @@ localStorage.removeItem("dsh-mobile-flow:growth");       // 恢复默认
 - 原生接管期间，输入区内联的 chip/装饰（如 `@` 引用装饰）不显示；进入命令 claim 阶段会自动切回官方编辑器。
 - 移动端「粘贴图片」通过转发给官方附件入口实现，浏览器若不允许构造粘贴事件则退化为用回形针按钮选择文件。
 - 输入法自身的候选词栏/联想行为由系统输入法决定，插件无法控制。
+- **回合运行中 + 输入框里有未提交文字**时，那颗按钮是「发送」（排队/引导），不再提供「停止」——想打断这个回合就先清空输入框（清空后按钮立刻变回 Stop）。这与官方「草稿非空时主按钮是发送」的取向一致。
 
 ## 开发与自测
 
@@ -183,6 +201,7 @@ npm install --no-save jsdom react@18 react-dom@18
 node test/takeover.test.mjs                          # jsdom：渲染 + 打字路径（含"打字期零 DOM 写入"断言）
 node test/facts-probe.mjs <token>                    # 真实页面：DOM/CSS 结构与引擎能力
 node test/probe-live.mjs <token>                     # 真实页面：接管契约 + 诊断开关（CDP，390x844 移动视口）
+node test/probe-send.mjs <token>                     # 真实页面：发送按钮的亮色状态 + 一次点击发送 + 运行中回合
 ```
 
 token 取自 `journalctl --user -u dsh-web | grep -o 'token=[A-Za-z0-9_-]*' | tail -1`（每次重启换新；单次有效，探针只用一次）。

package/lib/client.js

@@ -156,6 +156,47 @@ window.__ModuleLoader__.load({
       "  color: var(--dsw-alias-label-tertiary);",
       "  cursor: not-allowed;",
       "}",
+      "/* Send-button honesty (phone report 2026-09-21: text typed, the send",
+      "   button stays grey — it reads as \"cannot send\"). The product derives",
+      "   that button from the MACHINE draft, and the takeover keeps the machine",
+      "   draft deliberately stale while the user types (the ArkWeb fix), so a",
+      "   filled field sits next to a disabled, 40%-opacity button. The field's",
+      "   own value state is the truth the eye needs, and :placeholder-shown is",
+      "   the one PURE-CSS value probe — no DOM write, which is the hard rule",
+      "   while a field has focus. The gesture is carried by the commit bridge in",
+      "   the card's capture pointerdown, so the look and the tap agree: one tap,",
+      "   one send. The submit button is the trailing row's LAST primary control;",
+      "   an interruptible child's extra Stop circle renders before it. */",
+      "[data-composer-card][data-mobile-input-active]:has([data-mobile-input]:not(:placeholder-shown)) [class*='_trailing'] > [class*='_primary']:last-child:disabled {",
+      "  opacity: 1;",
+      "  cursor: pointer;",
+      "}",
+      "/* Pressed feedback for that same button: the product's own :active rules",
+      "   only cover the enabled state, and a tap with no visible answer reads as",
+      "   a dead control. */",
+      "[data-composer-card][data-mobile-input-active]:has([data-mobile-input]:not(:placeholder-shown)) [class*='_trailing'] > [class*='_primary']:last-child:disabled:active {",
+      "  opacity: 0.72;",
+      "}",
+      "/* The running-turn case: while a turn streams, the product puts its Stop",
+      "   square on that button (its stale-empty draft tells it the composer holds",
+      "   nothing, so interrupting is the only action left). With text in the",
+      "   field the tap SENDS — the bridge turns it into the product's own submit",
+      "   gesture (queue / steer under a running turn) — so the face has to say",
+      "   send. Gated on the machine draft still being EMPTY (the stock editor is",
+      "   never empty in that state), so the arrow only ever replaces the Stop",
+      "   square and never the product's own send arrow. The glyph is the",
+      "   product's own arrow: 16px, currentColor on the blue fill. */",
+      "[data-composer-card][data-mobile-input-active]:has([data-composer-input]:empty):has([data-mobile-input]:not(:placeholder-shown)) [class*='_trailing'] > [class*='_primary']:last-child:not(:disabled) > svg {",
+      "  display: none;",
+      "}",
+      "[data-composer-card][data-mobile-input-active]:has([data-composer-input]:empty):has([data-mobile-input]:not(:placeholder-shown)) [class*='_trailing'] > [class*='_primary']:last-child:not(:disabled)::after {",
+      "  content: '';",
+      "  width: 16px;",
+      "  height: 16px;",
+      "  background: currentColor;",
+      "  -webkit-mask: url(\"data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Cpath d='M8.3125 0.980183C8.66767 1.0531 8.97902 1.20418 9.2627 1.43233C9.48724 1.61297 9.73029 1.85793 9.97949 2.10714L14.707 6.83468L13.293 8.24874L9 3.95577V15.0417H7V3.95577L2.70703 8.24874L1.29297 6.83468L6.02051 2.10714C6.26971 1.85793 6.51277 1.61297 6.7373 1.43233C6.97662 1.23986 7.28445 1.04402 7.6875 0.980183C7.8973 0.947006 8.1031 0.95516 8.3125 0.980183Z' fill='%23000'/%3E%3C/svg%3E\") center / 16px 16px no-repeat;",
+      "  mask: url(\"data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Cpath d='M8.3125 0.980183C8.66767 1.0531 8.97902 1.20418 9.2627 1.43233C9.48724 1.61297 9.73029 1.85793 9.97949 2.10714L14.707 6.83468L13.293 8.24874L9 3.95577V15.0417H7V3.95577L2.70703 8.24874L1.29297 6.83468L6.02051 2.10714C6.26971 1.85793 6.51277 1.61297 6.7373 1.43233C6.97662 1.23986 7.28445 1.04402 7.6875 0.980183C7.8973 0.947006 8.1031 0.95516 8.3125 0.980183Z' fill='%23000'/%3E%3C/svg%3E\") center / 16px 16px no-repeat;",
+      "}",
       "/* Escape hatch in the composer tool row (narrow viewports only): one tap",
       "   returns the stock input box when the native one misbehaves on a device",
       "   we cannot test on. Its neighbour switches the diagnostics surfaces on",
@@ -723,6 +764,40 @@ window.__ModuleLoader__.load({
       }
     }
 
+    /**
+     * Whether the product's composer on this card is a LIVE TEXT INPUT.
+     *
+     * The resident composer card is reused for states that are not inputs at
+     * all: a blank-session hero whose workspace is not resolved yet renders the
+     * same surface as a workspace-PICKER trigger (tapping it opens the picker,
+     * `editor={null}`, `contenteditable="false"`), and a blocked/removed/offline
+     * session renders it disabled. The takeover must not own those surfaces: a
+     * read-only field that swallows the card's own tap is worse than no
+     * takeover — the user cannot type AND cannot open the picker.
+     *
+     * Two product-owned attributes carry that fact and the takeover never
+     * writes either (see the "no workspace yet" note on the editability refs):
+     *   - `aria-haspopup="menu"` — the workspace-picker trigger state
+     *   - `aria-disabled="true"` — the locked states (blocked composer, removed
+     *     session, offline parent)
+     * `contenteditable` is deliberately NOT consulted here: the takeover forces
+     * it to "false" while it owns the surface, so reading it once at mount and
+     * latching the answer is what left a phone with a permanently read-only
+     * field (v0.7.2 phone report: "new session, tapping the input box does
+     * nothing").
+     *
+     * @param card - the resident composer card, or null.
+     * @returns true when the card currently hosts a real text input.
+     */
+    function composerIsTextInput(card) {
+      if (card === null || typeof card.querySelector !== "function") return false;
+      var editor = card.querySelector("[data-composer-input]");
+      if (editor === null) return false;
+      if (editor.getAttribute("aria-haspopup") === "menu") return false;
+      if (editor.getAttribute("aria-disabled") === "true") return false;
+      return true;
+    }
+
     /** Whether the takeover should own the surface on this viewport. */
     function takeoverLive(media) {
       var override = readOverride();
@@ -832,9 +907,16 @@ window.__ModuleLoader__.load({
       var sessionId = props.sessionId;
       var actions = props.inputActions;
       var phase = input === undefined ? "plain" : input.phase;
+      /* Whether the product's composer is a real text input right now. Tracked
+         live (see the mount effect below), never latched: a new session is
+         routinely created before its workspace resolves, and that hero composer
+         is a workspace-picker trigger, not an input. */
+      var readyPair = React.useState(false);
+      var composerReady = readyPair[0];
+      var setComposerReady = readyPair[1];
       /* Ownership is surface-level only: claims fall back to the stock editor
          (see the section comment). */
-      var active = live && phase === "plain" && sessionId !== undefined;
+      var active = live && composerReady && phase === "plain" && sessionId !== undefined;
 
       var wrapRef = React.useRef(null);
       var areaRef = React.useRef(null);
@@ -855,9 +937,17 @@ window.__ModuleLoader__.load({
       /* Whether the takeover currently owns the surface (read by handlers that
          outlive a render). */
       var activeRef = React.useRef(false);
-      /* The stock editor's own editability, captured before the takeover forces
-         contenteditable="false" (the field mirrors THIS, not our own override). */
-      var stockEditableRef = React.useRef(true);
+      /* The product's editability intent for the composer, kept across takeover
+         releases. The field mirrors THIS, never our own override: the takeover
+         forces contenteditable="false" while it owns the surface, so the
+         attribute cannot be read back as the product's answer. `forcedRef` marks
+         a "false" that is ours. (A latched read-only field used to survive the
+         composer becoming editable again — one phone report: a new session whose
+         workspace was not resolved yet left the input dead until the next
+         session switch.) */
+      var appEditableRef = React.useRef(true);
+      /* True while the "false" standing on the product's editor is OUR force. */
+      var forcedRef = React.useRef(false);
       /* Last geometry applied: style writes are skipped when nothing moved, so
          a strict engine's IME is not disturbed by pointless relayouts. */
       var geometryRef = React.useRef("");
@@ -875,6 +965,34 @@ window.__ModuleLoader__.load({
         return wrap === null ? null : wrap.closest("[data-composer-card]");
       };
 
+      /* Is the product's composer a text input right now? Re-answered on every
+         product-side change of the two attributes that decide it, whether the
+         takeover is active or not — that is what lets the surface be handed
+         back when a new session opens without a resolved workspace, and taken
+         over again the moment the composer becomes an input. */
+      React.useEffect(function () {
+        var card = cardOf();
+        var update = function () {
+          var next = composerIsTextInput(cardOf());
+          setComposerReady(function (previous) {
+            if (previous !== next) {
+              debug("composer " + (next ? "is a text input -> takeover may own it"
+                : "is NOT a text input (picker/locked) -> stock surface stays"));
+            }
+            return next;
+          });
+        };
+        update();
+        if (card === null || typeof window.MutationObserver !== "function") return undefined;
+        var observer = new window.MutationObserver(update);
+        observer.observe(card, {
+          attributes: true,
+          attributeFilter: ["aria-haspopup", "aria-disabled"],
+          subtree: true,
+        });
+        return function () { observer.disconnect(); };
+      }, []);
+
       /* The one invariant this whole file is built around (see the section
          comment): while the field has focus the plugin writes NOTHING to the
          DOM. Every measurement, resize and chrome sync below starts with this
@@ -995,17 +1113,32 @@ window.__ModuleLoader__.load({
         var editor = card === null ? null : card.querySelector("[data-composer-input]");
         if (editor === null) return;
         var placeholder = editor.getAttribute("data-placeholder");
-        if (placeholder !== null && area.placeholder !== placeholder) area.placeholder = placeholder;
+        /* A surface that renders no placeholder still gets an invisible one:
+           the CSS that keeps the send button honest reads the field's value
+           state through :placeholder-shown, which needs the attribute to be
+           there at all. */
+        if (placeholder === null || placeholder === "") placeholder = " ";
+        if (area.placeholder !== placeholder) area.placeholder = placeholder;
         /* The product's own gate (locked / inert / takeover states) rides this
-           attribute; mirror it instead of re-deriving the policy. */
-        var editable = activeRef.current
-          ? stockEditableRef.current
-          : editor.getAttribute("contenteditable") !== "false";
+           attribute; mirror it instead of re-deriving the policy. The takeover
+           only ever writes "false" AND marks those writes, so an unmarked value
+           is the product speaking: "true" means it made its composer editable
+           again, which must clear any latched read-only state (see
+           `composerIsTextInput`). */
+        if (!forcedRef.current && editor.getAttribute("contenteditable") === "false") {
+          appEditableRef.current = false;
+        } else if (editor.getAttribute("contenteditable") !== "false") {
+          if (appEditableRef.current === false) debug("stock editor editable again");
+          appEditableRef.current = true;
+          forcedRef.current = false;
+        }
+        var editable = appEditableRef.current;
         /* Keep the stock editor out of the browser's editable set for as long
            as the takeover owns the surface (React re-applies its own value only
            when the prop changes, so ours sticks until then). */
         if (activeRef.current && editor.getAttribute("contenteditable") !== "false") {
           editor.setAttribute("contenteditable", "false");
+          forcedRef.current = true;
           debug("re-forced contenteditable=false");
         }
         if (area.readOnly === editable) area.readOnly = !editable;
@@ -1043,11 +1176,16 @@ window.__ModuleLoader__.load({
             var hadInert = editor.hasAttribute("inert");
             var hadAria = editor.getAttribute("aria-hidden");
             var hadEditable = editor.getAttribute("contenteditable");
-            stockEditableRef.current = hadEditable !== "false";
+            /* Trust the product's value unless the "false" standing there is
+               the one we wrote ourselves. */
+            if (!forcedRef.current || hadEditable !== "false") {
+              appEditableRef.current = hadEditable !== "false";
+            }
             if (typeof editor.inert === "boolean") editor.inert = true;
             else editor.setAttribute("inert", "");
             editor.setAttribute("aria-hidden", "true");
             editor.setAttribute("contenteditable", "false");
+            forcedRef.current = true;
             restore = function () {
               if (!hadInert) {
                 if (typeof editor.inert === "boolean") editor.inert = false;
@@ -1055,8 +1193,17 @@ window.__ModuleLoader__.load({
               }
               if (hadAria === null) editor.removeAttribute("aria-hidden");
               else editor.setAttribute("aria-hidden", hadAria);
-              if (hadEditable === null) editor.removeAttribute("contenteditable");
-              else editor.setAttribute("contenteditable", hadEditable);
+              /* Hand editability back to the product — but only while it still
+                 wants an input. When the takeover is released because the
+                 product locked the composer (picker trigger / blocked session),
+                 our own "false" IS the product's answer and must stand: writing
+                 the pre-takeover "true" back would re-enable a surface the
+                 product has just disabled (and hand the IME a hidden editable
+                 again — the exact bug the inert/aria-hidden pair exists for). */
+              if (composerIsTextInput(card)) {
+                editor.setAttribute("contenteditable", appEditableRef.current ? "true" : "false");
+                forcedRef.current = false;
+              }
             };
           }
         } else {
@@ -1459,6 +1606,18 @@ window.__ModuleLoader__.load({
           }
           return null;
         };
+        /** The composer's submit control: the trailing row's LAST primary
+            button (an interruptible child's extra Stop circle renders before
+            it). It is the one control whose gate AND face read the machine
+            draft — exactly the state the takeover keeps stale while typing. */
+        var submitAt = function (button) {
+          if (button === null || typeof button.className !== "string"
+            || button.className.indexOf("_primary") < 0) return false;
+          var trailing = typeof button.closest === "function" ? button.closest("[class*='_trailing']") : null;
+          if (trailing === null) return false;
+          var primaries = trailing.querySelectorAll("[class*='_primary']");
+          return primaries.length !== 0 && primaries[primaries.length - 1] === button;
+        };
         var onPointerDown = function (event) {
           var area = areaRef.current;
           var wrap = wrapRef.current;
@@ -1478,17 +1637,24 @@ window.__ModuleLoader__.load({
             }
             return;
           }
-          /* Outside the field: a toolbar action whose gate may depend on the
-             draft (the send button is disabled while the machine draft is
-             empty). Commit first, then replay the tap on a button our commit
-             just enabled. */
+          /* Outside the field: a toolbar action. Everywhere else the commit is
+             bookkeeping and the gesture runs untouched. The submit button is
+             the exception: its gate AND its face read the machine draft, so
+             while the user types they describe a composer the product has not
+             heard about yet — a grey send button that a tap may never reach,
+             or the running turn's Stop square on a button whose tap means
+             send. Commit first (the submit reads the machine draft), then run
+             the product's own send gesture — the same path Enter takes (slash
+             adjudication, busy policy, steer/queue) — so one tap is one send,
+             whatever the engine would have made of the stale control. */
           var button = buttonAt(x, y);
-          var wasDisabled = button !== null && button.disabled === true;
-          mirrorNow();
-          if (button !== null && wasDisabled && button.disabled === false) {
+          if (submitAt(button) === true && pendingRef.current !== null) {
             event.preventDefault();
-            window.setTimeout(function () { button.click(); }, 0);
+            mirrorNow();
+            debug("carry tap -> " + (sendGesture() ? "submit" : "nothing"));
+            return;
           }
+          mirrorNow();
         };
         /* Engines without a working inert: if anything hands focus back to the
            stock editor, take it straight back to the field. */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-mobile-flow",
-  "version": "0.7.1",
-  "description": "Mobile fixes for the DeepSeek Harness Web UI: on narrow (≤720px) screens the input bar and AI confirmation cards scroll with the page instead of pinning to the viewport floor, edges slim down, session switches no longer auto-focus the input, workspace row actions stay visible, and the draft surface becomes a native textarea (ArkWeb/Android-IME hardened: zero DOM writes while typing, resizing only at commit points, with a tool-row escape hatch and an on-device diagnostics bench) so mobile IMEs stop clearing typed text and stop dropping the keyboard.",
+  "version": "0.7.3",
+  "description": "Mobile fixes for the DeepSeek Harness Web UI: on narrow (≤720px) screens the input bar and AI confirmation cards scroll with the page instead of pinning to the viewport floor, edges slim down, session switches no longer auto-focus the input, workspace row actions stay visible, and the draft surface becomes a native textarea (ArkWeb/Android-IME hardened: zero DOM writes while typing, resizing only at commit points, with a tool-row escape hatch and an on-device diagnostics bench) so mobile IMEs stop clearing typed text and stop dropping the keyboard; the send button follows the field's content (live as soon as there is text, one tap sends), not the deliberately stale machine draft.",
   "license": "MIT",
   "type": "module",
   "main": "lib/index.js",
@@ -40,7 +40,7 @@
     "css"
   ],
   "scripts": {
-    "test": "node test/takeover.test.mjs"
+    "test": "node test/takeover.test.mjs && node test/input-gate.test.mjs"
   },
   "devDependencies": {
     "jsdom": "^27.0.0",