dsh-paste-code-block 0.1.3 → 0.2.6

package/src/client.js

@@ -17,6 +17,20 @@ window.__ModuleLoader__.load({
     const DETAIL_NS = 'dsh-pcb-detail'
     const CHIP_X_CLASS = 'dsh-pcb-chip-x'
 
+    // ===== diagnostics =======================================================
+    // Off by default. Set `window.__PCB_DEBUG__ = true` in the console (then
+    // paste / send) to trace paste parsing and fold decisions. The on-screen
+    // badge that used to sit above the composer was scaffolding for one
+    // debugging session and is gone.
+    const PCB_DEBUG = (() => {
+      try { return typeof window !== 'undefined' && window.__PCB_DEBUG__ === true } catch (e) { return false }
+    })()
+    function pcbDiag(kind, info) {
+      if (!PCB_DEBUG) return
+      try { console.log('[pcb-diag]', kind + (info ? ': ' + info : '')) } catch (e) {}
+    }
+    // =========================================================================
+
     // ----- shared chip-DOM helpers ------------------------------------------
     // Module level on purpose: the chip sync scan and the controller's removal
     // path both need to map a chip host element back to its label (and its
@@ -109,6 +123,9 @@ window.__ModuleLoader__.load({
         'edit.aria': '编辑代码块内容',
         'error.stale': '代码块已失效，请重新粘贴',
         'error.remove': '无法删除该块，请重试',
+        'fold.code': '代码块',
+        'fold.text': '文本块',
+        'fold.aria': '展开或折叠该块',
       },
       en: {
         'block.code': 'Code #{n}',
@@ -126,6 +143,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 +158,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())
@@ -205,6 +232,25 @@ window.__ModuleLoader__.load({
       return ''
     }
 
+    /**
+     * The single complete fence of `text`, or null when the text is not exactly
+     * one fenced block (blank lines around it tolerated, real prose not).
+     * Keep in sync with src/parse.js#wholeFence.
+     */
+    function wholeFence(text) {
+      const segs = splitFencedSegments(text)
+      let fence = null
+      for (const seg of segs) {
+        if (seg.kind === 'fence') {
+          if (fence) return null
+          fence = seg
+        } else if (seg.text.trim() !== '') {
+          return null
+        }
+      }
+      return fence
+    }
+
     /**
      * Parse pasted text into a block, or null when it is ordinary short prose
      * that should paste plainly. `isCode` drives both the chip label
@@ -215,12 +261,42 @@ window.__ModuleLoader__.load({
       const text = String(raw || '').replace(/^\uFEFF/, '')
       if (!text) return null
 
-      const fm = /^\s*```([\w+-]*)[^\n]*\n([\s\S]*?)\n?\s*```\s*$/.exec(text)
-      if (fm) {
-        const lang = (fm[1] || '').trim()
-        const content = fm[2].replace(/\n+$/, '')
+      // (1) exactly one complete fence: this plugin's own output shape. The
+      // fence's info string decides the type, so an explicit ```text paste is
+      // a TEXT block and round-trips instead of degrading into bare code.
+      const whole = wholeFence(text)
+      if (whole) {
+        const content = whole.body.replace(/\n+$/, '')
         if (!content) return null
-        return { lang, content, lines: content.split(/\r?\n/), isCode: true }
+        const infoLang = (whole.lang || '').toLowerCase()
+        return {
+          lang: infoLang === 'text' ? '' : whole.lang,
+          content,
+          lines: content.split(/\r?\n/),
+          isCode: infoLang !== 'text',
+        }
+      }
+
+      // (2) a paste that OPENS with a fence but carries trailing prose — the
+      // copy-a-whole-previous-message case. Keep it as ONE block and take the
+      // type from the leading fence's info string, so the chip and the
+      // transcript agree. (0.2.5 treated it as code and re-wrapped the
+      // already-fenced text in a bare fence: two nested fences in the bubble.)
+      const segs = splitFencedSegments(text)
+      let leadFence = -1
+      for (let i = 0; i < segs.length; i += 1) {
+        if (segs[i].kind === 'fence') { leadFence = i; break }
+        if (segs[i].text.trim() !== '') break
+      }
+      if (leadFence >= 0) {
+        const leadLang = (segs[leadFence].lang || '').toLowerCase()
+        const content = text.replace(/\n+$/, '')
+        return {
+          lang: leadLang === 'text' ? '' : segs[leadFence].lang,
+          content,
+          lines: content.split(/\r?\n/),
+          isCode: leadLang !== 'text',
+        }
       }
 
       const multi = /\r?\n/.test(text)
@@ -264,9 +340,225 @@ window.__ModuleLoader__.load({
       return n
     }
 
+    /**
+     * Backtick marker long enough to wrap `content` unambiguously: longer than
+     * the longest backtick run inside it. Keep in sync with
+     * src/parse.js#fenceMarkerFor.
+     */
+    function fenceMarkerFor(content) {
+      const src = String(content == null ? '' : content)
+      let longest = 0
+      const runs = src.match(/`+/g)
+      if (runs) for (const run of runs) if (run.length > longest) longest = run.length
+      return '`'.repeat(Math.max(3, longest + 1))
+    }
+
     function serializeBlock(block) {
       const lang = block.isCode ? (block.lang || '') : 'text'
-      return `\n\`\`\`${lang}\n${block.content}\n\`\`\`\n`
+      const marker = fenceMarkerFor(block.content)
+      return `\n${marker}${lang}\n${block.content}\n${marker}\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
+    }
+
+    /**
+     * Character ranges of every complete fence in `text`, in order, as
+     * { start, end } (end exclusive, both fence lines included). Same pairing
+     * rules as splitFencedSegments. Keep in sync with src/parse.js#fenceRanges.
+     */
+    function fenceRanges(text) {
+      const src = String(text == null ? '' : text)
+      const out = []
+      if (!src) return out
+      const starts = [0]
+      for (let i = 0; i < src.length; i += 1) if (src.charCodeAt(i) === 10) starts.push(i + 1)
+      const lineEnd = (n) => (n + 1 < starts.length ? starts[n + 1] - 1 : src.length)
+      const lineText = (n) => src.slice(starts[n], lineEnd(n)).replace(/\r$/, '')
+      const OPEN = /^ {0,3}(`{3,}|~{3,})(.*)$/
+      let i = 0
+      while (i < starts.length) {
+        const m = OPEN.exec(lineText(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 < starts.length) {
+          if (closeRe.test(lineText(j))) { closed = true; break }
+          j += 1
+        }
+        if (!closed) { i += 1; continue }
+        out.push({ start: starts[i], end: starts[j] + lineText(j).length })
+        i = j + 1
+      }
+      return out
+    }
+
+    /**
+     * How the sent-message fold scan should fold `text`, given the run texts
+     * DSH actually rendered it as. Keep in sync with src/parse.js#planFoldRuns.
+     * Returns null when nothing is foldable, else
+     *   { mode:'single', segments, runs }  — every fence lies inside ONE run
+     *   { mode:'bubble', segments, fences } — a fence straddles run boundaries
+     */
+    function planFoldRuns(text, runTexts) {
+      const src = String(text == null ? '' : text)
+      const segments = splitFencedSegments(src)
+      const fenceSegs = segments.filter((seg) => seg.kind === 'fence')
+      const spans = fenceRanges(src)
+      if (fenceSegs.length !== spans.length) return null
+      const fences = []
+      fenceSegs.forEach((seg, k) => { if (seg.body.trim() !== '') fences.push(spans[k]) })
+      if (!fences.length) return null
+
+      const bounds = []
+      let at = 0
+      for (const rt of (runTexts || [])) {
+        const len = String(rt == null ? '' : rt).length
+        bounds.push([at, at + len])
+        at += len
+      }
+      const runOf = (off) => {
+        for (let k = 0; k < bounds.length; k += 1) if (off >= bounds[k][0] && off < bounds[k][1]) return k
+        return -1
+      }
+      const runs = []
+      for (const f of fences) {
+        const a = runOf(f.start)
+        const b = runOf(Math.max(f.start, f.end - 1))
+        if (a < 0 || a !== b) return { mode: 'bubble', segments, fences }
+        if (!runs.includes(a)) runs.push(a)
+      }
+      return { mode: 'single', segments, runs }
+    }
+
+    // ===== 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 ==================================================
@@ -289,6 +581,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
       }
 
@@ -372,7 +666,11 @@ window.__ModuleLoader__.load({
       insertReference(sessionId, block) {
         const { actx, shell } = this.scope(sessionId)
         const input = shell.snapshot
-        if (!input || input.phase !== 'plain') return false
+        // DSH's SessionInputShell.insertReference accepts both `plain` and
+        // `claimed` phases; mirror that so a paste while a command draft is
+        // still pending (claimed) folds into a chip instead of falling back to
+        // raw text. Submitting/adjudicating (mid-submit) stay rejected.
+        if (!input || (input.phase !== 'plain' && input.phase !== 'claimed')) return false
         // Each chip contributes exactly one char to the editor's detect text
         // (the "" placeholder) and one char to the plain `draft` projection
         // (clipboardText = zero-width space, chosen because String#trim() does
@@ -445,6 +743,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 +878,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 +887,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 +957,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 +984,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 +1208,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 +1321,163 @@ 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_STAMP_ATTR = 'data-dsh-pcb-stamp'  // on a host: the content stamp it was built from
+    const FOLD_HIDE_ATTR = 'data-dsh-pcb-hide'    // on every run the scan hid: the same stamp
+    const FOLD_SIG_ATTR = 'data-dsh-pcb-sig'      // on the bubble: '<mode>|<stamp>' it was folded for
+    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 +1549,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 +1579,10 @@ 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 */ }
+      try { pcbDiag('LOADED', 'v0.2.5-diag') } catch (e) {}
+      // 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 +1596,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 +1650,112 @@ window.__ModuleLoader__.load({
         }
       }
 
+      // ----- sent-message fold: the scan ------------------------------------
+      // DSH renders a sent message as plain pre-wrap runs and SPLITS those runs
+      // at every @mention chip, so one serialized block can arrive as several
+      // sibling runs with the fence opener in one and its closer in another.
+      // A per-run scan then sees only an unterminated half (nothing to fold) —
+      // or, worse, a fragment that happens to look like a complete fence, which
+      // is how a bogus card built from the tail of the message used to appear.
+      // So fold at BUBBLE scope: rebuild the text from the runs, plan the
+      // fences over that, and keep the per-run path only when every fence sits
+      // inside a single run (which leaves DSH's mention chips clickable).
+      const foldedBubbles = new WeakSet()
+
+      /** Hand a bubble back to DSH's own rendering. */
+      function clearFolds(bubble) {
+        for (const el of [...bubble.children]) {
+          if (el.classList.contains(FOLD_HOST_CLASS)) { el.remove(); continue }
+          if (el.getAttribute(FOLD_HIDE_ATTR) !== null) {
+            el.style.display = ''
+            el.removeAttribute(FOLD_HIDE_ATTR)
+          }
+        }
+        bubble.removeAttribute(FOLD_SIG_ATTR)
+        foldedBubbles.delete(bubble)
+      }
+
+      /** True when the DOM still matches what `sig` claims (React remounts runs). */
+      function foldsIntact(bubble, mode, stamp, wanted) {
+        const kids = [...bubble.children]
+        const hosts = kids.filter((el) => el.classList.contains(FOLD_HOST_CLASS))
+        if (hosts.length !== (mode === 'bubble' ? 1 : wanted)) return false
+        for (const host of hosts) if (host.getAttribute(FOLD_STAMP_ATTR) !== stamp) return false
+        const hidden = kids.filter((el) => el.getAttribute(FOLD_HIDE_ATTR) === stamp)
+        if (hidden.length !== wanted) return false
+        for (const el of hidden) if (el.style.display !== 'none') return false
+        return true
+      }
+
+      function foldBubble(bubble) {
+        const holder = bubble.closest('[data-chat-flow-key]')
+        const flowKey = holder ? holder.getAttribute('data-chat-flow-key') || '' : ''
+        const runs = [...bubble.children].filter((el) => !el.classList.contains(FOLD_HOST_CLASS))
+        const texts = runs.map((el) => el.textContent || '')
+        const full = texts.join('')
+        const stamp = foldStamp(full)
+        // Cheap guard first: most messages carry no fence at all.
+        const plan = runs.length && FENCE_HINT.test(full) ? planFoldRuns(full, texts) : null
+        let mode = plan ? plan.mode : ''
+        let subs = []
+        if (plan && mode === 'single') {
+          for (const k of plan.runs) {
+            const sub = foldPlanFor(texts[k])
+            if (sub) subs.push([k, sub])
+          }
+          // A run we cannot plan for (a mention chip, a wrapper element) is not
+          // ours to hide — rebuild the bubble instead.
+          if (!subs.length || plan.runs.some((k) => !isFoldRun(runs[k]))) mode = 'bubble'
+        }
+        const sig = plan ? `${mode}|${stamp}` : ''
+        const wanted = plan ? (mode === 'bubble' ? runs.length : subs.length) : 0
+        if (plan && bubble.getAttribute(FOLD_SIG_ATTR) === sig && foldsIntact(bubble, mode, stamp, wanted)) return
+        if (!plan && !foldedBubbles.has(bubble)) return
+        clearFolds(bubble)
+        if (!plan) return
+        const keyBase = flowKey || 'h' + hash32(full)
+        const fenceCount = plan.fences ? plan.fences.length : (plan.runs || []).length
+        pcbDiag('FOLD', 'mode=' + mode + ' runs=' + runs.length + ' fences=' + fenceCount +
+          ' hide=' + (mode === 'bubble' ? 'all' : subs.map((s) => s[0]).join(',')) + ' len=' + full.length)
+        if (mode === 'bubble') {
+          // Hide every run and render the whole message from the plan, so the
+          // fence that straddled them is paired again. Mention chips inside the
+          // folded text lose their click target — they are collapsed content.
+          const host = buildFoldHost(plan.segments, `${keyBase}#b`, t)
+          host.setAttribute(FOLD_STAMP_ATTR, stamp)
+          for (const el of runs) {
+            el.style.display = 'none'
+            el.setAttribute(FOLD_HIDE_ATTR, stamp)
+          }
+          bubble.appendChild(host)
+        } else {
+          for (const [k, sub] of subs.slice().sort((a, b) => a[0] - b[0])) {
+            const el = runs[k]
+            el.style.display = 'none'
+            el.setAttribute(FOLD_HIDE_ATTR, stamp)
+            const host = buildFoldHost(sub, `${keyBase}#${k}`, t)
+            host.setAttribute(FOLD_STAMP_ATTR, stamp)
+            el.insertAdjacentElement('afterend', host)
+          }
+        }
+        bubble.setAttribute(FOLD_SIG_ATTR, sig)
+        foldedBubbles.add(bubble)
+      }
+
+      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
+          try { foldBubble(bubble) } catch (e) { /* never break DSH's render loop */ }
+        }
+      }
+
       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 +1767,29 @@ 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_HIDE_ATTR}]`)) {
+            run.style.display = ''
+            run.removeAttribute(FOLD_HIDE_ATTR)
+          }
+          for (const bubble of document.querySelectorAll(`[${FOLD_SIG_ATTR}]`)) bubble.removeAttribute(FOLD_SIG_ATTR)
+        } catch (e) { /* noop */ }
+        foldOpenKeys.clear()
+      }, 'paste-code-block: fold restore')
 
       ctx.effect(() => ctx.inputTriggers.registerSource({
         trigger: '@',
@@ -1026,6 +1811,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
@@ -1035,14 +1848,30 @@ window.__ModuleLoader__.load({
         const target = document.activeElement
         if (!target || !(target instanceof Element)) return
         const sid = sessionFor(target)
-        if (!sid) return
+        if (!sid) { pcbDiag("EXIT-SID-NULL", "activeEl=" + target.tagName + "." + (target.className || "") + " mark=" + !!document.querySelector("[data-dsh-pcb]")); 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 (!block) { pcbDiag("EXIT-NOT-BLOCK", "len=" + text.length); console.log('[dsh-paste-code-block] paste NOT block', text.length); return }
+        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()
+          pcbDiag("EXIT-STORM", "len=" + text.length);
+          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.
+        pcbDiag("ENTER-INTERCEPT", "sid=" + sid + " lines=" + block.lines.length + " code=" + block.isCode + " trusted=" + ev.isTrusted);
+        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 {
           if (!controller.attach(sid, block)) {
+            const snapX = (() => { try { const s = controller.scope(sid).shell.snapshot; return "phase=" + (s && s.phase) + " draftLen=" + (s && s.draft ? s.draft.length : -1) + " rev=" + (s && s.draftRev) } catch (e) { return "scope-throw:" + e.message } })();
+            pcbDiag("EXIT-ATTACH-FAIL", snapX);
             console.log('[dsh-paste-code-block] attach failed; plain insert instead')
             const { actx, shell } = controller.scope(sid)
             const input = shell.snapshot
@@ -1057,6 +1886,17 @@ window.__ModuleLoader__.load({
               console.warn('[dsh-paste-code-block] could not insert block text')
             }
           }
+          pcbDiag("OK-ATTACHED", "id=" + block.id);
+          setTimeout(() => { try {
+            const sc = controller.scope(sid).shell.snapshot || {};
+            const occ = (sc.occurrences || []).filter((o) => o.source === 'paste-code-block').length;
+            var __chip = document.querySelector('[data-composer-chip="paste-code-block"]'); var __r = __chip && __chip.getBoundingClientRect(); var __cs = __chip && getComputedStyle(__chip); var __csi = __chip && __chip.firstElementChild && getComputedStyle(__chip.firstElementChild); pcbDiag("POST-ATTACH", "phase=" + sc.phase + " draftLen=" + (sc.draft ? sc.draft.length : -1) + " occ=" + occ + " chips=" + document.querySelectorAll('[data-composer-chip="paste-code-block"]').length);
+            var __hosts = []; var __seen = new Set();
+            document.querySelectorAll('[data-composer-chip]').forEach(function (c) { var k = c.getAttribute('data-composer-chip') + '|' + (c.closest('[data-composer-seat]') ? 'seat' : (c.closest('[data-message-id],[data-message-id] *,.dsh-msg,.message') ? 'msg' : '?')); if (!__seen.has(k)) { __seen.add(k); __hosts.push(k) } });
+            pcbDiag("CHIP-HOSTS", __hosts.join(',') || 'none');
+            var __seats = [].map.call(document.querySelectorAll('[data-composer-seat]'), function (s) { return s.getBoundingClientRect().width + 'x' + Math.round(s.getBoundingClientRect().height) }).join(',');
+            pcbDiag("SEATS", "n=" + document.querySelectorAll('[data-composer-seat]').length + " sizes=" + (__seats || '-') + " ce=" + document.querySelectorAll('[contenteditable="true"]').length); pcbDiag("CHIP-DOM", __chip ? ("rect=" + Math.round(__r.width) + "x" + Math.round(__r.height) + "@" + Math.round(__r.x) + "," + Math.round(__r.y) + " disp=" + __cs.display + " vis=" + __cs.visibility + " op=" + __cs.opacity + " innerDisp=" + (__csi ? __csi.display : "?") + " txt=(" + __chip.textContent.slice(0, 24) + ") parent=" + (__chip.parentElement ? __chip.parentElement.tagName + "." + String(__chip.parentElement.className).slice(0, 40) : "?")) : "NO-CHIP");
+          } catch (e) { pcbDiag("POST-ATTACH-THROW", e.message) } }, 350);
         } catch (err) {
           console.error('[paste-code-block] attach failed:', err)
         }