refactor(renderer): remove prev_line_count; extract scrolling logic and simplify flush

Remove unused ctx.prev_line_count from the renderer context and reset.
Simplify M.flush() to only request data-rendered when changes were applied and
the renderer is not in bulk_mode. Extract window-scrolling into
M.scroll_win_to_bottom() and reuse it from post_flush().

tests: make replay deterministic and robust for bulk mode

Sort extmarks deterministically in test helpers, clear/reset UI and renderer
state during replay setup, and force synchronous completion (flush.end_bulk_mode())
in replay tests when ctx.bulk_mode is active so assertions run against final output.

Author: sudo-tee

lua/opencode/ui/renderer/ctx.lua

@@ -6,8 +6,6 @@ local RenderState = require('opencode.ui.render_state')
 local ctx = {
   ---@type RenderState
   render_state = RenderState.new(),
-  ---@type integer
-  prev_line_count = 0,
   ---@type { part_id: string|nil, formatted_data: Output|nil }
   last_part_formatted = { part_id = nil, formatted_data = nil },
   ---@type table<string, Output>
@@ -34,7 +32,6 @@ local ctx = {
 
 function ctx:reset()
   self.render_state:reset()
-  self.prev_line_count = 0
   self.last_part_formatted = { part_id = nil, formatted_data = nil }
   self.formatted_parts = {}
   self.formatted_messages = {}

lua/opencode/ui/renderer/flush.lua

@@ -418,18 +418,8 @@ end
 function M.flush()
   local pending = snapshot_pending()
   local applied = apply_pending(pending)
-  if applied then
-    local windows = state.windows
-    local output_buf = windows and windows.output_buf
-    if output_buf and vim.api.nvim_buf_is_valid(output_buf) then
-      local ok, line_count = pcall(vim.api.nvim_buf_line_count, output_buf)
-      if ok then
-        ctx.prev_line_count = line_count
-      end
-    end
-    if not ctx.bulk_mode then
-      M.request_on_data_rendered()
-    end
+  if applied and not ctx.bulk_mode then
+    M.request_on_data_rendered()
   end
 end
 

lua/opencode/ui/renderer/scroll.lua

@@ -14,6 +14,21 @@ function M.get_output_win()
   return win
 end
 
+---Move the cursor in `win` to the last line of `buf` and scroll so it's visible.
+---@param win integer
+---@param buf integer
+function M.scroll_win_to_bottom(win, buf)
+  local line_count = vim.api.nvim_buf_line_count(buf)
+  if line_count == 0 then
+    return
+  end
+  local last_line = vim.api.nvim_buf_get_lines(buf, line_count - 1, line_count, false)[1] or ''
+  vim.api.nvim_win_set_cursor(win, { line_count, #last_line })
+  vim.api.nvim_win_call(win, function()
+    vim.cmd('normal! zb')
+  end)
+end
+
 ---@param buf integer|nil
 ---@return { win: integer, follow: boolean }|nil
 function M.pre_flush(buf)
@@ -41,17 +56,7 @@ function M.post_flush(snapshot, buf)
   if not vim.api.nvim_win_is_valid(snapshot.win) or vim.api.nvim_win_get_buf(snapshot.win) ~= buf then
     return
   end
-
-  local line_count = vim.api.nvim_buf_line_count(buf)
-  if line_count == 0 then
-    return
-  end
-
-  local last_line = vim.api.nvim_buf_get_lines(buf, line_count - 1, line_count, false)[1] or ''
-  vim.api.nvim_win_set_cursor(snapshot.win, { line_count, #last_line })
-  vim.api.nvim_win_call(snapshot.win, function()
-    vim.cmd('normal! zb')
-  end)
+  M.scroll_win_to_bottom(snapshot.win, buf)
 end
 
 return M

tests/helpers.lua

@@ -11,12 +11,28 @@ function M.replay_setup()
   local state = require('opencode.state')
   local ui = require('opencode.ui.ui')
   local renderer = require('opencode.ui.renderer')
+  local permission_window = require('opencode.ui.permission_window')
+  local question_window = require('opencode.ui.question_window')
+  local reference_picker = require('opencode.ui.reference_picker')
 
   local empty_promise = require('opencode.promise').new():resolve(nil)
   config_file.config_promise = empty_promise
   config_file.project_promise = empty_promise
   config_file.providers_promise = empty_promise
 
+  if state.windows then
+    ui.close_windows(state.windows)
+  end
+
+  renderer.reset()
+  permission_window.clear_all()
+  question_window._clear_dialog()
+  question_window._current_question = nil
+  question_window._current_question_index = 1
+  question_window._collected_answers = {}
+  question_window._answering = false
+  reference_picker.clear_all()
+
   ---@diagnostic disable-next-line: duplicate-set-field
   require('opencode.session').project_id = function()
     return nil
@@ -323,9 +339,28 @@ function M.normalize_namespace_ids(extmarks)
 end
 
 function M.capture_output(output_buf, namespace)
+  local extmarks = vim.api.nvim_buf_get_extmarks(output_buf, namespace, 0, -1, { details = true }) or {}
+  table.sort(extmarks, function(a, b)
+    if a[2] ~= b[2] then
+      return a[2] < b[2]
+    end
+
+    if a[3] ~= b[3] then
+      return a[3] < b[3]
+    end
+
+    local a_priority = a[4] and a[4].priority or 0
+    local b_priority = b[4] and b[4].priority or 0
+    if a_priority ~= b_priority then
+      return a_priority > b_priority
+    end
+
+    return a[1] < b[1]
+  end)
+
   return {
     lines = vim.api.nvim_buf_get_lines(output_buf, 0, -1, false) or {},
-    extmarks = vim.api.nvim_buf_get_extmarks(output_buf, namespace, 0, -1, { details = true }) or {},
+    extmarks = extmarks,
     actions = vim.deepcopy(require('opencode.ui.renderer.ctx').render_state:get_all_actions()),
   }
 end

tests/replay/renderer_spec.lua

@@ -277,20 +277,30 @@ describe('renderer functional tests', function()
           )
         end
 
-        if not vim.tbl_contains(skip_full_session, name) then
-          it('replays ' .. name .. ' correctly (session)', function()
-            local renderer = require('opencode.ui.renderer')
-            local events = helpers.load_test_data(filepath)
-            state.session.set_active(helpers.get_session_from_events(events, true))
-            local expected = helpers.load_test_data(expected_path)
-
-            local session_data = helpers.load_session_from_events(events)
-            renderer._render_full_session_data(session_data)
-
-            local actual = helpers.capture_output(state.windows and state.windows.output_buf, output_window.namespace)
-            assert_output_matches(expected, actual, name)
-          end)
-        end
+  if not vim.tbl_contains(skip_full_session, name) then
+    it('replays ' .. name .. ' correctly (session)', function()
+      local renderer = require('opencode.ui.renderer')
+      local flush = require('opencode.ui.renderer.flush')
+      local ctx = require('opencode.ui.renderer.ctx')
+      local events = helpers.load_test_data(filepath)
+      state.session.set_active(helpers.get_session_from_events(events, true))
+      local expected = helpers.load_test_data(expected_path)
+
+      local session_data = helpers.load_session_from_events(events)
+      renderer._render_full_session_data(session_data)
+
+      -- If bulk mode is active (async writing), wait for it to complete
+      -- by forcing synchronous completion
+      if ctx.bulk_mode then
+        -- Force synchronous completion by calling end_bulk_mode directly
+        -- This ensures all content is written before we check
+        flush.end_bulk_mode()
+      end
+
+      local actual = helpers.capture_output(state.windows and state.windows.output_buf, output_window.namespace)
+      assert_output_matches(expected, actual, name)
+    end)
+  end
       end
     end
   end