[BUG] closeAllDiffTabs closes all diff-mode windows, destroying unrelated diffs (diffview.nvim)

[tibbe]

Bug Description

claudecode.nvim closes/overwrites diff windows it doesn't own. If you have a diff open from diffview.nvim (or native :diffthis/vimdiff/fugitive) while the Claude Code integration is active, the side-by-side diff windows get closed, leaving the review "blank." Plain (non-diff) buffers are unaffected.

Two independent defects in the source:

1. lua/claudecode/tools/close_all_diff_tabs.lua closes every &diff window, not just claudecode's own. The handler marks any window with diff set for closing (and force-deletes buffers matching %.diff$ / diff:// / ^fugitive://), with no check that claudecode created them:

   local diff_mode = vim.api.nvim_win_get_option(win, "diff")   -- ~L30
   if diff_mode then
     should_close = true                                        -- ~L34-36
   end
   ...
   pcall(vim.api.nvim_win_close, win, false)                    -- ~L56-58

   diffview's side-by-side windows have &diff set, so they're closed; its diffview:// file panel isn't a diff window, so it survives — which exactly matches the symptom.

2. find_main_editor_window does not exclude &diff windows (in both lua/claudecode/tools/open_file.lua ~L53 and lua/claudecode/diff.lua ~L124). It skips floats, terminals, nofile/prompt, and known sidebar filetypes, but a diffview working-tree window is an ordinary file buffer, so it's chosen as the "main editor window" and openFile/openDiff then :edits into it, corrupting the layout.

To Reproduce

1. Open Neovim in a git repo with uncommitted changes and run :DiffviewOpen — the side-by-side diff appears.
2. Start/connect the Claude Code integration against that Neovim (--ide).
3. Use Claude normally (it reads/edits files / cleans up diffs over the course of a turn).
4. The side-by-side diff windows are closed/blanked; only the Diffview file panel remains. Normal file buffers are never affected.

(The handler behavior in defect #1 is deterministic: any window with &diff set is closed when closeAllDiffTabs runs.)

Expected Behavior

claudecode should only close or replace diffs it created (it already tracks these via diff.close_all_diffs()). It must not close or delete windows/buffers belonging to other diff tools (diffview.nvim, :diffthis, fugitive). Likewise, find_main_editor_window should not select a window that is currently in diff mode.

Environment

• Neovim version: 0.11.6
• Claude Code CLI version: 2.1.175
• OS: macOS 26.3.1 (Darwin 25.3.0)
• Plugin version: v0.3.0-35-g7b8b709 (commit 7b8b709)

Error Messages

No error is emitted — the diff windows are closed silently. MCP-message logging during the affected flow showed only the connection handshake plus read-only getDiagnostics calls, so I was unable to capture the exact client→server RPC that invokes closeAllDiffTabs; I'm therefore reporting defect #1 as an independent handler bug rather than asserting the precise call site.

(no error output)

Additional Context

• Suggested fixes: scope closeAllDiffTabs to claudecode-tracked diffs only (or, at minimum, skip windows in a tab that contains a diffview:// buffer); add a vim.wo[win].diff guard to find_main_editor_window in both files.
• Workaround that helps the edit-time path only: setting diff_opts.open_in_new_tab = true keeps openDiff from reusing the current tab — but it does not address closeAllDiffTabs.

[ThomasK33]

Note

This triage report is AI-generated using Claude Code

Summary

This has been confirmed as a genuine bug, and both defects described in the issue are accurate. A reproduction environment was built, the failure was observed deterministically (3/3), and the root cause was then traced through the plugin source, the Claude CLI binary, and the official VS Code extension. A fix has been prepared and verified locally (details at the end).

Environment used for reproduction: Neovim 0.11.x, Claude Code CLI 2.1.175 (matching the version in the report), macOS, plugin at current main (commit 7c7d47e).

Reproduction (3/3, deterministic)

A fixture (fixtures/issue-277/) and a scripted harness (scripts/repro_issue_277.sh) were created. The harness drives a real Neovim TUI with diffview.nvim loaded and then sends the same MCP tools/call requests that the CLI sends. Each phase is written so that PASS = the bug is present.

With the current code, all three phases reproduce (closeAllDiffTabs returns CLOSED_2_DIFF_TABS; the diff-window count goes 2 → 0):

Phase	Steps	Observed (buggy)
1	:DiffviewOpen, then closeAllDiffTabs	both side-by-side diff windows are closed; only the Diffview file panel remains
2	native :vertical diffsplit, then openFile	the opened file is :edit-ed into one half of the diff; the diff pair is broken
3	native :vertical diffsplit, then closeAllDiffTabs	the user's vimdiff windows are closed

Root cause

The tool is invoked on every turn. Inspecting the CLI binary (2.1.175) shows closeAllDiffTabs being called fire-and-forget at the start of each user turn whenever an IDE client is connected, with the result discarded in a catch {}. This explains why no explicit error appears, and why the impact is felt on essentially every prompt — it is also consistent with the observation that only the handshake and read-only getDiagnostics calls were visible during the affected flow.

Defect 1 — the sweep is unscoped (and is a parity regression). lua/claudecode/tools/close_all_diff_tabs.lua first drains the plugin's own tracked diffs (correct), and then additionally closes every window with &diff set and force-deletes any buffer named like *.diff / diff:// / fugitive://. There is no check that the plugin created them, so diffview.nvim's side-by-side windows (which have &diff set) are closed while its diffview:// panel survives — exactly the reported symptom. For comparison, the official VS Code extension's equivalent closes only tabs it had labelled [Claude Code] … — an explicit ownership check. The unscoped behaviour appears to have originated in an early "VS Code parity" change, yet the reference implementation was never actually unscoped, so ownership-scoping is more faithful to it, not less.

Defect 2 — find_main_editor_window does not exclude &diff windows. This selector (duplicated in lua/claudecode/tools/open_file.lua and lua/claudecode/diff.lua) skips floats, terminals, and known sidebar filetypes, but not diff windows. A diffview working-tree window is an ordinary file buffer, so it can be selected as the "main editor window," after which openFile/openDiff :edits into it. The mechanism was confirmed directly: :edit-ing a non-diff buffer into a &diff window clears that window's diff option, and its partner window then drops out of the diff group — corrupting the layout. (The selector currently exists as two copies that have drifted apart, which may be worth addressing separately.)

Suggested fix (prepared and verified)

The approach matches the suggestion in the issue:

• closeAllDiffTabs is scoped to the plugin's existing tracked-diff registry only (the &diff window sweep and the buffer force-delete are dropped entirely);
• a &diff guard is added to both copies of find_main_editor_window, to the open_file fallback path, and to the buffer-reuse branch in the diff-setup code.

With this change applied and run against the same harness, all three phases flip to NOT REPRODUCED (closeAllDiffTabs returns CLOSED_0_DIFF_TABS; the diffview/vimdiff windows survive; openFile opens in a fresh window beside the diff). The full unit suite passes (655/655) and luacheck reports no warnings. A pull request will follow shortly.

The diff_opts.open_in_new_tab = true workaround noted in the issue helps only the openFile/openDiff path and does not address the turn-start closeAllDiffTabs sweep — consistent with what was reported.

Reproduction artifacts

The reproduction was carried out with the files below (collapsed for brevity). They have been screened for sensitive information before posting.

fixtures/issue-277/init.lua

-- Fixture for issue #277:
--   "[BUG] closeAllDiffTabs closes all diff-mode windows, destroying unrelated
--    diffs (diffview.nvim)"
--   https://github.com/coder/claudecode.nvim/issues/277
--
-- Two defects under test:
--   1. tools/close_all_diff_tabs.lua closes EVERY `&diff` window (no ownership
--      check), so diffview.nvim / fugitive / native `:diffthis` layouts are
--      destroyed when the Claude CLI fires closeAllDiffTabs (it does so at the
--      start of a user turn whenever an IDE is connected).
--   2. find_main_editor_window (tools/open_file.lua and diff.lua) does not
--      exclude `&diff` windows, so openFile/openDiff target a diffview window
--      and :edit into it, corrupting the diff layout.
--
-- The fixture pulls in diffview.nvim (cloned on first run) and exposes a
-- window-state probe for scripted verification:
--   nvim --server <sock> --remote-expr 'v:lua.Repro277State()'
--
-- Usage (from repo root):
--   source fixtures/nvim-aliases.sh && vv issue-277
-- or scripted:
--   scripts/repro_issue_277.sh
--
-- Manual repro: open a file in a git repo with uncommitted changes,
-- :DiffviewOpen, connect claude (--ide), submit any prompt -> the side-by-side
-- diff windows close, only the Diffview file panel survives.

local config_dir = vim.fn.stdpath("config")
local repo_root = vim.fn.fnamemodify(config_dir, ":h:h")
vim.opt.rtp:prepend(repo_root)

vim.g.mapleader = " "
vim.g.maplocalleader = "\\"

-- ---------------------------------------------------------------------------
-- diffview.nvim (cloned into stdpath("data") on first run; no plugin manager)
-- ---------------------------------------------------------------------------
local diffview_dir = vim.fn.stdpath("data") .. "/diffview.nvim"
if vim.fn.isdirectory(diffview_dir) == 0 then
  vim.notify("issue-277 fixture: cloning diffview.nvim ...")
  local out = vim.fn.system({
    "git",
    "clone",
    "--depth=1",
    "https://github.com/sindrets/diffview.nvim",
    diffview_dir,
  })
  assert(vim.v.shell_error == 0, "failed to clone diffview.nvim: " .. out)
end
vim.opt.rtp:prepend(diffview_dir)

local ok_dv, diffview = pcall(require, "diffview")
assert(ok_dv, "Failed to load diffview.nvim: " .. tostring(diffview))
diffview.setup({})

-- ---------------------------------------------------------------------------
-- claudecode.nvim (dev version from this repo)
-- ---------------------------------------------------------------------------
local ok, claudecode = pcall(require, "claudecode")
assert(ok, "Failed to load claudecode.nvim from repo root: " .. tostring(claudecode))

claudecode.setup({
  auto_start = true, -- server + lock file immediately, so scripts can connect
  -- "warn", not "debug": multi-line debug echoes trip nvim's hit-enter prompt,
  -- which blocks --remote-expr probes in the scripted repro.
  log_level = "warn",
  terminal = {
    provider = "native",
    auto_close = false,
  },
})

vim.o.showtabline = 2
vim.o.laststatus = 2

-- ---------------------------------------------------------------------------
-- Window-state probe (for --remote-expr / on-screen verification)
-- ---------------------------------------------------------------------------

---Compact state of every window across all tabpages.
---@return string JSON: [{win,tab,name,buftype,filetype,diff}...]
function _G.Repro277State()
  local out = {}
  for _, win in ipairs(vim.api.nvim_list_wins()) do
    local buf = vim.api.nvim_win_get_buf(win)
    local name = vim.api.nvim_buf_get_name(buf)
    out[#out + 1] = {
      win = win,
      tab = vim.api.nvim_tabpage_get_number(vim.api.nvim_win_get_tabpage(win)),
      name = vim.fn.fnamemodify(name, ":t") ~= "" and vim.fn.fnamemodify(name, ":~:.") or "[No Name]",
      buftype = vim.bo[buf].buftype,
      filetype = vim.bo[buf].filetype,
      diff = vim.wo[win].diff,
    }
  end
  return vim.json.encode(out)
end

---WebSocket endpoint of the running claudecode server ("port token", or "" if
---not started yet). Lets scripts connect without scanning ~/.claude/ide.
---@return string
function _G.Repro277Server()
  local cc = require("claudecode")
  if cc.state.port and cc.state.auth_token then
    return cc.state.port .. " " .. cc.state.auth_token
  end
  return ""
end

---Count of windows currently in diff mode (quick assertion helper).
---@return integer
function _G.Repro277DiffWinCount()
  local n = 0
  for _, win in ipairs(vim.api.nvim_list_wins()) do
    if vim.wo[win].diff then
      n = n + 1
    end
  end
  return n
end

vim.api.nvim_create_user_command("ReproState", function()
  vim.notify(_G.Repro277State())
end, { desc = "Show issue-277 window state" })

-- Native (plugin-free) diff variant of the same bug: two `:diffsplit` windows.
vim.api.nvim_create_user_command("ReproNativeDiff", function(cmd_opts)
  local args = vim.split(cmd_opts.args, "%s+")
  assert(#args == 2, "usage: :ReproNativeDiff <file_a> <file_b>")
  vim.cmd("edit " .. vim.fn.fnameescape(args[1]))
  vim.cmd("vertical diffsplit " .. vim.fn.fnameescape(args[2]))
end, { nargs = "+", complete = "file", desc = "Open a native vimdiff of two files" })

vim.keymap.set("n", "<leader>aw", function()
  vim.notify(("diff windows: %d"):format(_G.Repro277DiffWinCount()))
end, { desc = "Show diff window count" })

fixtures/issue-277/README.md

# Fixture: issue #277 — closeAllDiffTabs destroys foreign diffs

Reproduction environment for
[#277 "[BUG] closeAllDiffTabs closes all diff-mode windows, destroying unrelated diffs (diffview.nvim)"](https://github.com/coder/claudecode.nvim/issues/277).

Two defects:

1. `tools/close_all_diff_tabs.lua` closes **every** window with `&diff` set (and
   force-deletes `%.diff$` / `diff://` / `fugitive://` buffers) with no check
   that claudecode created them. The Claude CLI invokes `closeAllDiffTabs` at
   the **start of each user turn** when an IDE is connected (verified against
   CLI 2.1.175), so any diffview.nvim / fugitive / native vimdiff layout that is
   open when you submit a prompt gets destroyed.
2. `find_main_editor_window()` (in `tools/open_file.lua` and `diff.lua`) does
   not exclude `&diff` windows, so `openFile`/`openDiff` can `:edit` into one
   half of a foreign diff, corrupting it (the new buffer joins the diff).

## Scripted reproduction

```bash
scripts/repro_issue_277.sh
```

Drives a real Neovim TUI under agent-tty, opens diffview/native diffs, then
sends the same MCP `tools/call` requests the Claude CLI sends. Prints
`REPRODUCED:`/`NOT REPRODUCED:` per phase; exits 0 when all three defects
reproduce.

## Manual reproduction

```bash
source fixtures/nvim-aliases.sh && vv issue-277  # cwd must be a git repo with changes
```

1. `:DiffviewOpen` — side-by-side diff appears (2 windows with `&diff` + file panel).
2. Connect Claude (`:ClaudeCode`, or any client with the lock-file token).
3. Submit any prompt (or send `closeAllDiffTabs` by hand).
4. Both diff windows close; only the Diffview panel survives. `<leader>aw`
   shows the diff-window count; `:ReproState` dumps per-window state.

`:ReproNativeDiff <a> <b>` opens a plugin-free native vimdiff for the same
experiment (no diffview involved).

## Notes

- diffview.nvim is cloned into `stdpath("data")/diffview.nvim`
  (`~/.local/share/issue-277/`) on first start.
- The fixture exposes `v:lua.Repro277State()`, `v:lua.Repro277DiffWinCount()`
  and `v:lua.Repro277Server()` for `--remote-expr` scripting.

scripts/repro_issue_277.sh

#!/usr/bin/env bash
#
# Reproduce issue #277: "[BUG] closeAllDiffTabs closes all diff-mode windows,
# destroying unrelated diffs (diffview.nvim)"
# https://github.com/coder/claudecode.nvim/issues/277
#
# Drives a real Neovim TUI (fixtures/issue-277, diffview.nvim + dev claudecode)
# inside agent-tty, then acts as the Claude CLI by sending MCP `tools/call`
# requests straight to the plugin's WebSocket server (the real CLI fires
# closeAllDiffTabs at the start of a user turn whenever an IDE is connected).
#
# Phases (each asserts the BUG reproduces, i.e. PASS == bug present):
#   1  :DiffviewOpen, then closeAllDiffTabs        -> both side-by-side diff
#      windows are closed, only the Diffview file panel survives ("blank review")
#   2  native `:vertical diffsplit`, then openFile -> the file is :edit-ed INTO a
#      diff-mode window (find_main_editor_window does not exclude &diff windows)
#      and joins the user's diff
#   3  native diff, then closeAllDiffTabs          -> user's vimdiff windows are
#      closed (no plugins involved at all)
#
# Requirements: nvim, agent-tty, websocat, jq, git, perl. No `claude` login is
# needed; the script speaks the MCP protocol itself.

set -uo pipefail

REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
WORK="$(mktemp -d "${TMPDIR:-/tmp}/issue277.XXXXXX")"
AGENT_HOME="$WORK/att-home"
NVIM_SOCK="$WORK/nvim.sock"
DEMO_REPO="$WORK/demo-repo"
ARTIFACTS="${ISSUE277_ARTIFACTS:-$WORK/artifacts}"
DIFFVIEW_DIR="${XDG_DATA_HOME:-$HOME/.local/share}/issue-277/diffview.nvim"

mkdir -p "$AGENT_HOME" "$ARTIFACTS"

for bin in nvim agent-tty jq git perl; do
  command -v "$bin" >/dev/null 2>&1 || {
    echo "MISSING dependency: $bin" >&2
    exit 3
  }
done

# A `websocat` mise shim can exist but have no active version, so probe that the
# resolved command actually runs before trusting it.
WEBSOCAT=websocat
"$WEBSOCAT" --version >/dev/null 2>&1 ||
  WEBSOCAT="$(find "${MISE_DATA_DIR:-$HOME/.local/share/mise}/installs/websocat" -maxdepth 2 -name websocat -type f 2>/dev/null | head -1)"
if [ -z "$WEBSOCAT" ] || ! "$WEBSOCAT" --version >/dev/null 2>&1; then
  echo "MISSING dependency: websocat (no working binary found)" >&2
  exit 3
fi

SESSION_ID=""
# shellcheck disable=SC2329  # invoked via `trap cleanup EXIT`
cleanup() {
  [ -n "$SESSION_ID" ] && agent-tty --home "$AGENT_HOME" destroy "$SESSION_ID" --json >/dev/null 2>&1
  rm -rf "$WORK"
}
trap cleanup EXIT

att() { agent-tty --home "$AGENT_HOME" "$@"; }
# Bounded --remote-expr: a modal hit-enter prompt in nvim would otherwise block
# the RPC (and this script) forever.
rexpr() { perl -e 'alarm 10; exec @ARGV' nvim --server "$NVIM_SOCK" --remote-expr "$1" 2>/dev/null; }
# Clear a hit-enter prompt ONLY if the RPC is actually blocked. A blind Enter
# would land in diffview's file panel (<CR> = reopen the diff!) and undo the
# very state we are asserting on.
ensure_responsive() {
  [ "$(rexpr '1+1')" = "2" ] && return 0
  att send-keys "$SESSION_ID" Enter --json >/dev/null 2>&1
  perl -e 'select(undef,undef,undef,0.5)'
  [ "$(rexpr '1+1')" = "2" ]
}
fail() {
  echo "SETUP FAILURE: $*" >&2
  exit 2
}

# mcp_call <tool-name> <arguments-json>: one-shot MCP tools/call as the Claude
# client. The server does not gate tools/call on `initialize`, and these tools
# respond immediately, so a short-lived socket is enough. macOS has no
# `timeout`; hold stdin open briefly and bound the whole client with alarm.
mcp_call() {
  local req
  req=$(jq -nc --arg name "$1" --argjson args "$2" \
    '{jsonrpc:"2.0",id:1,method:"tools/call",params:{name:$name,arguments:$args}}')
  {
    printf '%s\n' "$req"
    perl -e 'select(undef,undef,undef,2)'
  } |
    perl -e 'alarm 15; exec @ARGV' "$WEBSOCAT" -t "ws://127.0.0.1:$PORT" \
      --header "x-claude-code-ide-authorization: $TOKEN" 2>/dev/null |
    jq -c 'select(.id == 1)' # drop interleaved broadcasts (selection_changed)
  ensure_responsive
}

# ---------------------------------------------------------------------------
# Setup: demo git repo with uncommitted changes + diffview.nvim clone
# ---------------------------------------------------------------------------
mkdir -p "$DEMO_REPO"
(
  cd "$DEMO_REPO" || exit 1
  git init -q
  git config user.email repro@example.com
  git config user.name repro
  for i in $(seq 1 12); do echo "local line_$i = $i"; done >a.lua
  for i in $(seq 1 12); do echo "local other_$i = $i"; done >b.lua
  echo "# demo repo for issue #277" >README.md
  git add . && git commit -qm initial
  # uncommitted change so :DiffviewOpen has something to show
  printf 'local line_2 = 2000 -- CHANGED\n' >tmp && sed '2d' a.lua >>tmp && mv tmp a.lua
) || fail "could not build demo repo"

if [ ! -d "$DIFFVIEW_DIR" ]; then
  echo "[setup] cloning diffview.nvim -> $DIFFVIEW_DIR"
  git clone -q --depth=1 https://github.com/sindrets/diffview.nvim "$DIFFVIEW_DIR" ||
    fail "could not clone diffview.nvim"
fi

# ---------------------------------------------------------------------------
# Launch Neovim (issue-277 fixture) inside agent-tty
# ---------------------------------------------------------------------------
SESSION_ID=$(att create --json --cols 200 --rows 50 --cwd "$DEMO_REPO" \
  --name issue277 \
  --env NVIM_APPNAME=issue-277 \
  --env XDG_CONFIG_HOME="$REPO_ROOT/fixtures" \
  --env _ZO_DOCTOR=0 \
  -- nvim --listen "$NVIM_SOCK" | jq -r '.result.sessionId')
[ -n "$SESSION_ID" ] && [ "$SESSION_ID" != null ] || fail "agent-tty create failed"

for _ in $(seq 1 60); do
  [ -e "$NVIM_SOCK" ] && [ "$(rexpr '1+1')" = "2" ] && break
  perl -e 'select(undef,undef,undef,0.25)'
done
[ "$(rexpr '1+1')" = "2" ] || fail "nvim RPC socket never came up"

SERVER=""
for _ in $(seq 1 60); do
  SERVER=$(rexpr 'v:lua.Repro277Server()')
  [ -n "$SERVER" ] && break
  perl -e 'select(undef,undef,undef,0.25)'
done
[ -n "$SERVER" ] || fail "claudecode server never started (auto_start)"
PORT=${SERVER%% *}
TOKEN=${SERVER##* }
echo "[setup] nvim up; claudecode ws on port $PORT"

snap() { att snapshot "$SESSION_ID" --format text --json | jq -r '.result.text' >"$ARTIFACTS/$1.txt"; }

PASS=0
FAIL=0
verdict() { # <ok> <label>
  if [ "$1" = 1 ]; then
    PASS=$((PASS + 1))
    echo "REPRODUCED: $2"
  else
    FAIL=$((FAIL + 1))
    echo "NOT REPRODUCED: $2"
  fi
}

wait_diff_wins() { # <count> -> 0 if reached
  for _ in $(seq 1 40); do
    [ "$(rexpr 'v:lua.Repro277DiffWinCount()')" = "$1" ] && return 0
    perl -e 'select(undef,undef,undef,0.25)'
  done
  return 1
}

# ---------------------------------------------------------------------------
# Phase 1: closeAllDiffTabs destroys a diffview.nvim review     (defect 1)
# ---------------------------------------------------------------------------
echo
echo "=== Phase 1: :DiffviewOpen + closeAllDiffTabs ==="
rexpr 'execute("DiffviewOpen")' >/dev/null
wait_diff_wins 2 || fail "DiffviewOpen never produced 2 diff windows"
att wait "$SESSION_ID" --screen-stable-ms 700 --timeout-ms 8000 --json >/dev/null
snap phase1-before
P1_BEFORE=$(rexpr 'v:lua.Repro277DiffWinCount()')
P1_STATE_BEFORE=$(rexpr 'v:lua.Repro277State()')
echo "  before: $P1_BEFORE diff windows; windows: $(echo "$P1_STATE_BEFORE" | jq -c '[.[] | {name, filetype, diff}]')"

P1_RESP=$(mcp_call closeAllDiffTabs '{}')
echo "  closeAllDiffTabs response: $(echo "$P1_RESP" | jq -c '.result.content[0].text' 2>/dev/null || echo "$P1_RESP")"

att wait "$SESSION_ID" --screen-stable-ms 700 --timeout-ms 8000 --json >/dev/null
snap phase1-after
P1_AFTER=$(rexpr 'v:lua.Repro277DiffWinCount()')
P1_STATE_AFTER=$(rexpr 'v:lua.Repro277State()')
P1_PANEL=$(echo "$P1_STATE_AFTER" | jq '[.[] | select(.filetype == "DiffviewFiles")] | length')
echo "  after:  $P1_AFTER diff windows; windows: $(echo "$P1_STATE_AFTER" | jq -c '[.[] | {name, filetype, diff}]')"

P1_OK=0
[ "$P1_BEFORE" = 2 ] && [ "$P1_AFTER" = 0 ] && [ "$P1_PANEL" -ge 1 ] && P1_OK=1
verdict "$P1_OK" "diffview side-by-side windows closed; orphaned file panel left behind"

# ---------------------------------------------------------------------------
# Phase 2: openFile :edit-s into a foreign diff window          (defect 2)
# ---------------------------------------------------------------------------
echo
echo "=== Phase 2: native :vertical diffsplit + openFile ==="
rexpr 'execute("DiffviewClose")' >/dev/null
rexpr 'execute("tabonly | only")' >/dev/null
rexpr 'execute("ReproNativeDiff a.lua b.lua")' >/dev/null
wait_diff_wins 2 || fail "ReproNativeDiff never produced 2 diff windows"
P2_STATE_BEFORE=$(rexpr 'v:lua.Repro277State()')
echo "  before: windows: $(echo "$P2_STATE_BEFORE" | jq -c '[.[] | {name, diff}]')"

P2_RESP=$(mcp_call openFile '{"filePath": "README.md"}')
echo "  openFile response: $(echo "$P2_RESP" | jq -c '.result.content[0].text' 2>/dev/null || echo "$P2_RESP")"

att wait "$SESSION_ID" --screen-stable-ms 700 --timeout-ms 8000 --json >/dev/null
snap phase2-after
P2_STATE_AFTER=$(rexpr 'v:lua.Repro277State()')
# The corrupted outcome: README.md was :edit-ed into one half of the vimdiff
# (b.lua's window is gone; entering a new buffer resets the window-local &diff,
# leaving the other half diffing against nothing).
P2_README_WINS=$(echo "$P2_STATE_AFTER" | jq '[.[] | select(.name | endswith("README.md"))] | length')
P2_BLUA_WINS=$(echo "$P2_STATE_AFTER" | jq '[.[] | select(.name | endswith("b.lua"))] | length')
P2_DIFF_AFTER=$(rexpr 'v:lua.Repro277DiffWinCount()')
echo "  after:  windows: $(echo "$P2_STATE_AFTER" | jq -c '[.[] | {name, diff}]')"

P2_OK=0
[ "$P2_README_WINS" -ge 1 ] && [ "$P2_BLUA_WINS" = 0 ] && [ "$P2_DIFF_AFTER" = 1 ] && P2_OK=1
verdict "$P2_OK" "openFile hijacked one half of the user's vimdiff (b.lua window replaced by README.md, diff pair broken)"

# ---------------------------------------------------------------------------
# Phase 3: closeAllDiffTabs destroys a native vimdiff           (defect 1)
# ---------------------------------------------------------------------------
echo
echo "=== Phase 3: native :vertical diffsplit + closeAllDiffTabs ==="
rexpr 'execute("only")' >/dev/null
rexpr 'execute("ReproNativeDiff a.lua b.lua")' >/dev/null
wait_diff_wins 2 || fail "ReproNativeDiff never produced 2 diff windows"
P3_BEFORE=$(rexpr 'v:lua.Repro277DiffWinCount()')
P3_WINS_BEFORE=$(rexpr 'v:lua.Repro277State()' | jq 'length')

P3_RESP=$(mcp_call closeAllDiffTabs '{}')
echo "  closeAllDiffTabs response: $(echo "$P3_RESP" | jq -c '.result.content[0].text' 2>/dev/null || echo "$P3_RESP")"

att wait "$SESSION_ID" --screen-stable-ms 700 --timeout-ms 8000 --json >/dev/null
snap phase3-after
P3_AFTER=$(rexpr 'v:lua.Repro277DiffWinCount()')
P3_WINS_AFTER=$(rexpr 'v:lua.Repro277State()' | jq 'length')
echo "  diff windows: $P3_BEFORE -> $P3_AFTER; total windows: $P3_WINS_BEFORE -> $P3_WINS_AFTER"

P3_OK=0
[ "$P3_BEFORE" = 2 ] && [ "$P3_AFTER" -lt 2 ] && P3_OK=1
verdict "$P3_OK" "user's native vimdiff window(s) closed (E444 spares only the last window)"

# ---------------------------------------------------------------------------
echo
echo "=== Summary: $PASS/3 defects reproduced (artifacts: $ARTIFACTS) ==="
[ -n "${ISSUE277_ARTIFACTS:-}" ] || cp -R "$ARTIFACTS" "${TMPDIR:-/tmp}/issue277-artifacts-latest" 2>/dev/null
[ "$FAIL" = 0 ] || exit 1
exit 0

Harness output — before vs. after the fix

Before the fix (PASS = bug present):

=== Phase 1: :DiffviewOpen + closeAllDiffTabs ===
  before: 2 diff windows
  closeAllDiffTabs response: "CLOSED_2_DIFF_TABS"
  after:  0 diff windows; windows: [{"name":"[No Name]"},{"name":"…/DiffviewFilePanel","filetype":"DiffviewFiles"}]
REPRODUCED: diffview side-by-side windows closed; orphaned file panel left behind

=== Phase 2: native :vertical diffsplit + openFile ===
  before: windows: [{"name":"b.lua","diff":true},{"name":"a.lua","diff":true}]
  openFile response: "Opened file: README.md"
  after:  windows: [{"name":"README.md","diff":false},{"name":"a.lua","diff":true}]
REPRODUCED: openFile hijacked one half of the user's vimdiff (b.lua window replaced; diff pair broken)

=== Phase 3: native :vertical diffsplit + closeAllDiffTabs ===
  closeAllDiffTabs response: "CLOSED_1_DIFF_TABS"
  diff windows: 2 -> 0
REPRODUCED: user's native vimdiff window(s) closed

=== Summary: 3/3 defects reproduced ===

After the fix (same harness; every phase now spares the unrelated diff):

=== Phase 1: :DiffviewOpen + closeAllDiffTabs ===
  before: 2 diff windows
  closeAllDiffTabs response: "CLOSED_0_DIFF_TABS"
  after:  2 diff windows  (diffview panes survive)
NOT REPRODUCED: diffview side-by-side windows closed; orphaned file panel left behind

=== Phase 2: native :vertical diffsplit + openFile ===
  before: windows: [{"name":"b.lua","diff":true},{"name":"a.lua","diff":true}]
  openFile response: "Opened file: README.md"
  after:  windows: [{"name":"b.lua","diff":true},{"name":"README.md","diff":false},{"name":"a.lua","diff":true}]
NOT REPRODUCED: openFile opens in a new window beside the intact vimdiff

=== Phase 3: native :vertical diffsplit + closeAllDiffTabs ===
  closeAllDiffTabs response: "CLOSED_0_DIFF_TABS"
  diff windows: 2 -> 2  (untouched)
NOT REPRODUCED: user's native vimdiff window(s) closed

=== Summary: 0/3 defects reproduced ===