@@ -1,6 +1,30 @@
 # Changelog
 
-## Unreleased
+## 0.3.0-beta.2 — 2026-09-09
+
+- **The status line now asks OpenCode for a frame when it changes.** OpenCode's renderer draws
+  on demand, and nothing here ever called `requestRender()`: a signal changed from inside an
+  `await` — every progress update, and every notice raised by a slow action — reached the
+  render buffer and then waited there for something else to trigger a repaint. While a draft
+  runs the route also holds the renderer's own refcounted `requestLive()`, the same thing an
+  animation asks for, and drops it when the draft ends.
+
+  This is the one difference between 0.3.0-beta.1 and the branch summary reading as "no
+  feedback at all": beta.1 carries the progress line but never asks to be drawn. On the two
+  OpenCode versions the e2e suite can drive (1.18.26 and 1.18.29) the line was already being
+  painted promptly without it, so the fix is unconfirmed against a report rather than proven —
+  but nothing should depend on another component's render loop to be visible.
+
+- **The e2e suite can now watch a draft while it runs.** `startMock({ slowSummaryMs })` holds
+  back the branch-summary request only (the setup turns stay fast), and a new test samples the
+  tree 0.3s after you choose *Summarize* and three more times half a second apart: the line
+  must be up on all four, and the spinner must have turned between them. Every earlier test
+  used a mock that answered instantly, so nothing had ever looked at the screen mid-draft.
+
+- `CTREE_OPENCODE_VERSION` picks the OpenCode the e2e suite installs and drives (default
+  1.18.26), so a report against a newer release can be reproduced without editing the harness.
+
+## 0.3.0-beta.1 — 2026-09-08
 
 ### Breaking: the keymap is now vim-aligned
 
 
@@ -29,6 +29,23 @@ const server = http.createServer((req, res) => {
     if (req.method === "POST" && url.startsWith("/v1/chat/completions")) {
       let json = {};
       try { json = JSON.parse(body || "{}"); } catch {}
+      // MOCK_SLOW_MS: hold back the *summary* request only (the context-tree helper session's
+      // system prompt names it), so a test can watch the tree while a model is answering
+      // without slowing the turns that set the test up.
+      const slow = Number(process.env.MOCK_SLOW_MS || 0);
+      const isSummary = (json.messages || []).some((m) => typeof m.content === "string" && m.content.includes("context summarization assistant"));
+      if (slow > 0 && isSummary) {
+        return setTimeout(() => respond(req, res, url, body, json), slow);
+      }
+      return respond(req, res, url, body, json);
+    }
+    res.writeHead(404); res.end("not found");
+  });
+});
+
+function respond(req, res, url, body, json) {
+  {
+    {
       fs.appendFileSync(LOG, JSON.stringify({ ts: Date.now(), url, model: json.model, stream: !!json.stream, body: json }) + "\n");
       const id = "chatcmpl-" + Date.now();
       const created = Math.floor(Date.now() / 1000);
@@ -53,7 +70,6 @@ const server = http.createServer((req, res) => {
       res.writeHead(200, { "content-type": "application/json" });
       return res.end(JSON.stringify({ id, object: "chat.completion", created, model: json.model, choices: [{ index: 0, message: { role: "assistant", content: REPLY }, finish_reason: "stop" }], usage: { prompt_tokens: 100, completion_tokens: 5, total_tokens: 105 } }));
     }
-    res.writeHead(404); res.end("not found");
-  });
-});
+  }
+}
 server.listen(PORT, "127.0.0.1", () => console.log(`mock provider on http://127.0.0.1:${PORT}/v1 -> ${LOG}`));
@@ -324,10 +324,22 @@ export function TreeRoute(props: TreeRouteProps) {
   // palette (actions.ts) take this as `ctx.notify`, falling back to `api.ui.toast` without one.
   const [notice, setNotice] = createSignal<string | undefined>()
   let noticeTimer: ReturnType<typeof setTimeout> | undefined
+  /**
+   * Ask OpenCode's renderer for a frame. It renders **on demand**, so a signal we change from
+   * inside an `await` reaches the buffer and then sits there invisibly until something else
+   * repaints — which is why a status line set while a model was answering could stay dark for
+   * the whole call (`test/e2e/tui.test.ts` pins this). Every feedback path below asks.
+   */
+  const paint = () => (api.renderer as { requestRender?: () => void } | undefined)?.requestRender?.()
+
   const notify = (message: string, ms = 4000) => {
     setNotice(message)
     clearTimeout(noticeTimer)
-    noticeTimer = setTimeout(() => setNotice(undefined), ms)
+    noticeTimer = setTimeout(() => {
+      setNotice(undefined)
+      paint()
+    }, ms)
+    paint()
   }
   onCleanup(() => clearTimeout(noticeTimer))
 
@@ -337,21 +349,34 @@ export function TreeRoute(props: TreeRouteProps) {
     if (!state) {
       setProgress(undefined)
       setCancelling(undefined)
+      paint()
       return
     }
     const open = progress()
     setProgress({ ...state, startedAt: open && open.label === state.label ? open.startedAt : Date.now() })
+    paint()
   }
   const ctx: ActionContext = { api, store, directory, notify, progress: reportProgress }
 
-  // one interval for as long as something is running, rather than a permanently ticking route
+  // One interval for as long as something is running, rather than a permanently ticking route.
+  // `requestLive` is the renderer's own refcounted "keep drawing frames" request — the same
+  // thing an animation asks for — so the spinner turns without depending on anything else
+  // happening; the ticks below are what give it something new to draw.
   createEffect(
     on(
       () => progress() !== undefined,
       (running) => {
         if (!running) return
-        const timer = setInterval(() => setFrame((n) => n + 1), SPINNER_MS)
-        onCleanup(() => clearInterval(timer))
+        const renderer = api.renderer as { requestLive?: () => void; dropLive?: () => void } | undefined
+        renderer?.requestLive?.()
+        const timer = setInterval(() => {
+          setFrame((n) => n + 1)
+          paint()
+        }, SPINNER_MS)
+        onCleanup(() => {
+          clearInterval(timer)
+          renderer?.dropLive?.()
+        })
       },
     ),
   )
 
@@ -40,25 +40,38 @@ async function run(cmd: string[], cwd: string, env?: Record<string, string | und
 
 /**
  * Ensures a local `opencode` binary exists at harness/node_modules/.bin/opencode,
- * installing it with `npm i opencode-ai@1.18.26` in harness/ if missing. Writes a
+ * installing it with `npm i opencode-ai@$OPENCODE_VERSION` in harness/ if missing or if a
+ * different version is installed. Writes a
  * minimal harness/package.json first if one isn't there yet (harness/package*.json
  * is gitignored) — otherwise a cwd-less `npm i` walks up to the repo root and
  * pollutes the root package.json instead of installing locally.
  */
+/** The OpenCode the suite runs against. `CTREE_OPENCODE_VERSION` overrides it, so a report
+ *  against a newer release can be reproduced without editing the harness. */
+export const OPENCODE_VERSION = process.env["CTREE_OPENCODE_VERSION"] || "1.18.26"
+
+function installedOpencodeVersion(): string | undefined {
+  try {
+    return JSON.parse(readFileSync(path.join(HARNESS_DIR, "node_modules/opencode-ai/package.json"), "utf8")).version as string
+  } catch {
+    return undefined
+  }
+}
+
 export async function ensureOpencode(): Promise<string> {
   const bin = path.join(HARNESS_DIR, "node_modules/.bin/opencode")
-  if (!existsSync(bin)) {
+  if (!existsSync(bin) || installedOpencodeVersion() !== OPENCODE_VERSION) {
     const pkgJson = path.join(HARNESS_DIR, "package.json")
     if (!existsSync(pkgJson)) {
       writeFileSync(pkgJson, JSON.stringify({ name: "harness", version: "1.0.0", private: true }, null, 2) + "\n")
     }
     const proc = Bun.spawn({
-      cmd: ["npm", "i", "opencode-ai@1.18.26"],
+      cmd: ["npm", "i", `opencode-ai@${OPENCODE_VERSION}`],
       cwd: HARNESS_DIR,
       stdio: ["inherit", "inherit", "inherit"],
     })
     const code = await proc.exited
-    if (code !== 0) throw new Error(`npm i opencode-ai@1.18.26 failed in ${HARNESS_DIR} (exit ${code})`)
+    if (code !== 0) throw new Error(`npm i opencode-ai@${OPENCODE_VERSION} failed in ${HARNESS_DIR} (exit ${code})`)
   }
   if (!existsSync(bin)) throw new Error(`opencode binary still missing at ${bin} after install`)
   return bin
@@ -87,6 +100,9 @@ export interface StartMockOptions {
   port?: number
   /** MOCK_REPLY override for the assistant's canned text reply. */
   reply?: string
+  /** MOCK_SLOW_MS: hold back the branch-summary request this long, so a test can watch the
+   *  tree while a model is answering. Only the summary is delayed; setup turns stay fast. */
+  slowSummaryMs?: number
 }
 
 export async function startMock(opts: StartMockOptions = {}): Promise<StartedMock> {
@@ -103,6 +119,7 @@ export async function startMock(opts: StartMockOptions = {}): Promise<StartedMoc
       MOCK_LOG: logFile,
       MOCK_TOOL: opts.tool ? "1" : "0",
       ...(opts.reply ? { MOCK_REPLY: opts.reply } : {}),
+      ...(opts.slowSummaryMs ? { MOCK_SLOW_MS: String(opts.slowSummaryMs) } : {}),
     },
     stdio: ["ignore", "pipe", "pipe"],
   })
 
@@ -4,11 +4,23 @@
  */
 import { afterAll, beforeAll, describe, expect, test } from "bun:test"
 import path from "node:path"
+import { tmpdir } from "node:os"
 import { existsSync, readFileSync, readdirSync } from "node:fs"
 import { createProject, installPlugins, REPO_ROOT, runTui, runTuiScreens, startMock, type StartedMock } from "./harness.js"
 
 const e2e = process.env["CTREE_E2E"] === "1"
 
+/** `CTREE_DUMP=<path>` writes the pyte-rendered screens for eyeballing a failure. A value that
+ *  is not a path (`CTREE_DUMP=1`, the obvious thing to type) lands in the temp dir rather than
+ *  creating a file called `1` in the repo root — which is exactly how one got committed. */
+async function dumpScreens(screens: { label: string; screen: string }[]): Promise<void> {
+  const want = process.env["CTREE_DUMP"]
+  if (!want) return
+  const file = want.includes("/") ? want : path.join(tmpdir(), "ctree-e2e-screens.txt")
+  await Bun.write(file, screens.map((x) => `=== ${x.label}\n${x.screen}`).join("\n"))
+  console.log(`screens → ${file}`)
+}
+
 describe.skipIf(!e2e)("tui e2e: built plugin", () => {
   let mock: StartedMock
   let project: Awaited<ReturnType<typeof createProject>>
@@ -308,7 +320,7 @@ describe.skipIf(!e2e)("tui e2e: built plugin", () => {
         rows: 34,
         exitWhenDone: true,
       })
-      if (process.env["CTREE_DUMP"]) await Bun.write(process.env["CTREE_DUMP"]!, screens.map((x) => `=== ${x.label}\n${x.screen}`).join("\n"))
+      await dumpScreens(screens)
       // screens are captured *before* each key, so key N's screen is the state key N-1 left:
       // assert the state itself rather than the notice, which has a lifetime of its own
       const before = (key: number) => {
@@ -336,6 +348,66 @@ describe.skipIf(!e2e)("tui e2e: built plugin", () => {
     }
   }, 300_000)
 
+  test("a summary that takes seconds shows a live progress line while it runs", async () => {
+    // The mock answers instantly, which is why no earlier test watched the tree *during* a
+    // draft at all. Holding the summary request back pins the two things a user reports when
+    // they say "no feedback": that the line is up straight away (0.3s in, not whenever
+    // something else repaints), and that it is still moving while the model thinks.
+    const m = await startMock({ tool: false, slowSummaryMs: 20000 })
+    const proj = await createProject({ mockPort: m.port })
+    await installPlugins({ projectDir: proj.dir, server: [path.join(REPO_ROOT, "dist", "server.js")], tui: [path.join(REPO_ROOT, "dist", "tui.js")] })
+    try {
+      const { screens } = await runTuiScreens({
+        projectDir: proj.dir,
+        keys: [
+          ["Ask anything", 1, "first question\r"],
+          ["mock reply", 8, "second question\r"],
+          ["mock reply", 16, "/tree"],
+          ["Context tree", 0.5, "\r"],
+          ["Context tree ·", 2, "gg"],
+          ["Context tree ·", 3, "\r"],
+          // ↓ once = "Summarize everything below this point"
+          ["Fork & prefill this turn", 1.5, "\x1b[B"],
+          ["Summarize everything below", 1, "\r"],
+          // four screens half a second apart while the summary is still in flight: close
+          // enough that only a *live* line changes between them (the spinner turns every
+          // 120ms), which is the thing OpenCode's on-demand renderer does not do by itself
+          ["Summarize everything below", 0.3, ""],
+          ["Summarize everything below", 0.5, ""],
+          ["Summarize everything below", 0.5, ""],
+          ["Summarize everything below", 0.5, ""],
+          ["mock reply|Ask anything", 20, "\x03"],
+          ["", 1, "\x03"],
+        ],
+        timeoutSec: 240,
+        cols: 130,
+        rows: 34,
+        exitWhenDone: true,
+      })
+      await dumpScreens(screens)
+      // the first sample is 0.3s after the choice: the line has to be up *immediately*, not
+      // whenever something else happens to repaint the screen
+      const inFlight = screens.filter((x) => x.label.includes("conditional key 8") || x.label.includes("conditional key 9") || x.label.includes("conditional key 10") || x.label.includes("conditional key 11"))
+      expect(inFlight.length).toBe(4)
+      const during = inFlight.filter((x) => x.screen.includes("summarizing"))
+      if (during.length < 4) throw new Error(`the progress line was missing from ${4 - during.length} of the 4 in-flight samples: ${inFlight.map((x) => (x.screen.includes("summarizing") ? "line" : "NOTHING")).join(" ")}`)
+      expect(during.every((x) => x.screen.includes("esc cancels"))).toBe(true)
+
+      // It is *live*: the spinner has turned between these half-second samples. Without a
+      // frame request the line is drawn once and then sits frozen until something unrelated
+      // repaints — which is exactly what "no feedback" looked like.
+      const frames = during.map((x) => /([⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]) summarizing/.exec(x.screen)?.[1]).filter((v): v is string => v !== undefined)
+      if (process.env["CTREE_DUMP"]) console.log(`spinner frames across ${during.length} samples: ${frames.join(" ")}`)
+      expect(frames.length).toBe(during.length)
+      // two of four is enough to prove it moved: at 8 frames a second, samples half a second
+      // apart alias against the 10-frame cycle, so "all four differ" would be flaky
+      expect(new Set(frames).size).toBeGreaterThan(1)
+    } finally {
+      await m.stop()
+      await proj.cleanup()
+    }
+  }, 300_000)
+
   test("the g-prefixed verbs fire alongside gg", async () => {
     // `gg` was the only sequence in the keymap; the realignment put every plugin verb behind
     // `g`, so this proves the sequence tree branches rather than `gg` shadowing them