dsh-zen-remote 1.1.6 → 1.1.7

package/README.md

@@ -3,7 +3,7 @@
 
 <p align="center">
 <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-0B7285?style=flat-square" alt="MIT"></a>
-<img src="https://img.shields.io/badge/release-v1.1.6-5B4CF0?style=flat-square" alt="v1.1.6">
+<img src="https://img.shields.io/badge/release-v1.1.7-5B4CF0?style=flat-square" alt="v1.1.7">
 <img src="https://img.shields.io/badge/DSH-Web%20Profile-5B4CF0?style=flat-square" alt="DSH Web Profile">
 </p>
 
@@ -39,7 +39,7 @@ dsh plugin add dsh-zen-remote
 ```jsonc
 {
   "dependencies": {
-    "dsh-zen-remote": "^1.1.6"        // 本地开发换成 "link:/path/to/dsh-zen-remote"
+    "dsh-zen-remote": "^1.1.7"        // 本地开发换成 "link:/path/to/dsh-zen-remote"
   },
   "dsh": { "profile": { "bundles": [
     "@deepseek-ai/dsh-base",

package/lib/client.js

@@ -5505,6 +5505,14 @@ const PHONE_QUERY = '(max-width: 767px)';
  *   `=0` opts back out). */
 const DESKTOP_KEY = 'dsh-mobile-nav.turn-fold-desktop';
 const DESKTOP_PARAM = 'mobile-nav-turn-fold';
+/** Last answer the row config gave. The fetch is a round-trip and the phone
+ * breakpoint is not, so a desktop reader used to watch a whole session render
+ * unfolded and then collapse at once, every page load (issue #3). Remembering
+ * the answer switches the fold on before first paint from the second load on.
+ * Enable-only: turning the row knob back off clears this, so that load still
+ * folds and the next one does not — a stale fold is a chip click away, a
+ * one-way `disableDesktop` is a state machine nobody asked for. */
+const DESKTOP_CACHE_KEY = 'dsh-mobile-nav.turn-fold-desktop-seen';
 /** Root attribute the stylesheet keys the width-independent rules on. */
 const DESKTOP_ATTR = 'data-mnav-desktop-fold';
 /** Read (and, when the URL param is present, persist) the per-browser opt-in. */
@@ -5543,10 +5551,12 @@ const TURN_HEAD_KINDS = new Set(['user', 'steering']);
 /** ReasoningRow's own marker (lib/client.js:8966) — the Think disclosure
  * rendered inside an assistant-step row, beside that step's prose. */
 exports.THINK = '[data-variant="think"]';
-/** Attribute the phone stylesheet turns into `display: none`. Still written
- * per element for the one case the stylesheet cannot express on its own: an
- * assistant-step row whose entire body is reasoning, which has to go as a
- * whole row (see {@link foldsWholeRow}). */
+/** Attribute the phone stylesheet turns into `display: none`. Written for the
+ * one case the stylesheet cannot express on its own: an assistant-step row
+ * whose entire body is reasoning, which has to go as a whole row (see
+ * {@link foldsWholeRow}). Because it is the only thing hiding that row, it is
+ * written from {@link markWholeRows} in the observer callback rather than the
+ * scan a frame later — see that function for what the frame cost. */
 const FOLD = 'data-mnav-fold';
 /** Per-item override written while its turn is expanded. */
 exports.OPEN = 'data-mnav-fold-open';
@@ -5557,6 +5567,8 @@ exports.OPEN = 'data-mnav-fold-open';
  * flashes in, then folds away" report, 2026-08-22); it also keeps the
  * stylesheet a no-op — content visible — if this effect never runs. */
 const ACTIVE_ATTR = 'data-mnav-fold-on';
+/** Selector of the one row kind that can fold whole — see {@link foldsWholeRow}. */
+const STEP_SELECTOR = '[data-chat-flow-kind="assistant-step"]';
 /**
  * True when the reasoning rows are the ONLY thing this row renders, so the
  * whole flow item has to go: the flow column is `display: flex` with
@@ -5727,14 +5739,73 @@ function installTurnFold(ctx) {
             // its row-level fold after prose started arriving in the same DOM node
             // (React updates the row in place), hiding the streaming reply until a
             // completion re-render rebuilt the row — the "reply only appears when
-            // the turn finishes" phone bug (2026-08-18).
-            for (const stale of flow.querySelectorAll(`[${FOLD}]`)) {
+            // the turn finishes" phone bug (2026-08-18). {@link OPEN} needs the
+            // same sweep on its own account: it is what releases a row from the
+            // stylesheet's reasoning rules, so a stale one shows the reasoning of
+            // a turn the reader has since folded.
+            for (const stale of flow.querySelectorAll(`[${FOLD}], [${exports.OPEN}]`)) {
                 if (liveItems.has(stale))
                     continue;
                 stale.removeAttribute(FOLD);
                 stale.removeAttribute(exports.OPEN);
             }
         };
+        /**
+         * Fold (or release) the reasoning-only rows this mutation batch touched,
+         * synchronously.
+         *
+         * The full {@link scan} is rAF-coalesced, and React commits after that
+         * frame's rAF phase, so a scan scheduled from a mutation lands one PAINTED
+         * frame later. For everything else that is invisible — the stylesheet
+         * already hid it by the host's own markers before the effect looked. For
+         * the whole-row fold, which nothing but {@link FOLD} hides, the reader saw
+         * that frame: a blank 16px band on the way in (the flow column's gap,
+         * which an emptied flex item still claims), and — worse — the row still
+         * hidden for a frame after prose started arriving into it, so the reply
+         * appeared to stutter (issue #3).
+         *
+         * A MutationObserver callback is a microtask: it runs at the end of the
+         * task that mutated the DOM, before that frame's rendering update. Marking
+         * here is therefore never a frame late, in either direction.
+         *
+         * ponytail: O(rows touched by the batch), not O(rows). If streaming ever
+         * feels heavy, the cheap win is skipping batches whose records are all
+         * characterData — the fold verdict only changes when elements do.
+         */
+        const markWholeRows = (records) => {
+            const rows = new Set();
+            for (const record of records) {
+                const target = record.target;
+                if (target instanceof Element) {
+                    const row = target.closest(STEP_SELECTOR);
+                    if (row !== null)
+                        rows.add(row);
+                }
+                for (const node of record.addedNodes) {
+                    if (!(node instanceof Element))
+                        continue;
+                    if (node.matches(STEP_SELECTOR))
+                        rows.add(node);
+                    for (const nested of node.querySelectorAll(STEP_SELECTOR))
+                        rows.add(nested);
+                }
+            }
+            for (const row of rows) {
+                // Exactly what {@link groupsOf} walks: a direct child of the chat flow
+                // column. This is the scoping that keeps the effect Chat-only — the
+                // mutation records reach the whole document, so without it a row in
+                // any other view that seats chat nodes would get hidden with no chip
+                // to bring it back. It also drops rows detached since the batch.
+                const parent = row.parentElement;
+                if (parent === null || !parent.matches(FLOW))
+                    continue;
+                const thinks = [...row.querySelectorAll(exports.THINK)];
+                if (thinks.length > 0 && foldsWholeRow(row, thinks))
+                    row.setAttribute(FOLD, '');
+                else
+                    row.removeAttribute(FOLD);
+            }
+        };
         const schedule = () => {
             // The locale subscription below lives outside attach/detach, so this
             // guard is what keeps a late dictionary registration from marking up
@@ -5770,7 +5841,7 @@ function installTurnFold(ctx) {
         const clear = () => {
             for (const chip of document.querySelectorAll(CHIP_SELECTOR))
                 chip.remove();
-            for (const item of document.querySelectorAll(`[${FOLD}]`)) {
+            for (const item of document.querySelectorAll(`[${FOLD}], [${exports.OPEN}]`)) {
                 item.removeAttribute(FOLD);
                 item.removeAttribute(exports.OPEN);
             }
@@ -5779,7 +5850,10 @@ function installTurnFold(ctx) {
             if (observer !== null)
                 return;
             document.documentElement.setAttribute(ACTIVE_ATTR, '');
-            observer = new MutationObserver(schedule);
+            observer = new MutationObserver((records) => {
+                markWholeRows(records);
+                schedule();
+            });
             observer.observe(document.body, { childList: true, subtree: true });
             document.addEventListener('click', onClick);
             scan();
@@ -5813,12 +5887,22 @@ function installTurnFold(ctx) {
         if (narrow.matches)
             attach();
         narrow.addEventListener('change', onChange);
-        if (desktopOptIn())
+        // Both switches are synchronous reads, so a returning reader folds before
+        // first paint. Not awaited before phone attach either — folding must not
+        // wait on a round-trip.
+        if (desktopOptIn() || localStorage.getItem(DESKTOP_CACHE_KEY) === '1')
             enableDesktop();
-        // The row config arrives async; a late enable just attaches then. Not
-        // awaited before phone attach — folding must not wait on a round-trip.
-        else
-            void desktopConfigured().then((on) => (on ? enableDesktop() : undefined));
+        // The row config still arrives async, and remains the authority: a late
+        // yes attaches then and is remembered, a no forgets. A late answer after
+        // dispose is a no-op inside enableDesktop.
+        void desktopConfigured().then((on) => {
+            if (on) {
+                localStorage.setItem(DESKTOP_CACHE_KEY, '1');
+                enableDesktop();
+            }
+            else
+                localStorage.removeItem(DESKTOP_CACHE_KEY);
+        });
         // A language switch changes the chip copy of every already-rendered turn.
         const stopLocale = ctx.locale.subscribe(schedule);
         return () => {
@@ -5855,6 +5939,8 @@ exports.TURN_FOLD_CSS = void 0;
 const turn_fold_ts_1 = require("./effects/turn-fold.js");
 /** Mirror of the root attribute effects/turn-fold.ts holds while attached. */
 const ACTIVE = 'data-mnav-fold-on';
+/** One assistant-step row, inside an active fold. */
+const STEP = `html[${ACTIVE}] [data-chat-flow] > [data-chat-flow-kind="assistant-step"]`;
 /**
  * Born folded — the reason a new tool call no longer blinks into view.
  *
@@ -5871,21 +5957,43 @@ const ACTIVE = 'data-mnav-fold-on';
  * block is live for exactly the widths the fold is, and hides nothing at all
  * when the effect never ran.
  *
- * One case stays with the effect: an assistant-step row whose whole body is
- * reasoning has to be hidden as a row (an emptied-out flex item still claims
- * the flow column's 16px gap), and "this row has nothing but Think in it" is
- * not a selector. Its rows therefore still fold a frame late — as blank
- * space, not as content, since the Think rows below are hidden here.
+ * The Think rule reads {@link OPEN} off the ROW as well as off the block:
+ * a row folded whole (see {@link WHOLE_STEP}) is the item the effect marks,
+ * so an expanded turn carries the override on the row and its reasoning
+ * would otherwise stay hidden behind this rule — the reader clicked the chip
+ * and got an empty band (issue #3, 2026-08-25).
  */
 const BORN_FOLDED = [
     ...turn_fold_ts_1.PROCESS_KINDS.map((kind) => `html[${ACTIVE}] [data-chat-flow] > [data-chat-flow-kind="${kind}"]:not([${turn_fold_ts_1.OPEN}])`),
-    `html[${ACTIVE}] [data-chat-flow] > [data-chat-flow-kind="assistant-step"] ${turn_fold_ts_1.THINK}:not([${turn_fold_ts_1.OPEN}])`,
+    `${STEP}:not([${turn_fold_ts_1.OPEN}]) ${turn_fold_ts_1.THINK}:not([${turn_fold_ts_1.OPEN}])`,
 ].join(',\n');
+/*
+ * The one folded item with no selector of its own: an assistant-step row that
+ * holds reasoning and nothing else. It has to go as a ROW — the flow column is
+ * `display: flex` with `gap: 16px`, so a row whose every child is hidden still
+ * claims its gap and the reader sees a blank band — and "this row has nothing
+ * but Think in it" cannot be written as a selector.
+ *
+ * `:has()` looks like it can: "holds reasoning, holds no content block that is
+ * not reasoning". It cannot, safely. Every wrapper between the row and the
+ * blocks is itself a non-reasoning element, so the guard has to name the exact
+ * depth of the blocks — and the real tree is
+ * flowItem > seat > AssistantMarkdown root > body > blocks, one level deeper
+ * than the host's own component suggests, because the slot seat adds a wrapper
+ * the component never sees. A selector pinned to that depth silently stops
+ * matching the day a wrapper moves, with nothing to say why.
+ *
+ * So the row stays with effects/turn-fold.ts, which walks the tree instead of
+ * assuming its shape — but marks it synchronously in the MutationObserver
+ * callback (a microtask, before the frame paints) rather than a rAF later.
+ */
 /** The fold + chip rules, with every selector prefixed by `scope`. */
 const rules = (scope) => `
-  /* Folded process: tool-call / context / command rows and the Think
-     disclosures inside an assistant step. !important because the official
-     flow item and ReasoningRow both set their own display. */
+  /* The reasoning-only row (see above), which effects/turn-fold.ts marks
+     itself because no selector can find it. Everything else is already hidden
+     by BORN_FOLDED, by the host's own markers — this rule is what that one
+     case rides on. !important because the official flow item and ReasoningRow
+     both set their own display. */
   ${scope} [data-mnav-fold]:not([data-mnav-fold-open]) {
     display: none !important;
   }

package/lib/types/client/effects/turn-fold.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"turn-fold.d.ts","sourceRoot":"","sources":["../../../../src/client/effects/turn-fold.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAA;AA0C3E;;;;;;;sDAOsD;AACtD,eAAO,MAAM,aAAa,8CAA+C,CAAA;AAMzE;sEACsE;AACtE,eAAO,MAAM,KAAK,6BAA2B,CAAA;AAO7C,4DAA4D;AAC5D,eAAO,MAAM,IAAI,wBAAwB,CAAA;AAyFzC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CA0JxD"}
+{"version":3,"file":"turn-fold.d.ts","sourceRoot":"","sources":["../../../../src/client/effects/turn-fold.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAA;AAkD3E;;;;;;;sDAOsD;AACtD,eAAO,MAAM,aAAa,8CAA+C,CAAA;AAMzE;sEACsE;AACtE,eAAO,MAAM,KAAK,6BAA2B,CAAA;AAS7C,4DAA4D;AAC5D,eAAO,MAAM,IAAI,wBAAwB,CAAA;AA4FzC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CAyNxD"}

package/lib/types/client/styles/turn-fold.css.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"turn-fold.css.d.ts","sourceRoot":"","sources":["../../../../src/client/styles/turn-fold.css.ts"],"names":[],"mappings":"AAsIA,eAAO,MAAM,aAAa,QAyBzB,CAAA"}
+{"version":3,"file":"turn-fold.css.d.ts","sourceRoot":"","sources":["../../../../src/client/styles/turn-fold.css.ts"],"names":[],"mappings":"AAgKA,eAAO,MAAM,aAAa,QAyBzB,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-zen-remote",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "description": "把 DeepSeek Harness 变成手机 App：移动端界面重排（两级页面栈、会话列表主屏、composer 重排、手势、附件上传）+ 配对码认证网关 + PWA 安装 + 真 Web Push。Complete mobile plugin for DeepSeek Harness (DSH): app-shell mobile UI, pairing-code gateway for public-internet access behind your own reverse proxy, installable PWA, offline service worker, and real Web Push agent-done notifications.",
   "license": "MIT",
   "type": "module",

package/src/client/effects/turn-fold.ts

@@ -14,6 +14,14 @@ const PHONE_QUERY = '(max-width: 767px)'
  *   `=0` opts back out). */
 const DESKTOP_KEY = 'dsh-mobile-nav.turn-fold-desktop'
 const DESKTOP_PARAM = 'mobile-nav-turn-fold'
+/** Last answer the row config gave. The fetch is a round-trip and the phone
+ * breakpoint is not, so a desktop reader used to watch a whole session render
+ * unfolded and then collapse at once, every page load (issue #3). Remembering
+ * the answer switches the fold on before first paint from the second load on.
+ * Enable-only: turning the row knob back off clears this, so that load still
+ * folds and the next one does not — a stale fold is a chip click away, a
+ * one-way `disableDesktop` is a state machine nobody asked for. */
+const DESKTOP_CACHE_KEY = 'dsh-mobile-nav.turn-fold-desktop-seen'
 /** Root attribute the stylesheet keys the width-independent rules on. */
 const DESKTOP_ATTR = 'data-mnav-desktop-fold'
 
@@ -58,10 +66,12 @@ const TURN_HEAD_KINDS = new Set(['user', 'steering'])
  * rendered inside an assistant-step row, beside that step's prose. */
 export const THINK = '[data-variant="think"]'
 
-/** Attribute the phone stylesheet turns into `display: none`. Still written
- * per element for the one case the stylesheet cannot express on its own: an
- * assistant-step row whose entire body is reasoning, which has to go as a
- * whole row (see {@link foldsWholeRow}). */
+/** Attribute the phone stylesheet turns into `display: none`. Written for the
+ * one case the stylesheet cannot express on its own: an assistant-step row
+ * whose entire body is reasoning, which has to go as a whole row (see
+ * {@link foldsWholeRow}). Because it is the only thing hiding that row, it is
+ * written from {@link markWholeRows} in the observer callback rather than the
+ * scan a frame later — see that function for what the frame cost. */
 const FOLD = 'data-mnav-fold'
 /** Per-item override written while its turn is expanded. */
 export const OPEN = 'data-mnav-fold-open'
@@ -73,6 +83,9 @@ export const OPEN = 'data-mnav-fold-open'
  * stylesheet a no-op — content visible — if this effect never runs. */
 const ACTIVE_ATTR = 'data-mnav-fold-on'
 
+/** Selector of the one row kind that can fold whole — see {@link foldsWholeRow}. */
+const STEP_SELECTOR = '[data-chat-flow-kind="assistant-step"]'
+
 /**
  * True when the reasoning rows are the ONLY thing this row renders, so the
  * whole flow item has to go: the flow column is `display: flex` with
@@ -237,14 +250,67 @@ export function installTurnFold(ctx: ClientContext): void {
       // its row-level fold after prose started arriving in the same DOM node
       // (React updates the row in place), hiding the streaming reply until a
       // completion re-render rebuilt the row — the "reply only appears when
-      // the turn finishes" phone bug (2026-08-18).
-      for (const stale of flow.querySelectorAll(`[${FOLD}]`)) {
+      // the turn finishes" phone bug (2026-08-18). {@link OPEN} needs the
+      // same sweep on its own account: it is what releases a row from the
+      // stylesheet's reasoning rules, so a stale one shows the reasoning of
+      // a turn the reader has since folded.
+      for (const stale of flow.querySelectorAll(`[${FOLD}], [${OPEN}]`)) {
         if (liveItems.has(stale)) continue
         stale.removeAttribute(FOLD)
         stale.removeAttribute(OPEN)
       }
     }
 
+    /**
+     * Fold (or release) the reasoning-only rows this mutation batch touched,
+     * synchronously.
+     *
+     * The full {@link scan} is rAF-coalesced, and React commits after that
+     * frame's rAF phase, so a scan scheduled from a mutation lands one PAINTED
+     * frame later. For everything else that is invisible — the stylesheet
+     * already hid it by the host's own markers before the effect looked. For
+     * the whole-row fold, which nothing but {@link FOLD} hides, the reader saw
+     * that frame: a blank 16px band on the way in (the flow column's gap,
+     * which an emptied flex item still claims), and — worse — the row still
+     * hidden for a frame after prose started arriving into it, so the reply
+     * appeared to stutter (issue #3).
+     *
+     * A MutationObserver callback is a microtask: it runs at the end of the
+     * task that mutated the DOM, before that frame's rendering update. Marking
+     * here is therefore never a frame late, in either direction.
+     *
+     * ponytail: O(rows touched by the batch), not O(rows). If streaming ever
+     * feels heavy, the cheap win is skipping batches whose records are all
+     * characterData — the fold verdict only changes when elements do.
+     */
+    const markWholeRows = (records: readonly MutationRecord[]): void => {
+      const rows = new Set<Element>()
+      for (const record of records) {
+        const target = record.target
+        if (target instanceof Element) {
+          const row = target.closest(STEP_SELECTOR)
+          if (row !== null) rows.add(row)
+        }
+        for (const node of record.addedNodes) {
+          if (!(node instanceof Element)) continue
+          if (node.matches(STEP_SELECTOR)) rows.add(node)
+          for (const nested of node.querySelectorAll(STEP_SELECTOR)) rows.add(nested)
+        }
+      }
+      for (const row of rows) {
+        // Exactly what {@link groupsOf} walks: a direct child of the chat flow
+        // column. This is the scoping that keeps the effect Chat-only — the
+        // mutation records reach the whole document, so without it a row in
+        // any other view that seats chat nodes would get hidden with no chip
+        // to bring it back. It also drops rows detached since the batch.
+        const parent = row.parentElement
+        if (parent === null || !parent.matches(FLOW)) continue
+        const thinks = [...row.querySelectorAll(THINK)]
+        if (thinks.length > 0 && foldsWholeRow(row, thinks)) row.setAttribute(FOLD, '')
+        else row.removeAttribute(FOLD)
+      }
+    }
+
     const schedule = (): void => {
       // The locale subscription below lives outside attach/detach, so this
       // guard is what keeps a late dictionary registration from marking up
@@ -275,7 +341,7 @@ export function installTurnFold(ctx: ClientContext): void {
 
     const clear = (): void => {
       for (const chip of document.querySelectorAll(CHIP_SELECTOR)) chip.remove()
-      for (const item of document.querySelectorAll(`[${FOLD}]`)) {
+      for (const item of document.querySelectorAll(`[${FOLD}], [${OPEN}]`)) {
         item.removeAttribute(FOLD)
         item.removeAttribute(OPEN)
       }
@@ -284,7 +350,10 @@ export function installTurnFold(ctx: ClientContext): void {
     const attach = (): void => {
       if (observer !== null) return
       document.documentElement.setAttribute(ACTIVE_ATTR, '')
-      observer = new MutationObserver(schedule)
+      observer = new MutationObserver((records) => {
+        markWholeRows(records)
+        schedule()
+      })
       observer.observe(document.body, { childList: true, subtree: true })
       document.addEventListener('click', onClick)
       scan()
@@ -317,10 +386,17 @@ export function installTurnFold(ctx: ClientContext): void {
 
     if (narrow.matches) attach()
     narrow.addEventListener('change', onChange)
-    if (desktopOptIn()) enableDesktop()
-    // The row config arrives async; a late enable just attaches then. Not
-    // awaited before phone attach — folding must not wait on a round-trip.
-    else void desktopConfigured().then((on) => (on ? enableDesktop() : undefined))
+    // Both switches are synchronous reads, so a returning reader folds before
+    // first paint. Not awaited before phone attach either — folding must not
+    // wait on a round-trip.
+    if (desktopOptIn() || localStorage.getItem(DESKTOP_CACHE_KEY) === '1') enableDesktop()
+    // The row config still arrives async, and remains the authority: a late
+    // yes attaches then and is remembered, a no forgets. A late answer after
+    // dispose is a no-op inside enableDesktop.
+    void desktopConfigured().then((on) => {
+      if (on) { localStorage.setItem(DESKTOP_CACHE_KEY, '1'); enableDesktop() }
+      else localStorage.removeItem(DESKTOP_CACHE_KEY)
+    })
     // A language switch changes the chip copy of every already-rendered turn.
     const stopLocale = ctx.locale.subscribe(schedule)
     return () => {

package/src/client/styles/turn-fold.css.ts

@@ -21,6 +21,9 @@ import { OPEN, PROCESS_KINDS, THINK } from '../effects/turn-fold.ts'
 /** Mirror of the root attribute effects/turn-fold.ts holds while attached. */
 const ACTIVE = 'data-mnav-fold-on'
 
+/** One assistant-step row, inside an active fold. */
+const STEP = `html[${ACTIVE}] [data-chat-flow] > [data-chat-flow-kind="assistant-step"]`
+
 /**
  * Born folded — the reason a new tool call no longer blinks into view.
  *
@@ -37,22 +40,45 @@ const ACTIVE = 'data-mnav-fold-on'
  * block is live for exactly the widths the fold is, and hides nothing at all
  * when the effect never ran.
  *
- * One case stays with the effect: an assistant-step row whose whole body is
- * reasoning has to be hidden as a row (an emptied-out flex item still claims
- * the flow column's 16px gap), and "this row has nothing but Think in it" is
- * not a selector. Its rows therefore still fold a frame late — as blank
- * space, not as content, since the Think rows below are hidden here.
+ * The Think rule reads {@link OPEN} off the ROW as well as off the block:
+ * a row folded whole (see {@link WHOLE_STEP}) is the item the effect marks,
+ * so an expanded turn carries the override on the row and its reasoning
+ * would otherwise stay hidden behind this rule — the reader clicked the chip
+ * and got an empty band (issue #3, 2026-08-25).
  */
 const BORN_FOLDED = [
   ...PROCESS_KINDS.map((kind) => `html[${ACTIVE}] [data-chat-flow] > [data-chat-flow-kind="${kind}"]:not([${OPEN}])`),
-  `html[${ACTIVE}] [data-chat-flow] > [data-chat-flow-kind="assistant-step"] ${THINK}:not([${OPEN}])`,
+  `${STEP}:not([${OPEN}]) ${THINK}:not([${OPEN}])`,
 ].join(',\n')
 
+/*
+ * The one folded item with no selector of its own: an assistant-step row that
+ * holds reasoning and nothing else. It has to go as a ROW — the flow column is
+ * `display: flex` with `gap: 16px`, so a row whose every child is hidden still
+ * claims its gap and the reader sees a blank band — and "this row has nothing
+ * but Think in it" cannot be written as a selector.
+ *
+ * `:has()` looks like it can: "holds reasoning, holds no content block that is
+ * not reasoning". It cannot, safely. Every wrapper between the row and the
+ * blocks is itself a non-reasoning element, so the guard has to name the exact
+ * depth of the blocks — and the real tree is
+ * flowItem > seat > AssistantMarkdown root > body > blocks, one level deeper
+ * than the host's own component suggests, because the slot seat adds a wrapper
+ * the component never sees. A selector pinned to that depth silently stops
+ * matching the day a wrapper moves, with nothing to say why.
+ *
+ * So the row stays with effects/turn-fold.ts, which walks the tree instead of
+ * assuming its shape — but marks it synchronously in the MutationObserver
+ * callback (a microtask, before the frame paints) rather than a rAF later.
+ */
+
 /** The fold + chip rules, with every selector prefixed by `scope`. */
 const rules = (scope: string): string => `
-  /* Folded process: tool-call / context / command rows and the Think
-     disclosures inside an assistant step. !important because the official
-     flow item and ReasoningRow both set their own display. */
+  /* The reasoning-only row (see above), which effects/turn-fold.ts marks
+     itself because no selector can find it. Everything else is already hidden
+     by BORN_FOLDED, by the host's own markers — this rule is what that one
+     case rides on. !important because the official flow item and ReasoningRow
+     both set their own display. */
   ${scope} [data-mnav-fold]:not([data-mnav-fold-open]) {
     display: none !important;
   }