dsh-mobile-flow 0.7.1 → 0.7.2

package/README.md

@@ -190,6 +190,26 @@ 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.
+
 **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.
 

package/README.zh.md

@@ -153,6 +153,14 @@ localStorage.removeItem("dsh-mobile-flow:growth");       // 恢复默认
 
 **v0.7.1**：工具行清爽化——日常只留 **「输入法✓/✗」** 一个按钮（逃生通道），**长按 600ms** 才把 **「诊断」** 按钮叫出来（再长按收起）；诊断开着时「诊断」「复制日志」两个按钮自动出现，方便你取日志或关掉。
 
+**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`）**：

package/lib/client.js

@@ -723,6 +723,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 +866,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 +896,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 +924,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
@@ -997,15 +1074,25 @@ window.__ModuleLoader__.load({
         var placeholder = editor.getAttribute("data-placeholder");
         if (placeholder !== null && 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 +1130,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 +1147,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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-flow",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "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.",
   "license": "MIT",
   "type": "module",
@@ -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",