dsh-paste-code-block 0.1.3 → 0.2.5

package/README.md

@@ -4,7 +4,7 @@
 
 **Cherry Studio‑style text/code block pasting for DeepSeek Harness Web**
 
-Paste long code or text into the DSH Web composer → it lands as a **bordered, collapsible, language‑tagged card** instead of a wall of text. Names follow the DSH interface language (中文 / English). On send, the original content is restored as a fenced code block.
+Paste long code or text into the DSH Web composer → it lands as a **bordered, collapsible, language‑tagged card** instead of a wall of text. Names follow the DSH interface language (中文 / English). On send, the original content is restored as a fenced code block — and in the conversation it **stays folded** into click‑to‑expand cards, so your bubbles never become text walls again.
 
 [![npm version](https://img.shields.io/npm/v/dsh-paste-code-block?logo=npm)](https://www.npmjs.com/package/dsh-paste-code-block)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green)](./LICENSE)
@@ -28,6 +28,8 @@ Copying a 200‑line stack trace, an API response, or a long log into a chat inp
 - 🈯 **Localized names** — chips are named in the current DSH language: `代码块 1` / `Code #1`, `文本块 N` / `Text #N`. A leading glyph and tint tells the two apart at a glance — `</>` blue for code, `Aa` gray for text. Switching **Settings → Language** live-retitles every chip.
 - × **One-click remove** — every chip carries its own `×` delete button (the detail card has one too); a removed number is recycled immediately.
 - 📤 **Fenced restore on send** — each card expands back into a ```` ```lang … ``` ```` block when you send; a failed send automatically refills the input.
+- 📦 **Folded after send** — sent blocks keep folding in the transcript: every fenced block inside your own messages renders as a collapsed card (`python · 128 行` / `python · 128 lines`). Click the header to expand, again to collapse; the card's copy button grabs the original fenced text verbatim. Bare ```` ``` ```` fences fold as code (only an explicit ```` ```text ```` folds as a text block).
+- 💾 **Mid-draft safe** — DSH persists a composer draft as plain text, so pasted blocks are automatically re-attached when the composer is rebuilt (workspace switch on the new-session page, page reload); hand-deleted blocks are never "resurrected".
 - 🔢 **Smart numbering** — code and text count apart; the smallest free number is always reused.
 - 📱 **Every surface** — pure client plugin; works on desktop & mobile web, follows light/dark themes.
 
@@ -68,6 +70,7 @@ dsh plugin --profile web add file:/path/to/dsh-paste-code-block  # from a local
 2. Paste into the DSH input → it collapses into a chip such as `代码块 1` / `Code #1`.
 3. Click the chip to open the card: read, edit inline, copy, collapse. Click the chip's (or the card's) `×` to delete that block.
 4. Send — the full original text goes out as a proper fenced code block.
+5. In the conversation it stays folded: each block sits in the bubble as a collapsed card — click the header to expand and read, click again to collapse.
 
 Detection threshold: **contains a newline / ≥ 2 lines / length ≥ 96 / indented & brace-dense / fenced** — any one turns the paste into a block.
 
@@ -78,21 +81,24 @@ Detection threshold: **contains a newline / ≥ 2 lines / length ≥ 96 / indent
 - Removing a chip any other way (e.g. `Backspace`) also frees its number — plugin state is reconciled against the editor continuously.
 - Deleting one block never touches the others, and removal is an ordinary editor edit — `Ctrl+Z` brings it back.
 - Creating a block leaves **no stray space**: DSH appends a separating space after a freshly inserted chip, and the plugin removes exactly that one character, so text typed after a block does not start with a space and pasting several blocks never piles spaces into the message. Spaces you typed yourself are never touched by pasting or deleting.
+- Post-send folding is **display-only**: it restyles your own message bubbles (and steering rows / the send echo) in the DOM. Stored messages are never modified, the bubble's own copy / edit / delete bar keeps working on the original text, and assistant messages are left alone.
+- Draft-rebuild recovery keeps a small localStorage mirror (block payloads plus a draft fingerprint; written while you edit, cleared when you send, expired after two weeks). If the browser blocks local storage (private mode), blocks still survive a same-tab workspace switch from memory — just not a full page reload.
 
 ## Project layout
 
 ```
 dsh-paste-code-block/
 ├── src/
-│   ├── client.js       # Web (browser) half — paste capture, chips, detail card, × delete
+│   ├── client.js       # Web (browser) half — paste capture, chips, detail card, × delete, sent-message fold, draft-rebuild recovery
 │   ├── index.js        # Host (node) half — intentionally empty (pure UI plugin)
-│   ├── parse.js        # Pure block-detection logic (canonical, unit-tested)
-│   └── i18n.js         # Locale dictionaries + label parsing (canonical, unit-tested)
+│   ├── parse.js        # Pure block-detection + fence-splitting logic (canonical, unit-tested)
+│   └── i18n.js         # Locale dictionaries, label & fold-title builders (canonical, unit-tested)
 ├── tests/
-│   ├── parse.test.js   # node:test unit tests for src/parse.js
-│   └── i18n.test.js    # node:test unit tests for src/i18n.js
+│   ├── parse.test.js     # node:test unit tests for src/parse.js
+│   ├── i18n.test.js      # node:test unit tests for src/i18n.js
+│   └── fold-smoke.test.js # end-to-end fold scan against a DOM shim (runs the real client bundle)
 ├── docs/
-│   ├── design.md       # Design rationale (numbering, anchors, codec, i18n, chip ×)
+│   ├── design.md       # Design rationale (numbering, anchors, codec, i18n, chip ×, sent-message fold, draft-rebuild recovery)
 │   └── images/         # README mockups (PNG + editable SVG sources)
 ├── cordis.patch.yml    # DSH bundle patch declaring the host plugin
 ├── package.json        # Package + DSH plugin manifest
@@ -104,7 +110,7 @@ dsh-paste-code-block/
 
 ```sh
 npm run check   # syntax-check the JS halves
-npm test        # run unit tests (node:test, 38 tests)
+npm test        # run unit tests (node:test, 61 tests)
 ```
 
 ## License

package/README.zh-CN.md

@@ -4,7 +4,7 @@
 
 **Cherry Studio 式的文本块/代码块粘贴效果（DeepSeek Harness Web）**
 
-把复制的**长代码 / 长文本**粘到 DSH Web 输入框时，不再糊成一长串普通文字，而是收成一张**带边框、可折叠、带语言标签的卡片**；块名称自动跟随 DSH 界面语言（中文 / English）；发送时自动还原成真正的 ```` ```lang … ``` ```` 围栏代码块。
+把复制的**长代码 / 长文本**粘到 DSH Web 输入框时，不再糊成一长串普通文字，而是收成一张**带边框、可折叠、带语言标签的卡片**；块名称自动跟随 DSH 界面语言（中文 / English）；发送时自动还原成真正的 ```` ```lang … ``` ```` 围栏代码块——**发送后在对话里也保持折叠**，点击即可展开阅读。
 
 [![npm version](https://img.shields.io/npm/v/dsh-paste-code-block?logo=npm)](https://www.npmjs.com/package/dsh-paste-code-block)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green)](./LICENSE)
@@ -28,6 +28,8 @@
 - 🈯 **名称本地化**：芯片按当前 DSH 界面语言命名——`代码块 1` / `Code #1`、`文本块 N` / `Text #N`；前缀图标与配色一眼区分两类块（代码 `</>` 蓝色、文本 `Aa` 灰色）；在「设置 → 语言」切换后所有芯片即时改名。
 - × **一键删除**：每个芯片自带 `×` 删除按钮（详情卡上也有）；删掉的块编号立刻回收复用。
 - 📤 **发送还原**：发送时每个卡片展开还原为 ```` ```lang … ``` ```` 围栏代码块；发送失败自动回填输入框。
+- 📦 **发送后仍折叠**：发出去的消息在对话里继续折叠成卡片（如 `python · 128 行`），气泡不再变成文字墙；点标题展开、再点收起，卡片上的复制按钮原样复制带围栏的完整代码块。裸 ```` ``` ```` 围栏按代码块折叠（只有显式 ```` ```text ```` 才折叠为文本块）。
+- 💾 **草稿中途不丢**：DSH 只把输入框草稿按纯文本持久化，输入框被重建时（新会话页切换工作区、刷新页面）已粘贴的块会自动重新挂回草稿；手动删掉的块绝不会被“复活”。
 - 🔢 **智能编号**：代码与文本分开计数，永远分配最小可用号。
 - 📱 **全端适配**：纯客户端插件，PC 与手机 Web 通用，实时跟随深浅主题。
 
@@ -68,6 +70,7 @@ dsh plugin --profile web add file:/path/to/dsh-paste-code-block  # 从本地目
 2. 在 DSH 输入框粘贴 → 折叠成 `代码块 1` 这样的芯片。
 3. 点芯片打开详情卡：阅读、就地编辑、复制、折叠；点芯片（或卡片）上的 `×` 删除该块。
 4. 发送——完整原文以围栏代码块形式发出。
+5. 发送后对话里仍保持折叠：每个块在气泡中显示为一张卡片，点标题展开阅读、再点收起。
 
 识别阈值：**含换行 / 行数 ≥ 2 / 长度 ≥ 96 / 缩进且符号密集 / 带围栏**，任一命中即成块。
 
@@ -78,21 +81,24 @@ dsh plugin --profile web add file:/path/to/dsh-paste-code-block  # 从本地目
 - 用其他方式删除芯片（如 `Backspace`）同样会释放编号——插件状态与编辑器持续对账。
 - 删除单个块绝不影响其它块；删除是一次普通的编辑器编辑，可用 `Ctrl+Z` 撤销找回。
 - 创建块**不会残留空格**：DSH 会在新插入的芯片后自动补一个分隔空格，插件只把这一个字符删掉——因此块后面接着输入的文字不会顶着一个前导空格，连续粘贴多个块也不会在正文里堆出多余空格；你自己敲的空格在粘贴/删除时都不会被动到。
+- 发送后折叠**只是显示层**的改动：它只重排你自己消息（含插话与发送回显）气泡的 DOM，**不改任何存储的消息数据**；气泡自带的复制/编辑/删除操作照常作用于原文；助手消息完全不受影响。
+- 草稿恢复依赖一个小型 localStorage 镜像（只存块内容与草稿指纹；编辑时写入、发送即清、两周过期）。浏览器禁用本地存储（如隐身模式）时，同一页面内的工作区切换仍可从内存恢复，但整页刷新不能。
 
 ## 目录结构
 
 ```
 dsh-paste-code-block/
 ├── src/
-│   ├── client.js       # Web（浏览器侧）—— 粘贴拦截、芯片、详情卡片、× 删除
+│   ├── client.js       # Web（浏览器侧）—— 粘贴拦截、芯片、详情卡片、× 删除、发送后折叠、草稿恢复
 │   ├── index.js        # Host（Node 侧）—— 有意为空（纯 UI 插件）
-│   ├── parse.js        # 纯块识别逻辑（规范版，含单元测试）
-│   └── i18n.js         # 词典与块名称解析（规范版，含单元测试）
+│   ├── parse.js        # 纯块识别 + 围栏切分逻辑（规范版，含单元测试）
+│   └── i18n.js         # 词典、块名称与折叠卡标题（规范版，含单元测试）
 ├── tests/
-│   ├── parse.test.js   # node:test 单元测试（src/parse.js）
-│   └── i18n.test.js    # node:test 单元测试（src/i18n.js）
+│   ├── parse.test.js     # node:test 单元测试（src/parse.js）
+│   ├── i18n.test.js      # node:test 单元测试（src/i18n.js）
+│   └── fold-smoke.test.js # 用 DOM 垫片端到端跑真实 client.js：折叠扫描 + 草稿恢复
 ├── docs/
-│   ├── design.md       # 设计说明（编号复用、锚点稳定、codec、i18n、芯片 ×）
+│   ├── design.md       # 设计说明（编号复用、锚点稳定、codec、i18n、芯片 ×、发送后折叠）
 │   └── images/         # README 示意图（PNG + 可编辑 SVG 源）
 ├── cordis.patch.yml    # DSH bundle patch，声明宿主插件
 ├── package.json        # 包与 DSH 插件清单
@@ -104,7 +110,7 @@ dsh-paste-code-block/
 
 ```sh
 npm run check   # 语法检查 JS 半端
-npm test        # 运行单元测试（node:test，38 项）
+npm test        # 运行单元测试（node:test，61 项）
 ```
 
 ## License

package/docs/design.md

@@ -202,4 +202,136 @@ for us) while the scoped edit verbs address detect coordinates (a chip collapses
 placeholder character). `detectOffsetOf()` converts with
 `detect = clipboard - Σ(len_i - 1)` over preceding occurrences, so blocks stay correctly
 addressed even when other plugins' chips (file references and the like) sit in the same draft.
-Both helpers are pure and unit-tested (8 cases in tests/projection.test.js).
+Both helpers are pure and unit-tested (8 cases in tests/projection.test.js).
+
+## 12. Sent-message folding (0.2.0)
+
+The composer fold was only half the story: on send the chips expand back into fenced text, and
+DSH renders user bubbles as **plain pre-wrap text** (`projectUserText` → `span.plainRun` runs
+plus `data-ref-chip` badges), so the sent message reappeared in the transcript as the very wall
+of text the plugin exists to prevent. §12 folds *sent* blocks back down.
+
+**Where the DOM hooks are.** Every conversation row carries `data-chat-flow-kind`
+(`user` / `steering` / `agent` / …) and `data-chat-flow-key` on its wrapper; the right-aligned
+user bubble lives under the same row and contains the `plainRun` spans. The send echo
+(`data-submission-echo`) and pending steering (`data-pending-steering`) render the same bubble
+markup one frame before the durable node exists, so scanning all four gives an instant
+collapsed view from the moment of send. Assistant output is deliberately not touched: its
+markdown renderer already styles code blocks its own way.
+
+**Never fight React.** The bubble's children belong to React; removing them would make the
+next reconciliation throw. So the fold *hides* a qualifying `plainRun` span (`display:none` —
+the node stays a child, React keeps patching it harmlessly) and inserts a
+`div.dsh-pcb-fold-host` **after** it. The host is ours: prose segments re-render as
+`span.dsh-pcb-fold-prose`, each fence as a collapsed card (glyph `</>`/`Aa` + localized title
+`python · 128 行` / `Text · 128 lines`, copy button copying the **raw fenced text** exactly as
+sent, click-to-expand `<pre>`). Since hiding a child does not affect `textContent`, the
+message action bar (React-side copy/edit/delete) is entirely unaffected.
+
+**What folds.** `splitFencedSegments()` (canonical in `src/parse.js`, embedded copy in
+`client.js`) walks the run line by line with GFM fence rules (``` or ~~~, opener indented ≤ 3
+spaces, closer ≥ opener length alone on its line; backticks in a ``` info string kill that
+opener; an unterminated opener stays prose). Any fence segment with a non-empty body folds;
+everything else — prose, whitespace between blocks, empty fences — renders verbatim around
+the cards. Fence-only (not "any long text") is deliberate: composer-created blocks always
+travel as fences, while unfenced long messages may have been *typed*, and silently folding
+typed prose would be a nasty surprise.
+
+**Idempotence and refresh.** Each scanned run gets
+`data-dsh-pcb-run = "1|<stamp>"` (folded) or `"0|<stamp>"` (checked, nothing to fold), where
+the stamp folds `foldRev`, text length, and an FNV-1a hash. The shared chip-sync
+MutationObserver coalesces to one rAF scan; a run whose stamp matches is skipped, so steady
+state costs attribute reads. A locale switch bumps `foldRev`, which invalidates every stamp —
+the next scan rebuilds each host and re-titles cards from the live translator. Rebuilds
+preserve who was expanded via a stable `flowKey#runIndex:segIndex` open set, and an orphan
+sweep drops any host whose predecessor is no longer its hidden, stamp-matching run (React can
+remount the run underneath us). Disposal (HMR / plugin removal) removes all hosts and unhides
+every run — the transcript hands back clean.
+
+`tests/fold-smoke.test.js` exercises the real bundle against a dependency-free DOM shim:
+fold → marker/card/prose structure, steering rows, non-fenced messages untouched, retitle
+across locale switches with open-state kept, text edits re-fold and unfold, orphan sweep,
+and dispose restoration.
+
+**Bare fences are code (0.2.1).** Card type follows the composer round-trip convention: a
+plain-text block always serializes as an explicit ` ```text ` fence while a code block whose
+language was not detected serializes as a **bare** ` ``` ` fence — so only an explicit `text`
+info string folds as a 文本块, and a bare fence folds as 代码块, re-guessing a language from
+the body for the title (`python · 2 行`, else `代码块 · N 行`). Manually typed bare fences
+follow the same rule; that is also the CommonMark reading. (0.2.0 shipped the inverse and a
+sent 代码块 chip could reappear in the transcript as 文本块.)
+
+## 13. Draft rebuild recovery (0.2.1)
+
+**Typing-window guard and retired hygiene (0.2.2).** The recovery rewrite is a whole-
+document `setDraft`: the caret drops at the end and an in-flight IME composition is
+destroyed. Run in the middle of typing, that ate the user's first character and bounced
+the view on every pass (reported). Two keystroke-time paths existed: sweeping a stray
+U+200B that belonged to no restorable block (external invisible copy from WeChat / web
+pages — the signature is NOT exclusive to rebuilds after all), and restoring blocks while
+the draft had already moved past the re-seeded text. The hygiene path is retired outright:
+external residue is left exactly where the user put it. Both paths now share one gate —
+`recover()` only acts when the draft is IDENTICAL to the last draft observed for that
+session in this page view (or was never observed: fresh boot, or the composer only ever
+seen hydrating empty). A draft that MOVED between passes is live typing, never a rebuild.
+`attach()` records the shell's post-insertion draft as that fingerprint immediately, and
+the reconcile prune drops the mirror synchronously, so a hand-deleted block cannot be
+resurrected from stale mirror data through the empty-prior window.
+
+**Paste-storm guard (0.2.3).** Even with the typing-window guard deployed (load log
+`client loaded v0.2.2` verified live), the console showed the SAME clipboard text (571
+chars) intercepted dozens of times in seconds — an external automation (a Tampermonkey
+AutoClicker was running on the page) re-dispatching paste. Each accepted paste inserts a
+chip and re-renders the dock, so a storm reproduces the exact bounce-and-eat-the-first-
+character experience through a different door. Identical clipboard text arriving
+faster than a human can act collapses into one paste (`pasteStorm.seen`, 1200 ms
+sliding window refreshed on every matching event, so a held repeat stays
+suppressed while it continues); suppressed events are still `preventDefault`ed so
+raw text never falls through to the composer. The plugin cannot suppress the
+automation itself — users hitting this should disable AutoClicker-style userscripts
+on the DSH page.
+
+**Burst-only collapse (0.2.5).** 0.2.4 tried a content-liveness rule: while a block
+with the same text was still attached, re-pasting identical text was consumed as
+"not a new intent." That over-suppressed — pasting the same snippet twice (a
+completely normal action) yielded a single block and confused users, and in the
+end the reported bounces were traced to a *different* plugin entirely, not to
+paste storms. So 0.2.5 reverts to a pure burst window: identical text pasted after
+the 1200 ms window is a fresh intent and gets its own block (`sourceText` is
+recorded per block and carried through the recovery mirror); only machine-paced
+repeats *within* the window collapse. The `intercept` load log still carries
+`trusted=` — `false` names a page-script dispatch (userscript glue, or the
+`dsh-vision-router` image-paste replay, which carries the original text and lands
+seconds after the trusted paste) rather than a real Ctrl+V, so any future storm
+report identifies its own source.
+
+Two DSH paths strand pasted blocks mid-draft, and both share one signature. (a) A page
+reload re-seeds the composer from DSH's persisted per-session draft
+(`dsh.conversation.<sid>`), which is **plain text** — Lexical chips cannot round-trip
+through it (§7). (b) A workspace switch on the new-session page *carries the draft text
+over* to the target workspace's blank session (`inputHub`: `next.setDraft(from.snapshot
+.draft)`, then `from.setDraft("")`) — prose follows the composer, chips and controller
+state do not, so blocks were silently orphaned under the old session id (user-reported).
+Typed prose comes back either way; the blocks did not.
+
+The signature — as 0.2.1 read it: every chip contributes exactly one U+200B to the clipboard
+projection and nothing scrubs it from persisted/carried text (DSH's placeholder-stripping
+regex covers private-use chars and U+FFFC, not ZWSPs). Stray U+200Bs with **no** live
+occurrence of ours can therefore only mean the draft was rebuilt from text; conversely
+deleting a chip — ✕, Backspace, or prune — removes its ZWSP together with the node, so
+deliberate deletion never looks like a rebuild and cannot be "resurrected".
+
+`BlockController.recover()` runs in the dock's reconcile effect, ahead of the reconcile,
+and resolves blocks in this order: own-session memory → the session's own localStorage
+mirror → **carry-over donor**: the unmounted session whose last published draft equals the
+re-seeded text character for character (the mirror stores that same fingerprint, so the
+donor is even found after a reload wiped memory) → nothing. An ambiguous fingerprint aborts
+the donor step — no guessing. On a hit the mirror moves to the new sid. (0.2.1 also stripped
+strays when nothing could be restored; the typing-window guard above retired that — see the
+0.2.2 note.) The mirror holds just the block payloads plus that draft fingerprint, is written
+synchronously on attach (and debounced on detail-card edits), drops on a send attempt, and
+expires after two weeks. The recovery pass then *skips* its reconcile — the snapshot it
+would reconcile against is stale; the draft mutation bumps `draftRev` and the next pass
+reconciles real occurrences. Restored chips get re-derived labels and numbers, so a
+restored draft is indistinguishable from one that never left. Mirror writes are best
+effort: private mode / quota only lose reload durability, never the feature itself.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-paste-code-block",
-  "version": "0.1.3",
-  "description": "Cherry Studio-style paste for DSH Web: pasted text/code becomes a bordered, collapsible, language-tagged card with localized names (中文/English) and a one-click remove button; restored as a fenced code block on send.",
+  "version": "0.2.5",
+  "description": "Cherry Studio-style paste for DSH Web: pasted text/code becomes a bordered, collapsible, language-tagged card with localized names (中文/English) and a one-click remove button; restored as a fenced code block on send — and folded back into collapsed, expandable cards in the conversation.",
   "license": "MIT",
   "author": "DSH paste-code-block contributors",
   "repository": {
@@ -85,7 +85,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "check": "node --check src/index.js && node --check src/i18n.js && node --check src/chip-nodes.js && node --check src/projection.js && node --check src/client.js",
+    "check": "node --check src/index.js && node --check src/parse.js && node --check src/i18n.js && node --check src/chip-nodes.js && node --check src/projection.js && node --check src/client.js",
     "test": "node --test 'tests/**/*.test.js'",
     "render:images": "node docs/images/render.cjs"
   }

package/src/client.js

@@ -109,6 +109,9 @@ window.__ModuleLoader__.load({
         'edit.aria': '编辑代码块内容',
         'error.stale': '代码块已失效，请重新粘贴',
         'error.remove': '无法删除该块，请重试',
+        'fold.code': '代码块',
+        'fold.text': '文本块',
+        'fold.aria': '展开或折叠该块',
       },
       en: {
         'block.code': 'Code #{n}',
@@ -126,6 +129,9 @@ window.__ModuleLoader__.load({
         'edit.aria': 'Edit block content',
         'error.stale': 'This block is no longer valid — paste it again',
         'error.remove': 'Could not remove the block — please retry',
+        'fold.code': 'Code',
+        'fold.text': 'Text',
+        'fold.aria': 'Expand or collapse this block',
       },
     }
 
@@ -138,6 +144,13 @@ window.__ModuleLoader__.load({
       }
     }
 
+    // Sent-message fold card title (embedded copy of src/i18n.js#foldTitle).
+    function foldTitle(t, type, lang, lines) {
+      const meta = t(lines === 1 ? 'lines.one' : 'lines.other', { count: lines })
+      const name = type === 'code' ? (lang || t('fold.code')) : t('fold.text')
+      return `${name} · ${meta}`
+    }
+
     function detectBrowserLocale() {
       try {
         const langs = [...(navigator.languages || []), navigator.language].filter(Boolean).map((l) => String(l).toLowerCase())
@@ -269,6 +282,134 @@ window.__ModuleLoader__.load({
       return `\n\`\`\`${lang}\n${block.content}\n\`\`\`\n`
     }
 
+    // ----- fence segmentation (embedded copy of src/parse.js) ----------------
+    // Split a message text into ordered prose/fence segments (GFM-style ``` or
+    // ~~~ fences, opener indented <=3 spaces, closer >= opener length alone on
+    // its line). Unterminated openers stay prose. Keep in sync with parse.js.
+    function splitFencedSegments(text) {
+      const src = String(text == null ? '' : text)
+      if (!src) return []
+      const lines = src.split(/\r?\n/)
+      const segments = []
+      const OPEN = /^ {0,3}(`{3,}|~{3,})(.*)$/
+      let proseStart = 0
+      let i = 0
+      const flushProse = (end) => {
+        if (end > proseStart) segments.push({ kind: 'prose', text: lines.slice(proseStart, end).join('\n') })
+      }
+      while (i < lines.length) {
+        const m = OPEN.exec(lines[i])
+        if (!m) { i += 1; continue }
+        const marker = m[1]
+        const ch = marker[0]
+        const info = m[2].trim()
+        if (ch === '`' && info.includes('`')) { i += 1; continue }
+        const closeRe = new RegExp('^ {0,3}' + (ch === '`' ? '`' : '~') + '{' + marker.length + ',}[ \\t]*$')
+        let j = i + 1
+        let closed = false
+        while (j < lines.length) {
+          if (closeRe.test(lines[j])) { closed = true; break }
+          j += 1
+        }
+        if (!closed) { i += 1; continue }
+        flushProse(i)
+        const bodyLines = lines.slice(i + 1, j)
+        segments.push({
+          kind: 'fence',
+          lang: info ? info.split(/\s+/)[0] : '',
+          info,
+          body: bodyLines.join('\n'),
+          raw: lines.slice(i, j + 1).join('\n'),
+        })
+        i = j + 1
+        proseStart = i
+      }
+      flushProse(lines.length)
+      return segments
+    }
+
+    // ===== Recovery mirror (draft re-seed after workspace switch / reload) ===
+    // DSH persists a session's composer draft as PLAIN TEXT
+    // (`dsh.conversation.<sid>` in localStorage) and re-seeds the editor from
+    // it — but Lexical chip nodes cannot round-trip through text (design.md
+    // §7), so switching workspaces mid-draft left every pasted block behind:
+    // the seeded draft keeps only one invisible U+200B per lost chip. The
+    // plugin therefore mirrors its block CONTENT to localStorage itself and
+    // re-attaches the chips when it recognizes that stray-ZWSP signature
+    // (BlockDock mount effect → BlockController.recover). Intentional chip
+    // deletion removes the ZWSPs along with the nodes, so it never looks
+    // like a re-seed; the mirror clears itself on send and once no blocks
+    // remain, and stale entries expire after two weeks.
+    const RECOVERY_PREFIX = 'dsh-pcb-recovery.'
+    const RECOVERY_TTL_MS = 14 * 24 * 60 * 60 * 1000
+    const RECOVERY_MAX_CHARS = 3_000_000
+    const RECOVERY_MAX_DRAFT = 200_000
+
+    function recoverySave(sid, blocks, draftText) {
+      const key = RECOVERY_PREFIX + sid
+      try {
+        if (!blocks || blocks.length === 0) { localStorage.removeItem(key); return }
+        const draft = typeof draftText === 'string' && draftText.length <= RECOVERY_MAX_DRAFT ? draftText : ''
+        const json = JSON.stringify({ at: Date.now(), draft, blocks })
+        if (json.length > RECOVERY_MAX_CHARS) { console.warn('[dsh-pcb] draft too large to mirror; chips will not survive a reload'); return }
+        localStorage.setItem(key, json)
+      } catch (e) { /* quota / private mode: best effort */ }
+    }
+
+    function recoveryLoad(sid) {
+      const key = RECOVERY_PREFIX + sid
+      try {
+        const raw = localStorage.getItem(key)
+        if (!raw) return null
+        let data = null
+        try { data = JSON.parse(raw) } catch (e) { data = null }
+        if (!data || typeof data.at !== 'number' || Date.now() - data.at > RECOVERY_TTL_MS) { localStorage.removeItem(key); return null }
+        return data
+      } catch (e) { return null }
+    }
+
+    function recoveryClear(sid) {
+      try { localStorage.removeItem(RECOVERY_PREFIX + sid) } catch (e) { /* noop */ }
+    }
+
+    /**
+     * Mirror-side carry-over donor: a store whose mirrored draft matches the
+     * re-seeded one exactly and still holds blocks (after a page reload there
+     * is no live memory to match against). Returns { sid, blocks } on a
+     * UNIQUE match, null when absent or ambiguous.
+     */
+    function recoveryScanDonor(targetSid, draft) {
+      try {
+        let hit = null
+        for (let i = 0; i < localStorage.length; i += 1) {
+          const key = localStorage.key(i)
+          if (!key || !key.startsWith(RECOVERY_PREFIX)) continue
+          const sid = key.slice(RECOVERY_PREFIX.length)
+          if (sid === targetSid) continue
+          const data = recoveryLoad(sid)
+          if (!data || data.draft !== draft || !Array.isArray(data.blocks)) continue
+          if (!data.blocks.some((b) => b && typeof b.content === 'string' && b.content !== '')) continue
+          if (hit) return null // ambiguous — refuse to guess
+          hit = { sid, blocks: data.blocks }
+        }
+        return hit
+      } catch (e) { return null }
+    }
+
+    function recoveryPruneExpired() {
+      try {
+        const doomed = []
+        for (let i = 0; i < localStorage.length; i += 1) {
+          const k = localStorage.key(i)
+          if (!k || !k.startsWith(RECOVERY_PREFIX)) continue
+          let at = 0
+          try { at = (JSON.parse(localStorage.getItem(k) || '{}').at) || 0 } catch (e) { /* fall through */ }
+          if (!at || Date.now() - at > RECOVERY_TTL_MS) doomed.push(k)
+        }
+        for (const k of doomed) localStorage.removeItem(k)
+      } catch (e) { /* noop */ }
+    }
+
     // ===== Draft controller ==================================================
     class BlockController {
       /**
@@ -289,6 +430,8 @@ window.__ModuleLoader__.load({
         this.expiry = new Map()
         this.serializing = new Set()
         this.listeners = new Map()
+        this.recoverTimer = new Map() // sid -> debounce handle for the recovery mirror
+        this.lastInput = new Map() // sid -> draft text seen by the last recover() pass
         this.counter = 0
       }
 
@@ -445,6 +588,16 @@ window.__ModuleLoader__.load({
         this.refIndex.set(block.id, { sessionId: k, block })
         this.labelIndex.set(block.label, block.id)
         this.publish(sessionId)
+        // The shell just rewrote the draft (chip + placeholder char); until
+        // the next dock pass runs, this is the session's ground truth. Keep
+        // the typing-window fingerprint and the carry-over donor match fresh
+        // so the pass right after a paste cannot mistake the new draft for a
+        // rebuild.
+        try {
+          const after = this.scope(k).shell.snapshot
+          if (after && typeof after.draft === 'string') this.lastInput.set(k, after.draft)
+        } catch (e) { /* session vanished — the next pass re-observes */ }
+        this.mirrorNow(k) // attach is a key moment — persist synchronously
         return true
       }
 
@@ -570,6 +723,7 @@ window.__ModuleLoader__.load({
         for (const [label, r] of this.labelIndex) if (r === ref) this.labelIndex.delete(label)
         this.freeLabel(sessionId, entry.type, entry.labelNumber)
         this.publish(sessionId)
+        this.mirror(k)
       }
 
       /** Update a block's content while editing it in the detail card. */
@@ -578,23 +732,31 @@ window.__ModuleLoader__.load({
         if (!record) return
         record.block.content = content
         record.block.lines = content.split(/\r?\n/)
+        this.mirror(record.sessionId)
       }
 
       clearInFlight(sessionId) {
         const k = String(sessionId)
         const expiry = this.expiry.get(k)
         if (expiry) { clearTimeout(expiry); this.expiry.delete(k) }
+        const had = this.inFlight.has(k)
         for (const b of this.inFlight.get(k) || []) {
           this.refIndex.delete(b.id)
           this.freeLabel(sessionId, b.type, b.labelNumber)
           for (const [label, r] of this.labelIndex) if (r === b.id) this.labelIndex.delete(label)
         }
         this.inFlight.delete(k)
+        if (had) this.mirrorNow(k)
       }
 
       markSerializing(ref) {
         const record = this.refIndex.get(ref)
-        if (record && !this.serializing.has(record.sessionId)) this.serializing.add(record.sessionId)
+        if (record && !this.serializing.has(record.sessionId)) {
+          this.serializing.add(record.sessionId)
+          // A send is starting: the content leaves the draft, the mirror may go.
+          // (A failed send re-mirrors via restoreFailed.)
+          recoveryClear(record.sessionId)
+        }
       }
 
       async serialize(ref) {
@@ -640,6 +802,12 @@ window.__ModuleLoader__.load({
         if (next.length > 0) this.list.set(k, next)
         else this.list.delete(k)
         this.publish(sessionId)
+        // Hand-deletion is final. Persist the pruned state synchronously so a
+        // later reload/carry-over cannot resurrect a deleted chip from a
+        // mirror the draft has already outlived — and so the recovery
+        // restore-path can never fire off invisible external residue once the
+        // list for this session is empty.
+        this.mirrorNow(k)
       }
 
       restoreFailed(sessionId) {
@@ -661,10 +829,168 @@ window.__ModuleLoader__.load({
         }
         if (survived.length) this.list.set(k, [...this.listFor(k), ...survived])
         this.publish(sessionId)
+        if (survived.length) this.mirror(k)
+      }
+
+      // ----- recovery mirror -------------------------------------------------
+      /** Debounced persistence of the session's current block payloads. */
+      mirror(sessionId) {
+        const k = String(sessionId)
+        const prev = this.recoverTimer.get(k)
+        if (prev) clearTimeout(prev)
+        this.recoverTimer.set(k, setTimeout(() => {
+          this.recoverTimer.delete(k)
+          this.mirrorNow(k)
+        }, 250))
+      }
+
+      mirrorNow(sessionId) {
+        const k = String(sessionId)
+        const t = this.recoverTimer.get(k)
+        if (t) { clearTimeout(t); this.recoverTimer.delete(k) }
+        recoverySave(k, this.listFor(k).map((b) => ({ isCode: !!b.isCode, lang: b.lang || '', content: b.content, src: b.sourceText || '' })), this.lastInput.get(k))
+      }
+
+      /**
+       * Restore the chips a text-only draft rebuild dropped. Two DSH paths
+       * strand them: (a) the persisted per-session draft re-seeds the composer
+       * after a page reload, and (b) a workspace switch on the new-session
+       * page CARRIES the draft plain-text to the target workspace's blank
+       * session (inputHub: next.setDraft(from.snapshot.draft)) — the chips,
+       * which are Lexical nodes plus controller state, never move. Both leave
+       * the same signature: stray U+200Bs (every chip contributes exactly one,
+       * and removing a chip removes its ZWSP too) with no live occurrence of
+       * ours. Deliberate deletion therefore never looks like a rebuild; and a
+       * carry-over is matched to its donor by the exact draft the donor last
+       * published — unique match only, no guessing. Blocks come from memory
+       * first (same tab), then this session's mirror, then the donor's memory
+       * or mirror. A stray U+200B that belongs to NO restorable block is
+       * ordinary invisible copy from an external app (WeChat, web pages):
+       * never restorable, cosmetic — it is left exactly where the user put
+       * it. Sweeping it used to rewrite the whole draft mid-typing and is
+       * retired in 0.2.2 (see the typing-window guard below).
+       *
+       * @param sessionId - session whose composer just (re)mounted.
+       * @param snapshot - live input state ({draft, occurrences, phase}).
+       * @returns whether the draft was rewritten by a real restore.
+       */
+      recover(sessionId, snapshot) {
+        const k = String(sessionId)
+        if (!snapshot || typeof snapshot.draft !== 'string') return false
+        const prior = this.lastInput.get(k)
+        this.lastInput.set(k, snapshot.draft)
+        if (this.serializing.has(k)) return false
+        if (snapshot.phase && snapshot.phase !== 'plain') return false
+        if ((snapshot.occurrences || []).some((o) => o.source === SOURCE)) return false
+        const draft = snapshot.draft
+        const strays = (draft.match(/\u200B/g) || []).length
+        if (strays === 0) return false
+        // Typing-window guard. Every committed keystroke re-runs this pass, so
+        // a draft that MOVED since the pass before it is live typing, not a
+        // text-only re-seed — and a real restore rewrites the whole document
+        // via setDraft: caret to the end, chips re-appended, an in-flight IME
+        // composition destroyed (0.2.2 bug: the first character typed was
+        // eaten and the view bounced once, again and again). Only a draft
+        // IDENTICAL to the last one observed for this session — or one this
+        // page view has never seen, or only ever saw the composer hydrate
+        // through while empty (fresh-boot re-seed) — can carry the rebuild
+        // signature. The empty-prior escape is sealed from the other side by
+        // reconcile pruning synchronously dropping the mirror: with nothing
+        // restorable on record, a moved-from-empty pass restores nothing.
+        if (prior && prior !== draft) return false
+        let shell
+        try {
+          shell = this.scope(k).shell
+        } catch (e) { return false } // session not ready yet — a later pass retries
+        const usable = (arr) => Array.isArray(arr)
+          ? arr.filter((b) => b && typeof b.content === 'string' && b.content !== '')
+          : []
+        let sources = usable(this.listFor(k))
+        let origin = sources.length ? 'memory' : null
+        let donor = null
+        if (!sources.length) {
+          const saved = recoveryLoad(k)
+          sources = usable(saved && saved.blocks)
+          if (sources.length) origin = 'mirror'
+        }
+        if (!sources.length) {
+          donor = this.findCarryoverSource(k, draft)
+          if (donor) {
+            sources = usable(this.listFor(donor))
+            origin = 'carry-over (live)'
+          }
+        }
+        if (!sources.length) {
+          const scanned = recoveryScanDonor(k, draft)
+          if (scanned && scanned.blocks.length) {
+            donor = scanned.sid
+            sources = usable(scanned.blocks)
+            origin = 'carry-over (mirror)'
+          }
+        }
+        if (sources.length === 0) {
+          // Nothing to restore — invisible external residue (or the residue of
+          // a deliberately deleted chip whose node already carries none of our
+          // state). NEVER rewrite the draft for it: rewriting drops the caret,
+          // destroys an in-flight IME composition and re-seeds stale text over
+          // whatever the user typed in the meantime (0.2.2).
+          return false
+        }
+        try {
+          shell.setDraft(draft.replace(/\u200B/g, ''))
+        } catch (e) {
+          console.warn('[dsh-pcb] recovery: draft rewrite failed', e)
+          return false
+        }
+        // The draft — and with it the blocks — now belongs to this session:
+        // forget the (possibly moved) bookkeeping; attach() re-derives ids,
+        // labels and numbers, and re-mirrors under this sid.
+        this.forgetSession(k)
+        if (donor) {
+          this.forgetSession(donor)
+          recoveryClear(donor)
+          this.lastInput.delete(donor)
+        }
+        let restored = 0
+        for (const b of sources) {
+          const block = { lang: b.lang || '', content: b.content, lines: b.content.split(/\r?\n/), isCode: !!b.isCode, sourceText: b.sourceText || (typeof b.src === 'string' && b.src ? b.src : undefined) }
+          if (this.attach(k, block)) restored += 1
+        }
+        console.log('[dsh-pcb] recovery: re-attached', restored, 'of', sources.length, 'block(s) via', origin, donor ? `(donor ${donor})` : '')
+        return restored > 0
+      }
+
+      /** Unmounted session that still lists blocks and last published EXACTLY this draft. */
+      findCarryoverSource(targetSid, draft) {
+        let found = null
+        for (const [x, entries] of this.list) {
+          if (x === targetSid || entries.length === 0) continue
+          if (this.serializing.has(x)) continue
+          const listeners = this.listeners.get(x)
+          if (listeners && listeners.size > 0) continue // still mounted — draft did not move
+          if (this.lastInput.get(x) !== draft) continue
+          if (found) return null // ambiguous
+          found = x
+        }
+        return found
+      }
+
+      /** Drop a session's block bookkeeping (its chips are gone or moving). */
+      forgetSession(sessionId) {
+        const k = String(sessionId)
+        for (const b of this.listFor(k)) {
+          this.freeLabel(k, b.type, b.labelNumber)
+          this.refIndex.delete(b.id)
+          for (const [label, r] of this.labelIndex) if (r === b.id) this.labelIndex.delete(label)
+        }
+        this.list.delete(k)
+        this.selected.delete(k)
       }
 
       dispose() {
         for (const t of this.expiry.values()) clearTimeout(t)
+        for (const t of this.recoverTimer.values()) clearTimeout(t)
+        this.recoverTimer.clear()
         this.expiry.clear(); this.list.clear(); this.selected.clear()
         this.used.clear(); this.refIndex.clear(); this.labelIndex.clear()
         this.inFlight.clear(); this.serializing.clear(); this.listeners.clear()
@@ -727,6 +1053,12 @@ window.__ModuleLoader__.load({
       useComposerMark(railRef, props.sessionId, input.draftRev, blocks.length > 0)
 
       React.useEffect(() => {
+        // Recognize a text-only draft re-seed (workspace switch / reload)
+        // FIRST: re-attach lost chips before reconciliation prunes them. A
+        // successful recovery mutates the draft, so this pass must NOT
+        // reconcile against its now-stale snapshot — the next draftRev pass
+        // does that with fresh occurrences.
+        if (props.controller.recover(props.sessionId, input)) return
         props.controller.reconcile(props.sessionId, input.occurrences || [], input.phase)
       }, [props.controller, props.sessionId, input.draftRev, input.phase])
 
@@ -834,6 +1166,162 @@ window.__ModuleLoader__.load({
       )
     }
 
+    // ===== Sent-message fold =================================================
+    // A block that folded in the composer comes back *after send* as fenced
+    // text inside the user bubble (DSH renders user messages as plain
+    // pre-wrap runs), so the wall of text this plugin exists to prevent
+    // reappears in the transcript. scanFolds() (see apply) walks sent
+    // bubbles and folds every complete fenced block into a collapsed card:
+    //   [</>] python · 128 行        [⎘] ▾      (header click toggles)
+    // React owns the bubble's own children, so nothing is removed or
+    // reordered: the plainRun span being folded is hidden (display:none) and
+    // a host element we fully own is inserted directly after it. A content
+    // stamp on the run keeps the scan idempotent and self-refreshing — text
+    // or locale revision changes rebuild the host, and a fold that becomes
+    // unnecessary is undone. The copy button copies the RAW fenced text
+    // (exactly what was sent); the bubble's own copy/edit/delete bar is
+    // React-side and never sees this DOM.
+    const FOLD_HOST_CLASS = 'dsh-pcb-fold-host'
+    const FOLD_CARD_CLASS = 'dsh-pcb-fold'
+    const FOLD_RUN_ATTR = 'data-dsh-pcb-run'      // '1|<stamp>' folded · '0|<stamp>' checked, plain
+    const FOLD_STAMP_ATTR = 'data-dsh-pcb-stamp'  // on the host, matches the run's stamp
+    const FOLD_BUBBLE_SEL = [
+      '[data-chat-flow-kind="user"]',
+      '[data-chat-flow-kind="steering"]',
+      '[data-submission-echo]',
+      '[data-pending-steering]',
+    ].map((s) => `${s} [class*="bubble"]`).join(',')
+    const foldOpenKeys = new Set() // user-toggled-open cards, stable across rebuilds
+    let foldRev = 0                // bumped on locale switch so cards re-title
+
+    function hash32(str) {
+      let h = 0x811c9dc5
+      for (let i = 0; i < str.length; i += 1) {
+        h ^= str.charCodeAt(i)
+        h = Math.imul(h, 0x01000193)
+      }
+      return (h >>> 0).toString(36)
+    }
+
+    function foldStamp(text) {
+      return `${foldRev}:${text.length}:${hash32(text)}`
+    }
+
+    // Cheap pre-filter so the per-frame scan stays trivial on unfenced runs.
+    const FENCE_HINT = /(^|\n) {0,3}(```|~~~)/
+
+    function isFoldRun(el) {
+      return el.tagName === 'SPAN' && (el.getAttribute('class') || '').includes('plainRun')
+    }
+
+    /** Segments when the text holds at least one non-empty complete fence, else null. */
+    function foldPlanFor(text) {
+      if (!FENCE_HINT.test(text)) return null
+      const segments = splitFencedSegments(text)
+      let folds = 0
+      for (const seg of segments) if (seg.kind === 'fence' && seg.body.trim() !== '') folds += 1
+      return folds > 0 ? segments : null
+    }
+
+    function buildFoldCard(seg, openKey, t) {
+      const infoLang = (seg.lang || '').toLowerCase()
+      // Only an EXPLICIT ```text fence is a text block. The composer never
+      // emits a bare fence for prose (plain blocks always serialize as
+      // ```text), so a bare ``` fence is code whose language the composer
+      // could not name — fold it as a code card and re-guess the language
+      // for display. (0.2.0 bug: bare fences folded as 文本块, mismatching
+      // the 代码块 chip the message was drafted from.)
+      const isText = infoLang === 'text'
+      const lang = isText ? '' : (infoLang || detectLang(seg.body) || '')
+      const type = isText ? 'text' : 'code'
+      const lines = seg.body.split('\n').length
+      const open = foldOpenKeys.has(openKey)
+
+      const card = document.createElement('div')
+      card.className = FOLD_CARD_CLASS
+      card.setAttribute('data-pcb-type', type)
+      card.setAttribute('data-open', open ? '1' : '0')
+
+      const head = document.createElement('div')
+      head.className = 'dsh-pcb-fold-head'
+
+      const toggle = document.createElement('button')
+      toggle.type = 'button'
+      toggle.className = 'dsh-pcb-fold-toggle'
+      toggle.setAttribute('aria-expanded', open ? 'true' : 'false')
+      toggle.setAttribute('aria-label', t('fold.aria'))
+      toggle.title = t(open ? 'collapse' : 'expand')
+      const glyph = document.createElement('span')
+      glyph.className = 'dsh-pcb-fold-glyph'
+      glyph.setAttribute('aria-hidden', 'true')
+      glyph.textContent = type === 'code' ? '</>' : 'Aa'
+      const title = document.createElement('span')
+      title.className = 'dsh-pcb-fold-title'
+      title.textContent = foldTitle(t, type, lang, lines)
+      const chevron = document.createElement('span')
+      chevron.className = 'dsh-pcb-fold-chevron'
+      chevron.setAttribute('aria-hidden', 'true')
+      chevron.textContent = '▾'
+      toggle.append(glyph, title, chevron)
+
+      const copy = document.createElement('button')
+      copy.type = 'button'
+      copy.className = 'dsh-pcb-btn dsh-pcb-fold-copy'
+      copy.title = t('copy')
+      copy.setAttribute('aria-label', t('copy'))
+      copy.textContent = '⎘'
+      let copyTimer = 0
+      copy.addEventListener('click', (ev) => {
+        ev.preventDefault()
+        ev.stopPropagation()
+        try {
+          const done = navigator.clipboard?.writeText(seg.raw)
+          if (done && typeof done.then === 'function') {
+            done.then(() => {
+              copy.textContent = '✓'
+              clearTimeout(copyTimer)
+              copyTimer = setTimeout(() => { copy.textContent = '⎘' }, 1200)
+            }, () => {})
+          }
+        } catch (e) { /* noop */ }
+      })
+
+      head.append(toggle, copy)
+      const pre = document.createElement('pre')
+      pre.className = 'dsh-pcb-fold-body'
+      pre.textContent = seg.body
+      card.append(head, pre)
+
+      toggle.addEventListener('click', (ev) => {
+        ev.preventDefault()
+        ev.stopPropagation()
+        const nowOpen = card.getAttribute('data-open') !== '1'
+        card.setAttribute('data-open', nowOpen ? '1' : '0')
+        toggle.setAttribute('aria-expanded', nowOpen ? 'true' : 'false')
+        toggle.title = t(nowOpen ? 'collapse' : 'expand')
+        if (nowOpen) foldOpenKeys.add(openKey)
+        else foldOpenKeys.delete(openKey)
+      })
+      return card
+    }
+
+    function buildFoldHost(segments, keyBase, t) {
+      const host = document.createElement('div')
+      host.className = FOLD_HOST_CLASS
+      segments.forEach((seg, i) => {
+        if (seg.kind === 'fence' && seg.body.trim() !== '') {
+          host.appendChild(buildFoldCard(seg, `${keyBase}:${i}`, t))
+        } else {
+          const prose = document.createElement('span')
+          prose.className = 'dsh-pcb-fold-prose'
+          // An un-foldable fence (empty body) keeps its raw text, fences and all.
+          prose.textContent = seg.kind === 'fence' ? seg.raw : seg.text
+          host.appendChild(prose)
+        }
+      })
+      return host
+    }
+
     // ===== Styles ============================================================
     const CSS = `
       /* --- restyle DSH's inline reference chip into a boxed badge --- */
@@ -905,9 +1393,26 @@ window.__ModuleLoader__.load({
       /* --- hide the composer's own placeholder while chips/cards are active --- */
       [data-dsh-pcb-active="1"] [data-composer-placeholder]{visibility:hidden}
 
+      /* --- sent-message fold cards (conversation bubbles) --- */
+      .dsh-pcb-fold-host{box-sizing:border-box;display:flex;flex-direction:column;gap:8px;width:100%;min-width:0}
+      .dsh-pcb-fold-prose{white-space:pre-wrap;word-break:break-word}
+      .dsh-pcb-fold{box-sizing:border-box;width:100%;min-width:0;display:flex;flex-direction:column;border:1px solid var(--dsw-alias-border-l2);border-radius:12px;background:var(--dsw-specific-input-major,var(--dsw-alias-bg-layer-1));box-shadow:var(--dsw-shadow-lv1);color:var(--dsw-alias-label-primary);overflow:hidden}
+      .dsh-pcb-fold-head{box-sizing:border-box;min-height:34px;flex:none;display:flex;align-items:center;gap:4px;padding:0 6px 0 10px}
+      .dsh-pcb-fold-toggle{flex:1;min-width:0;display:flex;align-items:center;gap:7px;padding:0;border:0;background:transparent;color:inherit;font:inherit;text-align:left;cursor:pointer}
+      .dsh-pcb-fold-glyph{flex:none;font-family:var(--dsw-font-mono,ui-monospace,Menlo,Consolas,monospace);font-size:11px;font-weight:700;line-height:16px;opacity:.9}
+      .dsh-pcb-fold[data-pcb-type="code"] .dsh-pcb-fold-glyph{color:var(--dsw-alias-state-business-primary,#4c6ef5)}
+      .dsh-pcb-fold[data-pcb-type="text"] .dsh-pcb-fold-glyph{color:var(--dsw-alias-label-tertiary)}
+      .dsh-pcb-fold-title{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-family:var(--dsw-font-mono,ui-monospace,Menlo,Consolas,monospace);font-size:12px;line-height:18px;color:var(--dsw-alias-label-secondary)}
+      .dsh-pcb-fold[data-pcb-type="text"] .dsh-pcb-fold-title{font-family:var(--dsw-font-family)}
+      .dsh-pcb-fold-chevron{flex:none;width:14px;text-align:center;font-size:11px;line-height:1;color:var(--dsw-alias-label-tertiary);transition:transform .14s ease}
+      .dsh-pcb-fold[data-open="1"] .dsh-pcb-fold-chevron{transform:rotate(180deg)}
+      .dsh-pcb-fold[data-open="0"] .dsh-pcb-fold-body{display:none}
+      .dsh-pcb-fold-body{box-sizing:border-box;margin:0;max-height:360px;overflow:auto;padding:8px 12px;border-top:1px solid var(--dsw-alias-border-l2);font-family:var(--dsw-font-mono,ui-monospace,Menlo,Consolas,monospace);font-size:12px;line-height:1.5;white-space:pre;word-break:break-all;background:var(--dsw-alias-bg-base);color:var(--dsw-alias-label-primary);--dsh-scrollbar-thumb:var(--dsw-alias-scrollbar-bg-l2)}
+
       @media (max-width:640px){
         .dsh-pcb-head{height:34px}
         .dsh-pcb-lang{max-width:55%}
+        .dsh-pcb-fold-body{max-height:240px}
       }
       @media (pointer:coarse){
         .${CHIP_X_CLASS}{width:22px;height:22px;font-size:15px}
@@ -918,7 +1423,9 @@ window.__ModuleLoader__.load({
     const inject = ['slots', 'sessions', 'conversation', 'inputTriggers', 'locale']
 
     function apply(ctx) {
-      try { console.log('[dsh-paste-code-block] client loaded') } catch (e) { /* noop */ }
+      // Bump alongside package.json on every release — the load log is the
+      // only proof of WHICH bundle generation the browser actually loaded.
+      try { console.log('[dsh-paste-code-block] client loaded v0.2.5') } catch (e) { /* noop */ }
 
       // Publish our dictionaries under the plugin namespace, then bind a
       // translator that always reflects the ACTIVE DSH language (Settings →
@@ -932,7 +1439,10 @@ window.__ModuleLoader__.load({
         : createT(detectBrowserLocale())
 
       const controller = new BlockController(ctx, t)
+      // Test seam (tests/fold-smoke.test.js drives recover() directly).
+      exports.__controllerForTests = controller
       ctx.effect(() => () => controller.dispose(), 'paste-code-block: state')
+      try { recoveryPruneExpired() } catch (e) { /* private mode: recovery simply off */ }
 
       // ----- chip DOM sync: localized labels + per-chip ✕ delete button -----
       function scanChips() {
@@ -983,10 +1493,73 @@ window.__ModuleLoader__.load({
         }
       }
 
+      // ----- sent-message fold: the scan ------------------------------------
+      function foldRun(run, plan, keyBase, stamp) {
+        run.setAttribute(FOLD_RUN_ATTR, `1|${stamp}`)
+        run.style.display = 'none'
+        const next = run.nextElementSibling
+        if (next && next.classList.contains(FOLD_HOST_CLASS)) {
+          if (next.getAttribute(FOLD_STAMP_ATTR) === stamp) return // already current
+          next.remove()
+        }
+        const host = buildFoldHost(plan, keyBase, t)
+        host.setAttribute(FOLD_STAMP_ATTR, stamp)
+        run.insertAdjacentElement('afterend', host)
+      }
+
+      /** Restore a previously folded run to DSH's own rendering. */
+      function unfoldRun(run, stamp) {
+        const next = run.nextElementSibling
+        if (next && next.classList.contains(FOLD_HOST_CLASS)) next.remove()
+        run.style.display = ''
+        run.setAttribute(FOLD_RUN_ATTR, `0|${stamp}`)
+      }
+
+      function scanFolds() {
+        if (typeof document === 'undefined') return
+        let bubbles
+        try { bubbles = document.querySelectorAll(FOLD_BUBBLE_SEL) } catch (e) { return }
+        for (const bubble of bubbles) {
+          if (!bubble.isConnected) continue
+          const holder = bubble.closest('[data-chat-flow-key]')
+          const flowKey = holder ? holder.getAttribute('data-chat-flow-key') || '' : ''
+          const kids = [...bubble.children]
+          for (let i = 0; i < kids.length; i += 1) {
+            const el = kids[i]
+            if (el.classList.contains(FOLD_HOST_CLASS)) continue
+            if (!isFoldRun(el)) continue
+            const text = el.textContent || ''
+            const stamp = foldStamp(text)
+            const marked = el.getAttribute(FOLD_RUN_ATTR) || ''
+            if (marked === `1|${stamp}` || marked === `0|${stamp}`) continue // current
+            const plan = foldPlanFor(text)
+            if (!plan) {
+              if (marked.startsWith('1|')) unfoldRun(el, stamp)
+              else el.setAttribute(FOLD_RUN_ATTR, `0|${stamp}`)
+              continue
+            }
+            // Echo/pending rows have no flow key — fall back to a content hash so
+            // two simultaneous unkeyed rows never share one open-state slot.
+            const keyBase = `${flowKey || 'h' + hash32(text)}#${i}`
+            foldRun(el, plan, keyBase, stamp)
+          }
+          // Drop orphan hosts (e.g. React remounted the run span underneath us).
+          for (const el of [...bubble.children]) {
+            if (!el.classList.contains(FOLD_HOST_CLASS)) continue
+            const prev = el.previousElementSibling
+            const mark = prev && prev.getAttribute ? prev.getAttribute(FOLD_RUN_ATTR) : null
+            const keep = !!mark && mark.startsWith('1|') &&
+              prev.style.display === 'none' &&
+              el.getAttribute(FOLD_STAMP_ATTR) === mark.slice(2)
+            if (!keep) el.remove()
+          }
+        }
+      }
+
       let scanScheduled = 0
       function scheduleScan() {
         if (scanScheduled) return
-        const run = () => { scanScheduled = 0; scanChips() }
+        const run = () => { scanScheduled = 0; scanChips(); scanFolds() }
         scanScheduled = typeof requestAnimationFrame === 'function' ? requestAnimationFrame(run) : setTimeout(run, 16)
       }
 
@@ -998,13 +1571,28 @@ window.__ModuleLoader__.load({
       }, 'paste-code-block: chip sync observer')
 
       // A locale switch (or a late dictionary registration bumps the revision
-      // too) re-derives labels: controller state first, chip DOM second.
+      // too) re-derives labels: controller state first, chip DOM second. Sent
+      // fold cards are rebuilt the same way — bumping foldRev invalidates
+      // every run stamp, so the next scan re-titles the cards in the new
+      // language while foldOpenKeys keeps who was expanded.
       ctx.effect(() => {
         const face = ctx.locale
         if (!face || typeof face.subscribe !== 'function') return undefined
-        return face.subscribe(() => { controller.retitleAll(); scheduleScan() })
+        return face.subscribe(() => { controller.retitleAll(); foldRev += 1; scheduleScan() })
       }, 'paste-code-block: locale sync')
-      scheduleScan() // late-mount safety for chips rendered before plugin boot
+      scheduleScan() // late-mount safety for chips and sent bubbles rendered before plugin boot
+
+      // On dispose (plugin removed / HMR swap) hand the transcript back to DSH.
+      ctx.effect(() => () => {
+        try {
+          for (const host of document.querySelectorAll(`.${FOLD_HOST_CLASS}`)) host.remove()
+          for (const run of document.querySelectorAll(`[${FOLD_RUN_ATTR}]`)) {
+            run.style.display = ''
+            run.removeAttribute(FOLD_RUN_ATTR)
+          }
+        } catch (e) { /* noop */ }
+        foldOpenKeys.clear()
+      }, 'paste-code-block: fold restore')
 
       ctx.effect(() => ctx.inputTriggers.registerSource({
         trigger: '@',
@@ -1026,6 +1614,34 @@ window.__ModuleLoader__.load({
         return () => style.remove()
       }, 'paste-code-block: styles')
 
+      // Paste-storm guard. External automation — a Tampermonkey AutoClicker,
+      // a clipboard bridge, IME glue, or a held-down Ctrl+V — can re-dispatch
+      // the SAME clipboard text dozens of times a second. Each accepted paste
+      // mints a new block, so a storm stuffs the composer with duplicate
+      // chips. Collapse runs of an identical clipboard text that arrive faster
+      // than a human can act into a single paste (a 1200 ms sliding window,
+      // refreshed on every matching event, so a held repeat stays suppressed
+      // while it continues). 0.2.4 added a content-liveness dedup that ALSO
+      // suppressed a re-paste of the same text while its block was still
+      // attached — that made "paste the same snippet twice" impossible, which
+      // users hit immediately. 0.2.5 reverts that: identical text pasted after
+      // the burst window is a fresh intent and gets its own block. Only
+      // machine-paced repeats within the window are collapsed.
+      const STORM_WINDOW_MS = 1200
+      const pasteStorm = {
+        lastText: '',
+        lastAt: 0,
+        // True when this text is the tail of a storm; every call refreshes
+        // the window, so a held repeat stays suppressed while it continues.
+        seen(text, now) {
+          const dup = text === this.lastText && now - this.lastAt < STORM_WINDOW_MS
+          this.lastText = text
+          this.lastAt = now
+          return dup
+        },
+      }
+      exports.__pasteStormForTests = pasteStorm
+
       // Turn qualifying pastes into boxed inline chips.
       const onPaste = (ev) => {
         const clip = ev.clipboardData
@@ -1038,7 +1654,19 @@ window.__ModuleLoader__.load({
         if (!sid) return
         const block = parseBlock(text)
         if (!block) { console.log('[dsh-paste-code-block] paste NOT block', text.length); return }
-        console.log('[dsh-paste-code-block] intercept', block.isCode ? 'code' : 'text', block.lines.length, 'lang=', block.lang)
+        if (pasteStorm.seen(text, Date.now())) {
+          // Consume the event (never let the raw text fall through to the
+          // composer) but create nothing.
+          ev.preventDefault()
+          ev.stopPropagation()
+          console.log('[dsh-paste-code-block] storm paste ignored (<' + STORM_WINDOW_MS + 'ms repeat)')
+          return
+        }
+        block.sourceText = text
+        // trusted=false means a page script dispatched this paste (userscript,
+        // clipboard bridge, replay glue) rather than a real keystroke — the
+        // load-log line that names the source when a storm report comes in.
+        console.log('[dsh-paste-code-block] intercept', block.isCode ? 'code' : 'text', block.lines.length, 'lang=', block.lang, 'trusted=', ev.isTrusted)
         ev.preventDefault()
         ev.stopPropagation()
         try {

package/src/i18n.js

@@ -34,6 +34,9 @@ export const zh = {
   'edit.aria': '编辑代码块内容',
   'error.stale': '代码块已失效，请重新粘贴',
   'error.remove': '无法删除该块，请重试',
+  'fold.code': '代码块',
+  'fold.text': '文本块',
+  'fold.aria': '展开或折叠该块',
 }
 
 /** English dictionary, key-identical to the Chinese source of truth. */
@@ -53,6 +56,9 @@ export const en = {
   'edit.aria': 'Edit block content',
   'error.stale': 'This block is no longer valid — paste it again',
   'error.remove': 'Could not remove the block — please retry',
+  'fold.code': 'Code',
+  'fold.text': 'Text',
+  'fold.aria': 'Expand or collapse this block',
 }
 
 /** Shipped dictionaries keyed by locale id (mirrors DSH's built-in zh/en set). */
@@ -97,6 +103,19 @@ export function blockLabel(t, type, n) {
   return t(type === 'code' ? 'block.code' : 'block.text', { n })
 }
 
+/**
+ * Build the title of a SENT-message fold card: `python · 128 行` /
+ * `Code · 128 lines`. `lang` (the fence info string) names code cards when
+ * present; text cards and untagged code cards fall back to the localized
+ * type name. Line count always renders, so users can gauge size while the
+ * card is collapsed.
+ */
+export function foldTitle(t, type, lang, lines) {
+  const meta = t(lines === 1 ? 'lines.one' : 'lines.other', { count: lines })
+  const name = type === 'code' ? (lang || t('fold.code')) : t('fold.text')
+  return `${name} · ${meta}`
+}
+
 /**
  * Recognize a rendered block label in ANY shipped locale (or a pre-0.1.3
  * legacy locale) and recover its `{ type, n }` identity. This lets a chip

package/src/parse.js

@@ -99,4 +99,68 @@ export function countMarkdownSignals(text) {
 export function serializeBlock(block) {
   const lang = block.isCode ? (block.lang || '') : 'text'
   return `\n\`\`\`${lang}\n${block.content}\n\`\`\`\n`
+}
+
+/**
+ * Split a message text into ordered `prose` / `fence` segments using GFM-style
+ * fenced code blocks (``` or ~~~, opening fence indented at most 3 spaces,
+ * closing fence of >= the opening length and alone on its line).
+ *
+ * Used by the sent-message fold scanner (see design.md §12): a message the
+ * plugin serialized on send comes back as fenced text inside the user
+ * bubble, and this function locates the fences so each can be rendered as a
+ * collapsed card while the surrounding prose stays visible.
+ *
+ * Returns [] for empty input. Segments:
+ *  - { kind: 'prose', text }                          — verbatim lines between fences
+ *  - { kind: 'fence', lang, info, body, raw }         — complete, terminated fence
+ *      lang  = first word of the info string ('' when absent)
+ *      info  = trimmed info string
+ *      body  = content between the fence lines (no fences, verbatim)
+ *      raw   = the whole slice including both fence lines
+ * An unterminated opening fence (no matching close) is kept in the prose run
+ * — conservative: we never fold text we are not sure ended.
+ */
+export function splitFencedSegments(text) {
+  const src = String(text == null ? '' : text)
+  if (!src) return []
+  const lines = src.split(/\r?\n/)
+  const segments = []
+  const OPEN = /^ {0,3}(`{3,}|~{3,})(.*)$/
+  let proseStart = 0
+  let i = 0
+  const flushProse = (end) => {
+    if (end > proseStart) segments.push({ kind: 'prose', text: lines.slice(proseStart, end).join('\n') })
+  }
+  while (i < lines.length) {
+    const m = OPEN.exec(lines[i])
+    if (!m) { i += 1; continue }
+    const marker = m[1]
+    const ch = marker[0]
+    const info = m[2].trim()
+    // A ``` fence's info string may not contain backticks (GFM); if it does,
+    // this line is ordinary prose, not an opener.
+    if (ch === '`' && info.includes('`')) { i += 1; continue }
+    const closeRe = new RegExp('^ {0,3}' + (ch === '`' ? '`' : '~') + '{' + marker.length + ',}[ \\t]*$')
+    let j = i + 1
+    let closed = false
+    while (j < lines.length) {
+      if (closeRe.test(lines[j])) { closed = true; break }
+      j += 1
+    }
+    if (!closed) { i += 1; continue } // unterminated -> stays prose, keep scanning
+    flushProse(i)
+    const bodyLines = lines.slice(i + 1, j)
+    segments.push({
+      kind: 'fence',
+      lang: info ? info.split(/\s+/)[0] : '',
+      info,
+      body: bodyLines.join('\n'),
+      raw: lines.slice(i, j + 1).join('\n'),
+    })
+    i = j + 1
+    proseStart = i
+  }
+  flushProse(lines.length)
+  return segments
 }