@cardinal4/opencode-fold-diffs 0.3.6 → 0.3.8

package/README.md

@@ -1,7 +1,7 @@
 # opencode-fold-diffs
 
 > [!NOTE]
-> **Unofficial OpenCode V2 port of [Tanner Bruhn](https://github.com/tannerbruhn)'s [`opencode-fold-diffs`](https://github.com/tannerbruhn/opencode-fold-diffs) (npm: `opencode-fold-diffs`) — the OpenCode V1 plugin.** This fork — [`cardin/opencode-fold-diffs`](https://github.com/cardin/opencode-fold-diffs), published as [`@cardinal4/opencode-fold-diffs`](https://www.npmjs.com/package/@cardinal4/opencode-fold-diffs) — ports it to **OpenCode V2** (`@opencode/cli` 2.x, `opencode v2.0.x`). Install this fork on V2, upstream on V1. Tanner has not reviewed or endorsed it; report bugs here, not upstream.
+> **Unofficial OpenCode V2 port of [Tanner Bruhn](https://github.com/tannerbruhn)'s [`opencode-fold-diffs`](https://github.com/tannerbruhn/opencode-fold-diffs) (npm: `opencode-fold-diffs`) — the OpenCode V1 plugin.** This fork — [`cardin/opencode-fold-diffs`](https://github.com/cardin/opencode-fold-diffs), published as [`@cardinal4/opencode-fold-diffs`](https://www.npmjs.com/package/@cardinal4/opencode-fold-diffs) — targets **OpenCode V2** (`@opencode/cli` 2.x, API-checked against `opencode 2.2.3` and OpenTUI 0.8.x). Install this fork on V2, upstream on V1. Tanner has not reviewed or endorsed it; report bugs here, not upstream.
 
 **Every `write`, `edit` and `apply_patch` dumps the whole file or the whole diff into your transcript, and stays there.** This plugin folds those blocks down to their header line — `# Wrote 40 lines · click to expand  src/app.ts` — and opens them again on click, or with a fold/unfold-all key if you configure one.
 
@@ -33,7 +33,9 @@ Click the row to open it. If you set the `key` option, that binding folds or unf
 opencode plugin add @cardinal4/opencode-fold-diffs
 ```
 
-Then list it in your CLI config so the terminal loads the TUI entrypoint. Add it to `~/.config/opencode/cli.json` (or `$XDG_CONFIG_HOME/opencode/cli.json`):
+That installs the package and adds it to the global `opencode.json`. The package ships a server entry (`index.js`), a portable RPC bridge (`rpc.js`) and a TUI entry (`tui.js`); the TUI part loads automatically with the server entry, so no second configuration is needed.
+
+If the terminal connects to a **remote server**, list the package in `~/.config/opencode/cli.json` (or `$XDG_CONFIG_HOME/opencode/cli.json`) instead so the local TUI loads the TUI part. Do not list it in both files:
 
 ```json
 {
@@ -42,9 +44,7 @@ Then list it in your CLI config so the terminal loads the TUI entrypoint. Add it
 }
 ```
 
-This plugin's behavior is TUI-only (its server entry is a no-op that exists so OpenCode can discover it by id), so configure it in `cli.json`. TUI plugins also stay active when the terminal connects to a remote server.
-
-With options:
+Options can go on the plugin entry in either file:
 
 ```json
 {
@@ -61,6 +61,8 @@ With options:
 }
 ```
 
+OpenCode 2.2.3 gives an `opencode.json` server plugin its options but drops them from the TUI entry it derives from the same listing. The server part therefore publishes its options over portable RPC, and the TUI asks for them at startup. If that bridge is unavailable (an older host, or a remote server that never registered it), `cli.json` remains the only source the TUI can read; **Fold diffs: diagnose** reports the effective option object either way. When both files set a key, `cli.json` wins.
+
 Restart OpenCode afterwards; plugins load at startup.
 
 ### From a local checkout
@@ -103,19 +105,19 @@ Clone this repository and point the plugin entry at the checkout. The package sh
 
 The V2 TUI plugin API (`@opencode/plugin/tui`) has no slot for message parts, so a plugin cannot render a tool block itself. It has to reach the renderables the host already made:
 
-1. **Find the transcript.** The scrollbox with `stickyScroll && stickyStart === "bottom"`. The sidebar, dialogs, autocomplete and diff viewer all have scrollboxes; none of them are sticky. The one other sticky scrollbox in V2 is the shell output viewer, which is a dialog and is skipped by its `shell-output-scroll` id.
-2. **Find the blocks.** A V2 `BlockTool` renders its header first as a row box whose first two children are the label text (`# Wrote`, `← Edit`, `← Patched`, `# Created`, `# Deleted`) and the path value. File blocks are matched on that label; a bash block carries no header, so it is found by shape — a child whose first grandchild is the `$ `-prefixed command.
-3. **Fold.** Set `visible = false` on the children carrying the bulk. That sets Yoga `display: none`, so the body leaves layout instead of leaving a hole. A zero `max-height` alone is not enough — the box collapses to zero rows but OpenTUI still paints the diff. A positive `lines` value keeps the first body visible and uses `maxHeight` for it instead. The block's own chrome (`gap`, `paddingTop`, `paddingBottom` of 1) is tightened to zero so a folded block occupies one row.
-4. **Toggle.** Assign `onMouseUp` on the block. The solid adapter sets that as a plain property, so a plugin can set it the same way — it replaces `BlockTool`'s own handler, which is why the copy-on-select guard is reimplemented here. For a bash block the host's handler is the output toggle and must be preserved, so the handler goes on the command text with `stopPropagation()` instead.
-5. **Restate the header.** The stats suffix is appended to the label text node, not the path. If solid will not let go of that node the plugin stops trying and folds without the suffix.
+1. **Find the transcript.** Candidates are every scrollbox with a bottom sticky start, excluding the shell output viewer, diff help and execute detail panels by id. They are scored, not taken first: a `session-part:` descendant is the strongest evidence, a `msg_` id is next, and scroll height breaks ties. A scrolled-up transcript that reports `stickyScroll=false` is still accepted when it has the bottom anchor plus session-part evidence. The cached transcript is dropped when its route/session changes or when it is detached from the renderer root.
+2. **Find the blocks.** A V2 `BlockTool` renders its header first as a row box whose first two children are the label text (`# Wrote`, `← Edit`, `← Patched`, `# Created`, `# Deleted`) and the path value. File blocks are matched on that label; a bash block carries no header, so it is found by shape — the command row's first text node is the `$ `-prefixed command. A running command (a spinner box before any text) is skipped and picked up by a later sweep; output that happens to begin with `$ ` is never mistaken for the command.
+3. **Fold.** Set `visible = false` on the children carrying the bulk. That sets Yoga `display: none`, so the body leaves layout instead of leaving a hole. A zero `max-height` alone is not enough — the box collapses to zero rows but OpenTUI still paints the diff. A positive `lines` value keeps the first body visible and uses `maxHeight` for it instead. The block's own chrome (`gap`, `paddingTop`, `paddingBottom`) is tightened to zero so a folded block occupies one row, and the values read from OpenTUI 0.8's `getGap`/`getPadding` getters are restored exactly when it unfolds. `maxHeight` is captured the same way; bash commands fall back to the host's two-row clamp when the getter is unavailable.
+4. **Toggle.** Assign `onMouseUp` on the block. The solid adapter sets that as a plain property, so a plugin can set it the same way — it replaces `BlockTool`'s own handler, which is why the copy-on-select guard is reimplemented here. For a bash block the host's handler is the output toggle and must be preserved, so the handler goes on the command text with `stopPropagation()` instead. The handler reference is stored and cleared on cleanup, and a `disposed` guard makes a late click a no-op.
+5. **Restate the header.** The stats suffix is appended to the label text node, not the path. If solid will not let go of that node the plugin stops trying; a block whose suffix was already applied still has it stripped on cleanup/unfold even after that global flag is off. Known blocks are re-summarised on each sweep, so a block whose streamed content grew gets fresh stats instead of keeping its first count.
 
-Renderable classes are matched by duck-typing (`typeof node.diff === "string"` for a diff, `typeof node.content === "string"` for a written file) rather than `instanceof`, because the opentui classes are minified in the shipped binary and their names are not stable. `filetype` is deliberately not required: it was dropped in 2.0.16 and restored in 2.0.27, and keying off it silently stopped write blocks from folding.
+Renderable classes are matched by duck-typing (`typeof node.diff === "string"` for a diff, a string `content` **plus** `getLineSources` for a written file) rather than `instanceof`, because the opentui classes are minified in the shipped binary and their names are not stable. The second half matters in OpenTUI 0.8: `MarkdownRenderable` also has a string `content`, and matching on content alone mistook markdown for a written file. `filetype` is deliberately not required: it was dropped in 2.0.16 and restored in 2.0.27, and keying off it silently stopped write blocks from folding.
 
-Blocks are re-scanned on V2's `session.message.content.updated`, `session.tool.success` and `session.tool.failed`, plus `session.step.ended` and `session.execution.succeeded` (`session.shell.ended` joins them when `bash` folding is on). A 2 s sweep catches a session opened from history, whose parts land before any event this plugin sees.
+Blocks are re-scanned on V2's `session.tool.called`, `session.tool.progress`, `session.tool.success` and `session.tool.failed`, plus `session.step.ended` and `session.execution.succeeded` (`session.shell.ended` joins them when `bash` folding is on). A 5 s fallback sweep catches a session opened from history, whose parts land before any event this plugin sees. The fallback is much slower than the old 2 s timer because it exists only for that initial batch; live updates are event-driven. `session.message.content.updated` is not in the public TUI event union used by the plugin API, so it is not subscribed to.
 
 ## Status
 
-Written against **opencode v2.0.24** and re-checked against **v2.0.27**; the `session.*` events it listens to exist from v2.0.10 on, so an older V2 install gets the fix without upgrading. The tree-walking, block matching, fold/unfold and toggle logic run green against a mock renderer tree shaped like V2's (`node --test`), and the fold was checked against a real transcript: `visible = false` (Yoga `display: none`) is what actually hides a body, not `maxHeight`.
+Written against **opencode v2.0.24**, re-checked against **v2.0.27** and **v2.2.0**, and API-checked against **v2.2.3** / OpenTUI 0.8.x; the `session.*` events it listens to exist from v2.0.10 on, so an older V2 install gets the fix without upgrading. The tree-walking, block matching, fold/unfold and toggle logic run green against a mock renderer tree shaped like V2's (`node --test`), and the fold was checked against a real transcript: `visible = false` (Yoga `display: none`) is what actually hides a body, not `maxHeight`.
 
 To confirm it loaded, restart (`opencode service restart`) and check `/plugins` lists `opencode-fold-diffs` and `Ctrl+P` → **Fold / unfold file diffs** is in the palette. If nothing folds, run **Fold diffs: diagnose** — the toast reports what the plugin can see:
 
@@ -125,6 +127,9 @@ To confirm it loaded, restart (`opencode service restart`) and check `/plugins`
 | `transcript: yes · blocks: 0` | The transcript was found but no file blocks matched — the host render tree differs from what this plugin expects. |
 | `transcript: yes · blocks: N · folded: N` | Detection and folding ran; if the blocks still look expanded, the fold did not take on the renderables. |
 | `stats: off` | Folding works but the header could not be restated (Solid owns the label node). |
+| `options: {...}` | The effective merged options. Compare this with the entry in `opencode.json`/`cli.json`; if it is empty and you configured options in a remote `cli.json`, the local TUI never saw them. |
+
+The diagnose dump includes up to 80 characters of text from each renderable, so it can contain prompts or tool output. Redact it before sharing; set `dump: false` to skip writing it.
 
 Edits with fewer than `min_lines` changed lines (default 6) are left expanded on purpose — a one-line change is already its own summary. Set `min_lines: 0` to fold every file block.
 
@@ -136,7 +141,7 @@ The port follows V2's new plugin API and render tree, so the V1 code could not b
 - `api.renderer` → `context.renderer`, `api.route.current.name` → `context.ui.router.current().type`, `api.event.on` → `context.data.on`, `api.ui.toast` → `context.ui.toast.show`, `api.keymap.registerLayer` → `context.keymap.layer` (called straight from `setup` on 2.0.23+, from an `app`-slot component before that).
 - Event names are V2's `session.*` events; `message.updated` / `message.part.updated` are legacy schemas that never fire.
 - Tool headers are a label node plus a path node, so detection and the stats suffix target the label.
-- `bash` defaults to `false` because V2 trims long commands itself, and config moves from `tui.json` to `cli.json`.
+- `bash` defaults to `false` because V2 trims long commands itself, and config moves from `tui.json` to `opencode.json` (bridged to the TUI by `rpc.js`) or `cli.json` for a remote TUI (which the TUI reads directly and which wins on conflicts).
 
 ## License
 

package/index.js

@@ -1,18 +1,49 @@
 // Server entrypoint for opencode-fold-diffs.
 //
-// All rendering happens in the CLI runtime (tui.js). This file only exists so a
-// local plugin directory is a complete plugin: OpenCode discovers a plugin
-// directory by its index (server) entry and loads the `tui` entry beside it, so
-// the plugin shows up by id instead of as an anonymous entry.
+// Rendering happens in the CLI runtime (tui.js). This file exists so a local
+// plugin directory is a complete plugin: OpenCode discovers a plugin directory
+// by its index (server) entry and loads the `tui` entry beside it, so the plugin
+// shows up by id instead of as an anonymous entry.
+//
+// It also bridges the options. A server plugin listed in opencode.json gets its
+// `options` object; the TUI entry OpenCode derives from the same listing does
+// not. Publishing them over RPC lets tui.js honour `folded`, `stats`, `key`,
+// `bash` and the rest even when the plugin was installed with
+// `opencode plugin add` instead of being configured in cli.json.
 //
 // `Plugin.define()` is an identity helper, so a plain { id, setup } object is
 // the same definition without a runtime dependency on @opencode/plugin.
 
+import { OPTIONS_RPC } from "./rpc.js";
+
 export const PLUGIN_ID = "opencode-fold-diffs";
 
 export default {
   id: PLUGIN_ID,
-  setup() {
-    // Intentional no-op: the transcript folding is registered by tui.js.
+  async setup(context) {
+    // Keep a copy: a host-side mutation of the context later must not change
+    // what an already-running TUI asked for.
+    const options =
+      context?.options && typeof context.options === "object" && !Array.isArray(context.options)
+        ? { ...context.options }
+        : {};
+    try {
+      const registration = await context?.rpc?.register?.(OPTIONS_RPC, {
+        // The RPC layer awaits every handler result, so a synchronous object
+        // fails with "t(...).then is not a function"; always return a promise.
+        async get() {
+          return { options };
+        },
+      });
+      return async () => {
+        try {
+          await registration?.dispose?.();
+        } catch {}
+      };
+    } catch {
+      // Older hosts have no portable RPC. The TUI then falls back to cli.json,
+      // which is the only path 2.2.3 supports natively.
+      return;
+    }
   },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cardinal4/opencode-fold-diffs",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "Unofficial OpenCode V2 fork of opencode-fold-diffs: write, edit and apply_patch blocks render folded to their header line, click to expand.",
   "license": "MIT",
   "type": "module",
@@ -24,6 +24,7 @@
   "files": [
     "index.js",
     "tui.js",
+    "rpc.js",
     "README.md",
     "LICENSE"
   ],
@@ -44,8 +45,5 @@
   },
   "publishConfig": {
     "access": "public"
-  },
-  "engines": {
-    "opencode": ">=2.0.0"
   }
 }

package/rpc.js

@@ -0,0 +1,20 @@
+// The one method the server part exposes to the TUI part.
+//
+// OpenCode 2.2.3 passes options to a TUI plugin only from cli.json. An
+// opencode.json server-plugin entry reaches the server context with its
+// options, but the matching TUI entry is reduced to the bare package name, so
+// the TUI never sees them. The server registers this method and the TUI asks
+// for the values before configuring itself; cli.json still wins on a conflict.
+//
+// The definition is deliberately dependency-free: portable RPC accepts JSON
+// Schema, so no @opencode/plugin or effect import is needed at runtime.
+export const OPTIONS_RPC = {
+  id: "opencode-fold-diffs.options",
+  methods: {
+    get: {
+      input: { type: "object" },
+      output: { type: "object" },
+    },
+  },
+  events: {},
+};

package/tui.js

@@ -13,7 +13,10 @@
 // expand  src/app.ts" -- and opens on click, or with the optional `key`
 // binding for every block at once.
 //
-// Options (cli.json -> { "package": "@cardinal4/opencode-fold-diffs", "options": { ... } }):
+// Options can live on the plugin entry in opencode.json or cli.json:
+//   { "package": "@cardinal4/opencode-fold-diffs", "options": { ... } }
+// opencode.json options reach the TUI through the server part's RPC bridge;
+// cli.json is the local TUI's own source and wins when both set a key.
 //   lines      lines of the body left visible when folded  (default 0, title only)
 //   min_lines  leave blocks with fewer content lines alone  (default 6)
 //   stats      append "40 lines · click to expand" to the header (default true)
@@ -30,6 +33,7 @@
 import { writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { OPTIONS_RPC } from "./rpc.js";
 
 const DEFAULTS = {
   lines: 0,
@@ -74,10 +78,29 @@ function baseLabel(text) {
 // "$ " in front of it.
 const PROMPT = "$ ";
 
-// How often to re-scan when nothing is streaming. Events cover the live case;
-// this catches a session opened from history, whose parts arrive as one batch
-// before any event this plugin sees.
-const SWEEP_MS = 2000;
+// Events cover the live case. The fallback catches a session opened from
+// history, whose parts arrive as one batch before any event this plugin sees;
+// it is deliberately slower than the old 2 s timer because that batch is the
+// only thing it is for.
+const SWEEP_MS = 5000;
+
+// Yoga enum values, so the 0.8 getters can be read without importing
+// @opentui/core (which the host bundles and minifies).
+const EDGE_TOP = 1;
+const EDGE_BOTTOM = 3;
+const GUTTER_ROW = 1;
+
+// Scrollboxes that belong to the host's panels and dialogs rather than to the
+// transcript. The shell viewer is the important one: since V2 it is also a
+// sticky scrollbox.
+const EXCLUDED_SCROLL_IDS = new Set([
+  "shell-output-scroll",
+  "diff-help-scroll",
+  "execute-detail-scroll",
+]);
+
+const MAX_ROWS = 10000;
+const BRIDGE_TIMEOUT_MS = 500;
 
 function children(node) {
   return typeof node?.getChildren === "function" ? node.getChildren() : [];
@@ -91,32 +114,76 @@ function plain(node) {
 // Duck-typing, not instanceof: the classes live in the host's bundled
 // @opentui/core and are minified, so their names are not stable. A diff
 // renderable is the only thing in the tree carrying a `diff` string. A code
-// renderable is the only thing whose `content` is a string -- text renderables
-// carry a styled-text `content` object and expose `plainText` instead. Never key
-// off `filetype`: OpenCode stopped setting it in 2.0.16 and restored it in
-// 2.0.27, and requiring it silently stopped every write block from folding.
+// renderable is a TextBufferRenderable: its `content` is a string AND it
+// exposes the line map. MarkdownRenderable also has a string `content`, so
+// checking the content alone made a markdown block look like a written file.
 function isDiff(node) {
   return typeof node?.diff === "string";
 }
 
 function isCode(node) {
-  return typeof node?.content === "string";
+  return typeof node?.content === "string" && typeof node?.getLineSources === "function";
+}
+
+// The text renderable's value is a styled-text object, not a string. Text is
+// the one primitive here that every host version has kept.
+function textValue(node) {
+  return typeof node?.content === "string" ? node.content : undefined;
+}
+
+// The stable identity of a message part, if the host published one. V2 sets
+// `session-part:<messageID>:<partID>` on the part container; older trees at
+// least carry a `msg_` id. Walking parents keeps this working when the block
+// renderable itself has no id.
+function stableKey(node) {
+  let current = node;
+  for (let i = 0; current && i < 200; i++) {
+    const id = typeof current.id === "string" ? current.id : "";
+    if (id.startsWith("session-part:") || id.startsWith("msg_")) return id;
+    current = current.parent;
+  }
+  return undefined;
+}
+
+// Rows a text content occupies. A lone "\n" is one empty line, not zero; a
+// single trailing newline is the terminator and does not add a second line.
+function contentLines(content) {
+  if (content === "") return 0;
+  const lines = content.split("\n");
+  if (lines.length && lines[lines.length - 1] === "") lines.pop();
+  return lines.length;
+}
+
+// A real unified-diff file header is the three-character marker followed by a
+// space and a path. Without the space requirement a content line whose text
+// starts "+++" was silently dropped from the stats.
+function isDiffHeader(line) {
+  if (!line.startsWith("+++ ") && !line.startsWith("--- ")) return false;
+  return line.slice(4).trim().length > 0;
 }
 
 // The command text of a bash block, or nothing. V2 wraps the command and its
-// output in one box, and the command is the first child of that box prefixed
-// with "$ ". While the tool is still running the host renders the command in a
-// row next to a spinner, so a running command is skipped and picked up by a
-// later sweep once it settles.
+// output in one box. The command is the first text-bearing child of that box;
+// only an empty <Show> placeholder may precede it.
+//
+// Scanning every grandchild for "$ " was wrong in two ways: while a command is
+// still running the host puts it in a row next to a spinner (no "$ " yet), and
+// its output may legitimately begin with "$ " -- which the old code then folded
+// instead of the command. A non-leaf before the text or an unprefixed first
+// text means this is a running/other block, not an adoptable shell block.
 function shellCommand(block) {
   for (const child of children(block)) {
     const inner = children(child);
-    if (!inner.length) continue;
-    // solid's <Show> leaves childless placeholders, so scan rather than assume
-    // the command is the first grandchild.
+    // command plus at least its output/hint sibling
+    if (inner.length < 2) continue;
     for (const node of inner) {
       const text = plain(node);
-      if (typeof text === "string" && text.startsWith(PROMPT)) return { node, text };
+      if (typeof text === "string") {
+        return text.startsWith(PROMPT) ? { node, text } : undefined;
+      }
+      // A spinner/command row is a box, not a leaf placeholder. Wait for a
+      // later sweep, once the command is rendered as text with its prompt.
+      if (children(node).length) return undefined;
     }
   }
   return;
@@ -124,10 +191,21 @@ function shellCommand(block) {
 
 // Rows the command occupies, not lines it contains: a single-line command long
 // enough to wrap is exactly the kind worth folding. `height` is the laid-out
-// row count and reads 0 before the first layout, so the line count is the floor.
+// row count, but the host already clamps it to two, so it can never prove a
+// long command is long. The intrinsic height comes from the text width instead.
 function commandRows(node, text) {
-  const height = typeof node?.height === "number" ? node.height : 0;
-  return Math.max(text.split("\n").length, height);
+  const lines = text.split("\n");
+  let rows = lines.length;
+  const width =
+    typeof node?.width === "number" && Number.isFinite(node.width) ? Math.trunc(node.width) : 0;
+  if (width > 0 && node?.wrapMode !== "none") {
+    let wrapped = 0;
+    for (const line of lines) wrapped += Math.max(1, Math.ceil(line.length / width));
+    rows = Math.max(rows, wrapped);
+  }
+  const height =
+    typeof node?.height === "number" && Number.isFinite(node.height) ? node.height : 0;
+  return Math.max(rows, height);
 }
 
 function bulk(node, found = []) {
@@ -140,31 +218,67 @@ function bulk(node, found = []) {
   return found;
 }
 
-// The session transcript is the scrollbox that sticks to the bottom. Since V2
-// the shell output viewer is also a sticky scrollbox, but it is a dialog and
-// must never be mistaken for the transcript, so it is excluded by id. Staying
-// inside the transcript is what keeps the permission dialog's diff preview
-// untouched -- you should always see in full what you are about to approve.
-const SHELL_VIEWER_ID = "shell-output-scroll";
-
-function isTranscript(node) {
-  return (
-    typeof node?.scrollTo === "function" &&
-    typeof node?.scrollHeight === "number" &&
-    node.stickyScroll === true &&
-    node.stickyStart === "bottom" &&
-    node.id !== SHELL_VIEWER_ID
-  );
+// The session transcript is a scrollbox that sticks to the bottom. It is not
+// the only one: the shell output viewer, the diff help panel and the execute
+// detail panel are scrollboxes too. They are excluded by id, and the remaining
+// candidates are scored by session-part descendants and scroll height rather
+// than taking the first match.
+function isScrollbox(node) {
+  try {
+    return typeof node?.scrollTo === "function" && typeof node?.scrollHeight === "number";
+  } catch {
+    return false;
+  }
 }
 
-function findTranscript(node) {
-  if (!node || node.isDestroyed) return;
-  if (isTranscript(node)) return node;
-  if (typeof node.scrollTo === "function") return;
-  for (const child of children(node)) {
-    const hit = findTranscript(child);
-    if (hit) return hit;
+function excludedScrollbox(node) {
+  const id = typeof node?.id === "string" ? node.id : "";
+  if (!id) return false;
+  if (EXCLUDED_SCROLL_IDS.has(id)) return true;
+  return /(?:^|[-_])(dialog|panel|popup|viewer)(?:$|[-_])/.test(id);
+}
+
+// Bit flags: 1 = a session-part id, 2 = a message id. Collected bottom-up in
+// one walk so each scrollbox only sees evidence inside its own subtree.
+function collectScrollboxes(node, found, depth = 0) {
+  if (!node || node.isDestroyed || depth > 1000) return 0;
+  const id = typeof node.id === "string" ? node.id : "";
+  let flags = id.startsWith("session-part:") ? 1 : id.startsWith("msg_") ? 2 : 0;
+  for (const child of children(node)) flags |= collectScrollboxes(child, found, depth + 1);
+  if (isScrollbox(node) && !excludedScrollbox(node)) found.push({ node, flags });
+  return flags;
+}
+
+function transcriptScore(node, flags) {
+  const sticky = node.stickyScroll === true;
+  const bottom = node.stickyStart === "bottom";
+  // Scrolled up, the host can report stickyScroll=false; a bottom anchor plus
+  // session-part evidence is still enough to identify the transcript.
+  if (!sticky && !(bottom && flags)) return -Infinity;
+  let score = 0;
+  if (flags & 1) score += 1000;
+  if (flags & 2) score += 600;
+  if (sticky) score += 50;
+  if (bottom) score += 50;
+  if (typeof node.scrollHeight === "number" && Number.isFinite(node.scrollHeight)) {
+    score += Math.min(100, Math.max(0, Math.log2(node.scrollHeight + 1) * 4));
+  }
+  return score;
+}
+
+function findTranscript(root) {
+  const found = [];
+  collectScrollboxes(root, found);
+  let best;
+  let bestScore = -Infinity;
+  for (const candidate of found) {
+    const score = transcriptScore(candidate.node, candidate.flags);
+    if (score > bestScore) {
+      best = candidate.node;
+      bestScore = score;
+    }
   }
+  return best;
 }
 
 // A V2 BlockTool renders the header first: a row box whose first two children
@@ -212,21 +326,127 @@ function summarise(nodes) {
   let lines = 0;
   let diffs = 0;
   for (const node of nodes) {
+    if (!node || node.isDestroyed) continue;
     if (isDiff(node)) {
       diffs++;
-      for (const line of node.diff.split("\n")) {
-        if (line.startsWith("+++") || line.startsWith("---")) continue;
+      const lines = node.diff.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // A file header is the marker plus a path, and the --- / +++ pair is
+        // what distinguishes it from a content line that merely starts with
+        // the same characters.
+        if (isDiffHeader(line)) {
+          const previous = lines[i - 1];
+          const next = lines[i + 1];
+          if (line.startsWith("--- ") && next && isDiffHeader(next) && next.startsWith("+++ ")) {
+            continue;
+          }
+          if (
+            line.startsWith("+++ ") &&
+            previous &&
+            isDiffHeader(previous) &&
+            previous.startsWith("--- ")
+          ) {
+            continue;
+          }
+        }
         if (line.startsWith("+")) added++;
         else if (line.startsWith("-")) removed++;
       }
       continue;
     }
-    lines += node.content.split("\n").length;
+    lines += contentLines(textValue(node) ?? "");
   }
   if (diffs) return { size: added + removed, label: `+${added} −${removed}` };
   return { size: lines, label: `${lines} ${lines === 1 ? "line" : "lines"}` };
 }
 
+// --- host style ----------------------------------------------------------
+//
+// Setter-only props in 0.5 became getters in OpenTUI 0.8. Capture what the host
+// actually set instead of assuming BlockTool's values, then put it back when a
+// block unfolds or the plugin is disabled.
+
+function readStyle(node, getter, args, property, fallback) {
+  try {
+    if (typeof node?.[getter] === "function") {
+      const value = node[getter](...args);
+      if (value !== undefined) return value;
+    }
+  } catch {}
+  try {
+    const value = node?.[property];
+    if (value !== undefined) return value;
+  } catch {}
+  return fallback;
+}
+
+function maxHeightOf(node, fallback) {
+  const value = readStyle(node, "getMaxHeight", [], "maxHeight", fallback);
+  // "auto" is the unset value in Yoga. For a shell command the host's real
+  // clamp (two rows) is the better restore point than an explicit auto.
+  return value === "auto" ? fallback : value;
+}
+
+function chromeOf(node) {
+  return {
+    gap: readStyle(node, "getGap", [GUTTER_ROW], "gap", 1),
+    paddingTop: readStyle(node, "getPadding", [EDGE_TOP], "paddingTop", 1),
+    paddingBottom: readStyle(node, "getPadding", [EDGE_BOTTOM], "paddingBottom", 1),
+  };
+}
+
+// --- options -------------------------------------------------------------
+
+function plainOptions(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
+function integerOption(value, fallback) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return fallback;
+  return Math.min(MAX_ROWS, Math.max(0, Math.trunc(number)));
+}
+
+function describeOptions(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "?";
+  }
+}
+
+function withTimeout(promise, ms) {
+  return new Promise((resolve) => {
+    let done = false;
+    let timer;
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    timer = setTimeout(() => finish(undefined), ms);
+    Promise.resolve(promise).then(finish, () => finish(undefined));
+  });
+}
+
+// Best-effort: the server part answers with the options OpenCode gave it from
+// opencode.json. A missing/older server or a host without portable RPC just
+// leaves the cli.json values (possibly none) in place.
+async function bridgeOptions(context) {
+  try {
+    if (typeof context?.client?.rpc !== "function") return {};
+    const client = context.client.rpc(OPTIONS_RPC);
+    if (typeof client?.get !== "function") return {};
+    const result = await withTimeout(client.get({}), BRIDGE_TIMEOUT_MS);
+    const options = plainOptions(result?.options);
+    return options;
+  } catch {
+    return {};
+  }
+}
+
 // Debug-only: one line per renderable, for aligning the matcher with a real
 // transcript when a live run reports `blocks: 0`. Truncated so a big session
 // still writes quickly.
@@ -261,31 +481,100 @@ export const PLUGIN_ID = "opencode-fold-diffs";
 
 export default {
   id: PLUGIN_ID,
-  setup(context) {
-    const opts = { ...DEFAULTS, ...(context.options ?? {}) };
-    const peek = Math.max(0, Number(opts.lines) || 0);
-    const floor = Math.max(0, Number(opts.min_lines) || 0);
+  async setup(context) {
+    const cliOptions = plainOptions(context.options);
+    const serverOptions = await bridgeOptions(context);
+    // cli.json is the local TUI's own configuration and wins on a conflict;
+    // opencode.json supplies everything it does not set.
+    const opts = { ...DEFAULTS, ...serverOptions, ...cliOptions };
+    const peek = integerOption(opts.lines, DEFAULTS.lines);
+    const floor = integerOption(opts.min_lines, DEFAULTS.min_lines);
     const shell = opts.bash === true;
-    const shellPeek = Math.max(0, Number(opts.bash_lines) || 0);
+    const shellPeek = integerOption(opts.bash_lines, DEFAULTS.bash_lines);
+    const key = typeof opts.key === "string" ? opts.key : "";
 
-    // Folded blocks, by their block renderable. WeakMap so a session switch,
-    // which destroys the renderables, drops the state with them.
+    // Folded state by stable part id, so a block that is remounted keeps the
+    // mode it was toggled to. WeakMap state below is per-renderable and dies
+    // with the renderable; this Map is the part's memory.
+    const foldedByKey = new Map();
     const known = new WeakMap();
+    // WeakMap has no iterator, so keep a strong set of adopted blocks only for
+    // cleanup. Destroyed blocks are pruned on the sweep to avoid retaining a
+    // closed session's renderables.
+    const adopted = new Set();
     // The mode new blocks adopt. ctrl+o flips it, so "expand everything" also
     // means "and stop folding what arrives next", the way a verbose toggle works.
     let folding = opts.folded !== false;
     // Set once the header rewrite is proven not to take, so we stop retrying it.
     let titles = opts.stats !== false;
+    let disposed = false;
 
     let cached;
+    let routed;
+
+    function currentRoute() {
+      try {
+        return context.ui.router.current();
+      } catch {
+        return undefined;
+      }
+    }
+
+    // Route/session changes destroy or replace the transcript and invalidate
+    // per-session fold memory. Detecting it here also makes the cache safe to
+    // keep between the (now much slower) fallback sweeps.
+    function refreshRoute() {
+      const route = currentRoute();
+      const token =
+        route?.type === "session" ? `session:${route.sessionID ?? ""}` : String(route?.type ?? "");
+      if (token !== routed) {
+        routed = token;
+        cached = undefined;
+        foldedByKey.clear();
+      }
+      return token;
+    }
+
+    function attached(node) {
+      const root = context.renderer.root;
+      let current = node;
+      for (let i = 0; current && i < 2000; i++) {
+        if (current === root) return true;
+        current = current.parent;
+      }
+      return false;
+    }
+
     function transcript() {
-      if (cached && !cached.isDestroyed) return cached;
+      refreshRoute();
+      if (cached && !cached.isDestroyed && attached(cached)) return cached;
       cached = findTranscript(context.renderer.root);
       return cached;
     }
 
+    function setTitle(state, fold) {
+      if (!state.title) return;
+      const next = fold && titles ? `${state.text} ${state.suffix}` : state.text;
+      if (plain(state.title) === next) {
+        state.titleChanged = fold && titles;
+        return;
+      }
+      try {
+        state.title.content = next;
+      } catch {
+        titles = false;
+        return;
+      }
+      const applied = plain(state.title);
+      if (fold && titles) {
+        if (applied === next) state.titleChanged = true;
+        else titles = false;
+      } else {
+        state.titleChanged = applied !== state.text;
+      }
+    }
+
     function apply(state, fold) {
-      state.folded = fold;
       state.body.forEach((node, index) => {
         try {
           // `visible = false` sets Yoga display:none, which removes the body
@@ -293,36 +582,53 @@ export default {
           // clamped the box to zero rows but OpenTUI still painted the diff.
           // A positive `lines` peek keeps the first body visible instead.
           const peekRow = fold && index === 0 && state.peek > 0;
-          node.visible = !fold || peekRow;
-          node.maxHeight = peekRow ? state.peek : undefined;
+          node.visible = fold ? peekRow : (state.visible[index] ?? true);
+          node.maxHeight = peekRow ? state.peek : state.maxHeight[index];
           node.overflow = fold ? "hidden" : state.overflow[index];
         } catch {}
       });
-      // With the body at zero height, the block's own padding and the gap it
+      // With the body at zero height the block's own padding and the gap it
       // keeps between children are all that is left. Collapse the chrome too so
-      // a folded block reads as the single row it now is. The restored values
-      // are BlockTool's own (paddingTop/Bottom 1, gap 1) because opentui gives
-      // these setters no getters to read the originals back from. Never for a
+      // a folded block reads as the single row it now is, restoring exactly the
+      // values the host had rather than BlockTool's assumed 1/1/1. Never for a
       // shell block: its output is a sibling of the command and stays on screen,
       // so the chrome is still holding something up.
       if (state.chrome) {
         try {
-          state.block.gap = fold ? 0 : 1;
-          state.block.paddingTop = fold ? 0 : 1;
-          state.block.paddingBottom = fold ? 0 : 1;
+          state.block.gap = fold ? 0 : state.chromeStyle.gap;
+          state.block.paddingTop = fold ? 0 : state.chromeStyle.paddingTop;
+          state.block.paddingBottom = fold ? 0 : state.chromeStyle.paddingBottom;
         } catch {}
       }
-      if (!titles || !state.title) return;
-      const next = fold ? `${state.text} ${state.suffix}` : state.text;
+      // Restore the label even after `titles` was turned off globally: a block
+      // whose suffix was applied before the failure must not keep it.
+      setTitle(state, fold);
+    }
+
+    function setFolded(state, fold) {
+      state.folded = fold;
+      if (state.key) foldedByKey.set(state.key, fold);
+      apply(state, fold);
+    }
+
+    function selection() {
       try {
-        state.title.content = next;
+        return context.renderer.getSelection?.()?.getSelectedText?.();
       } catch {
-        titles = false;
-        return;
+        return undefined;
       }
-      // The host owns that text node. If solid is not letting go of it there is
-      // nothing to be gained by asking again on every block.
-      if (plain(state.title) !== next) titles = false;
+    }
+
+    function installHandler(state, target, stop) {
+      state.handlerTarget = target;
+      state.handler = (event) => {
+        if (disposed || state.block.isDestroyed) return;
+        // Copy-on-select is a drag ending on the block; that is not a click.
+        if (selection()) return;
+        setFolded(state, !state.folded);
+        if (stop) event?.stopPropagation?.();
+      };
+      target.onMouseUp = state.handler;
     }
 
     function adoptDiff(block) {
@@ -347,41 +653,61 @@ export default {
       const state = {
         block,
         body,
+        visible: body.map((node) => node.visible),
+        maxHeight: body.map((node) => maxHeightOf(node, undefined)),
         overflow: body.map((node) => node.overflow),
         title: header.node,
         text: header.label,
         suffix: `${stats.label} · click to expand`,
+        signature: `${stats.size}|${stats.label}`,
         peek,
         chrome: peek === 0,
+        chromeStyle: chromeOf(block),
         folded: false,
+        titleChanged: false,
+        key: stableKey(block),
+        kind: "diff",
       };
+      const remembered = state.key === undefined ? undefined : foldedByKey.get(state.key);
+      state.folded = remembered === undefined ? folding : remembered;
+      if (state.key !== undefined) foldedByKey.set(state.key, state.folded);
       known.set(block, state);
-
-      block.onMouseUp = () => {
-        // Copy-on-select is a drag ending on the block; that is not a click.
-        if (context.renderer.getSelection?.()?.getSelectedText?.()) return;
-        apply(state, !state.folded);
-      };
-
-      if (folding) apply(state, true);
+      adopted.add(block);
+      installHandler(state, block, false);
+      apply(state, state.folded);
       return true;
     }
 
     function adoptShell(block) {
       const found = shellCommand(block);
-      if (!found) return;
-      if (commandRows(found.node, found.text) < floor) return;
+      if (!found) return false;
+      if (commandRows(found.node, found.text) < floor) return false;
 
       const state = {
         block,
         body: [found.node],
+        visible: [found.node.visible],
+        // The host clamps a running/long command to two rows. If the getter is
+        // unavailable, two is still a better restore point than undefined.
+        maxHeight: [maxHeightOf(found.node, 2)],
         overflow: [found.node.overflow],
         title: undefined,
+        text: "",
+        suffix: "",
+        signature: "",
         peek: shellPeek,
         chrome: false,
+        chromeStyle: undefined,
         folded: false,
+        titleChanged: false,
+        key: stableKey(block),
+        kind: "shell",
       };
+      const remembered = state.key === undefined ? undefined : foldedByKey.get(state.key);
+      state.folded = remembered === undefined ? folding : remembered;
+      if (state.key !== undefined) foldedByKey.set(state.key, state.folded);
       known.set(block, state);
+      adopted.add(block);
 
       // The block's own onMouseUp belongs to the host here -- it is what expands
       // the collapsed command/output -- and opentui declares the handler as a
@@ -389,22 +715,44 @@ export default {
       // command text instead and stop the event on it: clicking the command
       // folds the command, clicking anywhere else in the block still does
       // exactly what it did before this plugin loaded.
-      found.node.onMouseUp = (event) => {
-        if (context.renderer.getSelection?.()?.getSelectedText?.()) return;
-        apply(state, !state.folded);
-        event?.stopPropagation?.();
-      };
-
-      if (folding) apply(state, true);
+      installHandler(state, found.node, true);
+      apply(state, state.folded);
+      return true;
     }
 
     function adopt(block) {
-      if (adoptDiff(block)) return;
-      if (shell) adoptShell(block);
+      if (adoptDiff(block)) return true;
+      if (shell) return adoptShell(block);
+      return false;
+    }
+
+    // Recompute a folded block's stats without dropping its adoption. A tool
+    // that streams more content into the same renderables used to keep the
+    // first summary forever because the sweep skipped every known block.
+    function refreshStats(state) {
+      if (state.kind !== "diff") return;
+      const heavy = [];
+      for (const child of state.body) bulk(child, heavy);
+      if (!heavy.length) return;
+      const stats = summarise(heavy);
+      const signature = `${stats.size}|${stats.label}`;
+      if (signature === state.signature) return;
+      state.signature = signature;
+      state.suffix = `${stats.label} · click to expand`;
+      if (state.folded) setTitle(state, true);
     }
 
     function sweep() {
-      if (context.ui.router.current().type !== "session") return;
+      if (disposed) return;
+      for (const block of adopted) {
+        if (block.isDestroyed) {
+          adopted.delete(block);
+          continue;
+        }
+        const state = known.get(block);
+        if (state) refreshStats(state);
+      }
+      if (!refreshRoute().startsWith("session:")) return;
       const box = transcript();
       if (!box) return;
       for (const block of scan(box, [], shell)) {
@@ -421,7 +769,7 @@ export default {
       for (const block of scan(box, [], shell)) {
         const state = known.get(block);
         if (!state || state.folded === fold) continue;
-        apply(state, fold);
+        setFolded(state, fold);
         count++;
       }
       return count;
@@ -429,7 +777,7 @@ export default {
 
     let pending;
     function schedule() {
-      if (pending) return;
+      if (disposed || pending) return;
       pending = setTimeout(() => {
         pending = undefined;
         sweep();
@@ -437,17 +785,28 @@ export default {
     }
 
     // V1's message.part.updated / message.updated are legacy schemas in V2 --
-    // the client emits the session.* events instead, so the V1 names were a
-    // silent no-op and a new block only folded on the sweeping timer.
+    // the client emits the session.* events instead. `session.message.content.
+    // updated` is not exposed by the public TUI event union, so the tool events
+    // (plus the step and execution endings) are the ones this plugin can rely
+    // on; the slow fallback sweep covers anything else.
     const events = [
-      "session.message.content.updated", // a part was appended or replaced
-      "session.tool.success", // a tool body (diff or file) appeared
+      "session.tool.called", // a tool block was added to the transcript
+      "session.tool.progress", // its body may have grown or changed
+      "session.tool.success", // a tool body (diff or file) is final
       "session.tool.failed", // a failed tool still renders its block
       "session.step.ended", // the step's final content has arrived
       "session.execution.succeeded", // the turn settled; take a final look
     ];
     if (shell) events.push("session.shell.ended"); // the command now carries its "$ " prefix
-    const offs = events.map((name) => context.data.on(name, schedule));
+    // An older host may not know every event name; a missing subscription must
+    // not take the whole plugin down.
+    const offs = events.map((name) => {
+      try {
+        return context.data.on(name, schedule);
+      } catch {
+        return undefined;
+      }
+    });
     const timer = setInterval(sweep, SWEEP_MS);
     schedule();
 
@@ -465,8 +824,9 @@ export default {
             title: "Fold / unfold file diffs",
             group: "Plugin",
             palette: true,
-            bind: opts.key || false,
+            bind: key || false,
             run() {
+              if (disposed) return;
               sweep();
               const fold = !folding;
               const changed = all(fold);
@@ -487,13 +847,16 @@ export default {
             group: "Plugin",
             palette: true,
             run() {
-              const box = transcript();
+              if (disposed) return;
+              const inSession = refreshRoute().startsWith("session:");
+              const box = inSession ? transcript() : undefined;
               const blocks = box ? scan(box, [], shell) : [];
               const folded = blocks.filter((block) => known.get(block)?.folded).length;
+              const options = describeOptions(opts);
               let dump;
               try {
                 const summary = [
-                  `transcript=${Boolean(box)} blocks=${blocks.length} folded=${folded} stats=${titles ? "on" : "off"}`,
+                  `transcript=${Boolean(box)} blocks=${blocks.length} folded=${folded} stats=${titles ? "on" : "off"} options=${options}`,
                 ];
                 for (const block of blocks) {
                   const state = known.get(block);
@@ -515,8 +878,10 @@ export default {
                 if (target) {
                   const lines = [];
                   dumpNode(box ?? context.renderer.root, 0, lines, 600);
-                  dump = target;
                   writeFileSync(target, summary.concat("", lines).join("\n"));
+                  // Only advertise the path once the write succeeded; the
+                  // catch below keeps a failed write from taking down diagnose.
+                  dump = target;
                 }
               } catch {}
               context.ui.toast.show({
@@ -524,32 +889,58 @@ export default {
                 variant: box ? "info" : "warning",
                 duration: 5000,
                 message: box
-                  ? `transcript: yes · blocks: ${blocks.length} · folded: ${folded} · stats: ${titles ? "on" : "off"}` +
+                  ? `transcript: yes · blocks: ${blocks.length} · folded: ${folded} · stats: ${titles ? "on" : "off"} · options: ${options}` +
                     (dump ? ` · dump: ${dump}` : "")
-                  : "transcript: not found — open a session first",
+                  : `transcript: not found — open a session first · options: ${options}`,
               });
             },
           },
         ],
-        bindings: opts.key ? ["opencode-fold-diffs.toggle"] : [],
+        bindings: key ? ["opencode-fold-diffs.toggle"] : [],
       }));
     }
     let stopCommands = () => {};
+    const registerCommandsSafely = () => {
+      try {
+        registerCommands();
+      } catch {}
+    };
     if (supportsSetupKeymap(context.app?.version)) {
-      registerCommands();
+      registerCommandsSafely();
     } else {
       function FoldCommands() {
-        registerCommands();
+        registerCommandsSafely();
         return null;
       }
-      stopCommands = context.ui.slot({ append: "app", render: () => FoldCommands() });
+      try {
+        stopCommands = context.ui.slot({ append: "app", render: () => FoldCommands() });
+      } catch {}
     }
 
     return () => {
-      stopCommands();
+      if (disposed) return;
+      disposed = true;
+      if (typeof stopCommands === "function") stopCommands();
       clearInterval(timer);
-      if (pending) clearTimeout(pending);
+      if (pending) {
+        clearTimeout(pending);
+        pending = undefined;
+      }
       for (const off of offs) if (typeof off === "function") off();
+      // The host owns these renderables and keeps them after the plugin is
+      // disabled, so undo our folds and remove our handlers instead of leaving
+      // the transcript collapsed or a late click able to re-fold it.
+      for (const block of adopted) {
+        const state = known.get(block);
+        if (!state) continue;
+        try {
+          if (state.handlerTarget) state.handlerTarget.onMouseUp = undefined;
+        } catch {}
+        if (state.folded || state.titleChanged) apply(state, false);
+      }
+      adopted.clear();
+      foldedByKey.clear();
+      cached = undefined;
     };
   },
 };