@cardinal4/opencode-fold-diffs 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tanman24
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,155 @@
+# opencode-fold-diffs
+
+**Every `write` and `edit` 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.
+
+This branch targets **OpenCode V2** (the `@opencode/cli` 2.x line, `opencode v2.0.x`). The V1 plugin implementation does not run in V2; see [Migrating from V1](#migrating-from-v1).
+
+## What V2 already folds
+
+V2 tightened the transcript on its own, and this plugin deliberately leaves those parts alone:
+
+- `read` / `glob` / `grep` calls fold into a one-line exploration group (`Explored — 3 reads, 2 searches`), click to expand.
+- A bash **command** is trimmed to two lines and its **output** to ten, both click to expand.
+
+The tools V2 still renders in full are exactly the ones that fill the scrollback: `write`, `edit`, `apply_patch`. Upstream has been asked three times — [#9089](https://github.com/anomalyco/opencode/issues/9089) (minimal diff display), [#14511](https://github.com/anomalyco/opencode/issues/14511) (a toggle keybind, like Claude Code's `ctrl+o`), [#19074](https://github.com/anomalyco/opencode/issues/19074) (collapse tool output) — and all three were closed without a setting. This is that setting, from outside.
+
+## What you see
+
+Before:
+
+```
+← Edit src/session/index.ts
+│  1  import { createMemo } from "solid-js"
+│  2 -  const [expanded, setExpanded] = createSignal(false)
+│  3 +  const [expanded, setExpanded] = createSignal(props.open)
+│  … 40 more lines
+```
+
+After:
+
+```
+← Edit +12 −3 · click to expand  src/session/index.ts
+```
+
+Click the row to open it. If you set the `key` option, that binding folds or unfolds every block in the session and sets what newly arriving blocks do — same as a verbose toggle. By default there is no binding, so OpenCode's own shortcuts (including `ctrl+o`) are left alone.
+
+## Install
+
+```sh
+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`):
+
+```json
+{
+  "$schema": "https://opencode.ai/v2/cli.json",
+  "plugins": ["@cardinal4/opencode-fold-diffs"]
+}
+```
+
+This package is TUI-only (it has no server entrypoint), so configure it in `cli.json`. CLI-only plugins also stay active when the terminal connects to a remote server.
+
+With options:
+
+```json
+{
+  "plugins": [
+    {
+      "package": "@cardinal4/opencode-fold-diffs",
+      "options": {
+        "lines": 3,
+        "min_lines": 10,
+        "key": "ctrl+f"
+      }
+    }
+  ]
+}
+```
+
+Restart OpenCode afterwards; plugins load at startup.
+
+### From a local checkout
+
+Clone this repository and point the plugin entry at the checkout. The package ships a server entry (`index.js`) and a TUI entry (`tui.js`); OpenCode discovers a plugin directory by its server entry and loads the `tui` entry beside it, so the plugin shows up by id instead of as an anonymous entry.
+
+```json
+{
+  "plugins": ["/home/me/projects_l/opencode-fold-diffs"]
+}
+```
+
+## Options
+
+```json
+"plugins": [["@cardinal4/opencode-fold-diffs", { "lines": 3, "min_lines": 10, "key": "ctrl+f" }]]
+```
+
+| Option | Default | Meaning |
+|---|---|---|
+| `lines` | `0` | Lines of the body left showing when folded. `0` is the header only, and also tightens the block's padding so it occupies one row. Any positive number leaves a peek at the top. |
+| `min_lines` | `6` | Blocks with fewer changed lines than this are left alone — a two-line edit is already its own summary. |
+| `stats` | `true` | Append `+12 −3 · click to expand` to the header. |
+| `folded` | `true` | Whether blocks start folded. `false` gives you only the toggle. |
+| `key` | `""` | Optional binding for fold/unfold-all. Empty by default so no OpenCode shortcut is overridden; set e.g. `"ctrl+shift+d"` to opt in. |
+| `bash` | `false` | Fold long bash commands too. Off by default on V2 because the host already trims them to two lines. |
+| `bash_lines` | `1` | Rows of the command left showing when folded. `1` keeps the line that says what the thing was. |
+| `dump` | `""` | Where **Fold diffs: diagnose** writes its tree dump. `""` means `/tmp/opencode-fold-diffs-tree.txt`; `false` disables the dump. |
+
+> `ctrl+o` belongs to OpenCode's **Open recent sessions and projects** (`open.menu`), so this plugin does not bind it. Choose an unused key for the `key` option.
+
+## What it does not touch
+
+- **Permission dialogs.** The diff you approve renders in full, always. The plugin only ever walks inside the transcript scrollbox, and the permission preview is not in it.
+- **Diagnostics and errors.** Only the children carrying a diff or a file body get folded, so an edit that introduced a type error still says so with the block closed.
+- **Bash output, and the click that expands it.** Only the *command* is ever folded, and only when `bash` is enabled; the output keeps the host's ten-line collapse. The block's own click handler belongs to the host, so the plugin attaches to the command text instead and calls `stopPropagation()`: clicking the command folds the command, clicking anywhere else in the block does exactly what it did before.
+- **Todos, questions, and the generic fallback.** They keep the host's own collapse behaviour.
+
+## How it works, for anyone extending it
+
+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 only scrollbox in the tree with `stickyScroll && stickyStart === "bottom"`. The sidebar, dialogs, autocomplete and diff viewer all have scrollboxes; none of them are sticky.
+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.
+
+Renderable classes are matched by duck-typing (`typeof node.diff === "string"`, `content` + `filetype` for code) rather than `instanceof`, because the opentui classes are minified in the shipped binary and their names are not stable.
+
+Blocks are re-scanned on `message.part.updated` and `message.updated`, plus a 2 s sweep that catches a session opened from history, whose parts land before any event this plugin sees.
+
+## Migrating from V1
+
+V1 plugin implementations do not run in V2. This branch made these changes:
+
+- Entrypoint is a `{ id, setup(context) }` definition (`Plugin.define()` is an identity helper, so the shape is the same). `setup` returns the cleanup function instead of `api.lifecycle.onDispose`.
+- `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`.
+- Tool headers are no longer one string. V1 rendered `"← Edit src/app.ts"`; V2 renders a label node plus a path node, so detection and the stats suffix target the label.
+- `bash` defaults to `false`, because V2 now trims long commands to two lines itself.
+- Config moves from `tui.json` to `cli.json` (or `opencode.json(c)`).
+
+## Testing
+
+1. Restart so the plugin loads: `opencode service restart`, then relaunch the TUI.
+2. Confirm it loaded: `/plugins` should list `opencode-fold-diffs` by id, and `Ctrl+P` → **Fold / unfold file diffs** should be in the palette.
+3. Ask the agent for a small edit. The block should render as a single header row, `← Edit +2 −1 · click to expand  path`. Click it to open, click again to close.
+4. If you configured a `key`, press it to fold or unfold every block in the session. Otherwise use the palette command **Fold / unfold file diffs**.
+5. If nothing folds, run `Ctrl+P` → **Fold diffs: diagnose**. The toast reports what the plugin can see:
+
+| Result | Meaning |
+|---|---|
+| `transcript: not found` | No session view is open, so there is nothing to fold. |
+| `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). |
+
+## Status
+
+Written against **opencode v2.0.10 / v2.0.11**. 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`.
+
+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.
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,18 @@
+// 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.
+//
+// `Plugin.define()` is an identity helper, so a plain { id, setup } object is
+// the same definition without a runtime dependency on @opencode/plugin.
+
+export const PLUGIN_ID = "opencode-fold-diffs";
+
+export default {
+  id: PLUGIN_ID,
+  setup() {
+    // Intentional no-op: the transcript folding is registered by tui.js.
+  },
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@cardinal4/opencode-fold-diffs",
+  "version": "0.3.0",
+  "description": "OpenCode V2 TUI plugin: write, edit and apply_patch blocks render folded to their header line, click or ctrl+o to open them.",
+  "license": "MIT",
+  "type": "module",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "opencode-tui",
+    "tui",
+    "diff",
+    "collapse",
+    "fold",
+    "transcript",
+    "scrollback"
+  ],
+  "main": "./index.js",
+  "exports": {
+    ".": "./index.js",
+    "./server": "./index.js",
+    "./tui": "./tui.js"
+  },
+  "files": [
+    "index.js",
+    "tui.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "author": {
+    "name": "Tanner Bruhn",
+    "url": "https://github.com/tannerbruhn"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cardin/opencode-fold-diffs.git"
+  },
+  "homepage": "https://github.com/cardin/opencode-fold-diffs#readme",
+  "bugs": {
+    "url": "https://github.com/cardin/opencode-fold-diffs/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "opencode": ">=2.0.0"
+  }
+}

package/tui.js

@@ -0,0 +1,519 @@
+// Fold write / edit / apply_patch blocks -- and, optionally, long bash commands
+// -- in the OpenCode V2 transcript.
+//
+// opencode already collapses bash OUTPUT to ten lines and (since V2) also trims
+// a long bash COMMAND to two, both with click-to-expand. The file tools that
+// produce the most scrollback -- write, edit and apply_patch -- are the ones it
+// does not touch: they render the whole diff, or the whole written file,
+// forever. The three upstream requests for a setting (#9089 minimal diff
+// display, #14511 a toggle keybind, #19074 collapse tool output) were all
+// closed without one, so this does it from a plugin.
+//
+// A folded block renders as its header line -- "# Wrote 40 lines · click to
+// expand  src/app.ts" -- and opens on click, or with ctrl+o for every block at
+// once.
+//
+// Options (cli.json -> ["opencode-fold-diffs", { ... }] or opencode.json(c)):
+//   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)
+//   folded     new blocks start folded                      (default true)
+//   key        binding that folds/unfolds every block        (default "ctrl+o")
+//   bash       fold long bash commands too                   (default false on V2)
+//   bash_lines rows of the command left visible when folded  (default 1)
+//
+// The plugin is loaded by the OpenCode V2 CLI from the package's "./tui" export
+// and receives a plugin Context (see @opencode/plugin/tui). It exports a plain
+// { id, setup } definition; Plugin.define() is an identity helper, so the
+// shape is the same without a runtime dependency on @opencode/plugin.
+
+import { writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const DEFAULTS = {
+  lines: 0,
+  min_lines: 6,
+  stats: true,
+  folded: true,
+  // No binding by default: ctrl+o belongs to OpenCode's "Open recent sessions
+  // and projects". Set `key` to opt in to a fold/unfold-all shortcut.
+  key: "",
+  // V2 collapses a long command to two lines and its output to ten, both with
+  // click-to-expand, so the command is no longer the "the host never trims it"
+  // gap it was in V1. Off by default; turn on to tighten it to one line.
+  bash: false,
+  bash_lines: 1,
+  // Where "Fold diffs: diagnose" writes its tree dump. "" is the default
+  // (/tmp/opencode-fold-diffs-tree.txt); false turns the dump off.
+  dump: "",
+};
+
+// Header labels of the file-writing tools, as V2 renders them. Unlike V1, V2
+// splits a block header into a label text node ("# Wrote", "← Edit", ...) and a
+// separate path node, so these match the label alone. The trailing alternation
+// keeps a header that already carries the stats suffix matching on later scans.
+const LABELS = ["# Wrote", "← Edit", "← Patched", "# Created", "# Deleted", "# Moved"];
+
+function isLabel(text) {
+  return LABELS.includes(text);
+}
+
+// The stats suffix this plugin appends to a folded header. Stripping it makes
+// re-adopting a block idempotent: a hot reload rebuilds the plugin, re-walks the
+// same transcript and must not append the suffix a second time.
+const SUFFIX = / (?:\d+ lines?|\+\d+ −\d+) · click to expand$/;
+
+function baseLabel(text) {
+  const match = SUFFIX.exec(text);
+  return match ? text.slice(0, match.index) : text;
+}
+
+// A shell block carries no header of its own, and V2 writes the command with a
+// "$ " 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;
+
+function children(node) {
+  return typeof node?.getChildren === "function" ? node.getChildren() : [];
+}
+
+function plain(node) {
+  const value = node?.plainText;
+  return typeof value === "string" ? value : undefined;
+}
+
+// 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, and a code
+// renderable the only thing pairing `content` with `filetype`.
+function isDiff(node) {
+  return typeof node?.diff === "string";
+}
+
+function isCode(node) {
+  return typeof node?.content === "string" && typeof node?.filetype === "string";
+}
+
+// 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.
+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.
+    for (const node of inner) {
+      const text = plain(node);
+      if (typeof text === "string" && text.startsWith(PROMPT)) return { node, text };
+    }
+  }
+  return;
+}
+
+// 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.
+function commandRows(node, text) {
+  const height = typeof node?.height === "number" ? node.height : 0;
+  return Math.max(text.split("\n").length, height);
+}
+
+function bulk(node, found = []) {
+  if (!node || node.isDestroyed) return found;
+  if (isDiff(node) || isCode(node)) {
+    found.push(node);
+    return found;
+  }
+  for (const child of children(node)) bulk(child, found);
+  return found;
+}
+
+// The transcript is the only scrollbox in the TUI that asks to stick to the
+// bottom. Staying inside it is what keeps the permission dialog's diff preview
+// untouched -- you should always see in full what you are about to approve.
+function isTranscript(node) {
+  return (
+    typeof node?.scrollTo === "function" &&
+    typeof node?.scrollHeight === "number" &&
+    node.stickyScroll === true &&
+    node.stickyStart === "bottom"
+  );
+}
+
+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;
+  }
+}
+
+// A V2 BlockTool renders the header first: a row box whose first two children
+// are the label text ("# Wrote") and the path value. Anything else is not one
+// of ours. The row is returned with the label node so a folded header can be
+// restated with its stats.
+function blockHeader(block) {
+  for (const row of children(block)) {
+    const rowKids = children(row);
+    // Label plus the path value. The guard also keeps the plain-text read --
+    // which rebuilds a string every call -- off the leaf nodes, and the
+    // transcript is mostly leaf nodes.
+    if (rowKids.length < 2) continue;
+    // <Show> may leave childless placeholders around the label, so scan the
+    // row for the label rather than assume it is the first child. It must still
+    // have a sibling after it: that is the path value.
+    for (let i = 0; i < rowKids.length - 1; i++) {
+      const label = plain(rowKids[i]);
+      if (typeof label !== "string") continue;
+      const base = baseLabel(label);
+      if (!isLabel(base)) continue;
+      return { row, node: rowKids[i], label: base };
+    }
+  }
+  return;
+}
+
+function scan(node, hits = [], shell = false) {
+  if (!node || node.isDestroyed) return hits;
+  // A matched block never contains another one, so stop descending.
+  if (blockHeader(node) || (shell && shellCommand(node))) {
+    hits.push(node);
+    return hits;
+  }
+  for (const child of children(node)) scan(child, hits, shell);
+  return hits;
+}
+
+// "+12 −3" from a unified diff, "42 lines" from a written file. Counted off the
+// renderable's own props, so it stays right even for parts the TUI store has
+// already dropped.
+function summarise(nodes) {
+  let added = 0;
+  let removed = 0;
+  let lines = 0;
+  let diffs = 0;
+  for (const node of nodes) {
+    if (isDiff(node)) {
+      diffs++;
+      for (const line of node.diff.split("\n")) {
+        if (line.startsWith("+++") || line.startsWith("---")) continue;
+        if (line.startsWith("+")) added++;
+        else if (line.startsWith("-")) removed++;
+      }
+      continue;
+    }
+    lines += node.content.split("\n").length;
+  }
+  if (diffs) return { size: added + removed, label: `+${added} −${removed}` };
+  return { size: lines, label: `${lines} ${lines === 1 ? "line" : "lines"}` };
+}
+
+// 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.
+function dumpNode(node, depth, lines, limit) {
+  if (!node || node.isDestroyed || lines.length >= limit) return;
+  const kids = children(node);
+  const text = plain(node);
+  const tags = [];
+  if (isDiff(node)) tags.push("diff");
+  if (isCode(node)) tags.push("code");
+  if (node.stickyScroll === true) tags.push("sticky");
+  lines.push(
+    `${"  ".repeat(depth)}${node.constructor?.name ?? "node"} kids=${kids.length}` +
+      (typeof text === "string" ? ` text=${JSON.stringify(text.slice(0, 80))}` : "") +
+      (tags.length ? ` [${tags.join(",")}]` : "") +
+      ` vis=${node.visible} h=${node.height} ov=${node.overflow}`,
+  );
+  for (const kid of kids) dumpNode(kid, depth + 1, lines, limit);
+}
+
+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);
+    const shell = opts.bash === true;
+    const shellPeek = Math.max(0, Number(opts.bash_lines) || 0);
+
+    // Folded blocks, by their block renderable. WeakMap so a session switch,
+    // which destroys the renderables, drops the state with them.
+    const known = new WeakMap();
+    // 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 cached;
+    function transcript() {
+      if (cached && !cached.isDestroyed) return cached;
+      cached = findTranscript(context.renderer.root);
+      return cached;
+    }
+
+    function apply(state, fold) {
+      state.folded = fold;
+      state.body.forEach((node, index) => {
+        try {
+          // `visible = false` sets Yoga display:none, which removes the body
+          // from layout entirely. A zero max-height alone was not enough: Yoga
+          // 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.overflow = fold ? "hidden" : state.overflow[index];
+        } catch {}
+      });
+      // 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
+      // 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;
+        } catch {}
+      }
+      if (!titles || !state.title) return;
+      const next = fold ? `${state.text} ${state.suffix}` : state.text;
+      try {
+        state.title.content = next;
+      } catch {
+        titles = false;
+        return;
+      }
+      // 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 adoptDiff(block) {
+      const header = blockHeader(block);
+      if (!header) return false;
+      // Everything after the header that actually carries a diff or a file
+      // body. Diagnostics and the error line carry neither, so an edit that
+      // broke the build still says so while folded.
+      const body = [];
+      const heavy = [];
+      for (const child of children(block)) {
+        if (child === header.row) continue;
+        const found = bulk(child);
+        if (!found.length) continue;
+        body.push(child);
+        heavy.push(...found);
+      }
+      if (!body.length) return false;
+      const stats = summarise(heavy);
+      if (stats.size < floor) return false;
+
+      const state = {
+        block,
+        body,
+        overflow: body.map((node) => node.overflow),
+        title: header.node,
+        text: header.label,
+        suffix: `${stats.label} · click to expand`,
+        peek,
+        chrome: peek === 0,
+        folded: false,
+      };
+      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);
+      return true;
+    }
+
+    function adoptShell(block) {
+      const found = shellCommand(block);
+      if (!found) return;
+      if (commandRows(found.node, found.text) < floor) return;
+
+      const state = {
+        block,
+        body: [found.node],
+        overflow: [found.node.overflow],
+        title: undefined,
+        peek: shellPeek,
+        chrome: false,
+        folded: false,
+      };
+      known.set(block, state);
+
+      // 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
+      // setter with no getter, so it cannot be read back and chained. Take the
+      // 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);
+    }
+
+    function adopt(block) {
+      if (adoptDiff(block)) return;
+      if (shell) adoptShell(block);
+    }
+
+    function sweep() {
+      if (context.ui.router.current().type !== "session") return;
+      const box = transcript();
+      if (!box) return;
+      for (const block of scan(box, [], shell)) {
+        if (known.has(block)) continue;
+        adopt(block);
+      }
+    }
+
+    function all(fold) {
+      folding = fold;
+      const box = transcript();
+      if (!box) return 0;
+      let count = 0;
+      for (const block of scan(box, [], shell)) {
+        const state = known.get(block);
+        if (!state || state.folded === fold) continue;
+        apply(state, fold);
+        count++;
+      }
+      return count;
+    }
+
+    let pending;
+    function schedule() {
+      if (pending) return;
+      pending = setTimeout(() => {
+        pending = undefined;
+        sweep();
+      }, 120);
+    }
+
+    const offs = [
+      context.data.on("message.part.updated", schedule),
+      context.data.on("message.updated", schedule),
+    ];
+    const timer = setInterval(sweep, SWEEP_MS);
+    schedule();
+
+    // `keymap.layer` reads Solid context, so it must run while a component is
+    // rendering, not directly during setup. A null component mounted in the
+    // `app` slot owns the layer for the plugin's lifetime.
+    function FoldCommands() {
+      context.keymap.layer(() => ({
+        mode: "global",
+        priority: 100,
+        commands: [
+          {
+            id: "opencode-fold-diffs.toggle",
+            title: "Fold / unfold file diffs",
+            group: "Plugin",
+            palette: true,
+            bind: opts.key || false,
+            run() {
+              sweep();
+              const fold = !folding;
+              const changed = all(fold);
+              context.ui.toast.show({
+                variant: "info",
+                message: changed
+                  ? `${fold ? "Folded" : "Unfolded"} ${changed} ${changed === 1 ? "block" : "blocks"}`
+                  : `New file blocks will be ${fold ? "folded" : "unfolded"}`,
+                duration: 2000,
+              });
+            },
+          },
+          {
+            // Reports what the plugin can see, so "nothing happens" can be told
+            // apart from "no transcript yet" or "blocks not matched".
+            id: "opencode-fold-diffs.diagnose",
+            title: "Fold diffs: diagnose",
+            group: "Plugin",
+            palette: true,
+            run() {
+              const box = transcript();
+              const blocks = box ? scan(box, [], shell) : [];
+              const folded = blocks.filter((block) => known.get(block)?.folded).length;
+              let dump;
+              try {
+                const summary = [
+                  `transcript=${Boolean(box)} blocks=${blocks.length} folded=${folded} stats=${titles ? "on" : "off"}`,
+                ];
+                for (const block of blocks) {
+                  const state = known.get(block);
+                  const head = blockHeader(block);
+                  summary.push(
+                    `block "${head?.label ?? "?"}" folded=${state?.folded} body=[` +
+                      (state?.body ?? [])
+                        .map((node) => `${node.constructor?.name}(vis=${node.visible},ov=${node.overflow})`)
+                        .join(", ") +
+                      "]",
+                  );
+                }
+                const target =
+                  opts.dump === false
+                    ? undefined
+                    : typeof opts.dump === "string" && opts.dump
+                      ? opts.dump
+                      : join(tmpdir(), "opencode-fold-diffs-tree.txt");
+                if (target) {
+                  const lines = [];
+                  dumpNode(box ?? context.renderer.root, 0, lines, 600);
+                  dump = target;
+                  writeFileSync(target, summary.concat("", lines).join("\n"));
+                }
+              } catch {}
+              context.ui.toast.show({
+                title: "opencode-fold-diffs",
+                variant: box ? "info" : "warning",
+                duration: 5000,
+                message: box
+                  ? `transcript: yes · blocks: ${blocks.length} · folded: ${folded} · stats: ${titles ? "on" : "off"}` +
+                    (dump ? ` · dump: ${dump}` : "")
+                  : "transcript: not found — open a session first",
+              });
+            },
+          },
+        ],
+        bindings: opts.key ? ["opencode-fold-diffs.toggle"] : [],
+      }));
+      return null;
+    }
+    const stopCommands = context.ui.slot({ append: "app", render: () => FoldCommands() });
+
+    return () => {
+      stopCommands();
+      clearInterval(timer);
+      if (pending) clearTimeout(pending);
+      for (const off of offs) if (typeof off === "function") off();
+    };
+  },
+};