/**
 * Regression: StatusLineComponent's VCS segment was blank on the first (cold)
 * paint and only appeared after an unrelated re-render (e.g. flipping a
 * statusline setting and back). The async git-status and jj-label fetches
 * filled their caches but never called #onBranchChange, so the resolved value
 * had no way to reach the screen until something else forced a repaint. Worst
 * in a jj workspace, where there is no git branch so the PR / default-branch
 * lookups (which do fire #onBranchChange) never run.
 *
 * Contract: when an async VCS fetch resolves with a value, the component
 * requests a repaint via #onBranchChange. (Post-dispose suppression of the
 * same callback is covered by status-line-dispose-async-leak.test.ts.)
 */
import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from "bun:test";
import { EventEmitter } from "node:events";
import * as nodeFs from "node:fs";
import * as fs from "node:fs/promises";
import * as os from "node:os";
import * as path from "node:path";
import { resetSettingsForTest, Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
import type { StatusLineSettings } from "@oh-my-pi/pi-coding-agent/modes/components/status-line";
import { StatusLineComponent } from "@oh-my-pi/pi-coding-agent/modes/components/status-line";
import { initTheme } from "@oh-my-pi/pi-coding-agent/modes/theme/theme";
import type { GitHeadState, GitRefHead, GitRepository } from "@oh-my-pi/pi-coding-agent/utils/git";
import * as git from "@oh-my-pi/pi-coding-agent/utils/git";
import * as jj from "@oh-my-pi/pi-coding-agent/utils/jj";
import { getProjectDir, setProjectDir } from "@oh-my-pi/pi-utils";

type GitStatus = { staged: number; unstaged: number; untracked: number };

const originalProjectDir = getProjectDir();

beforeAll(async () => {
	resetSettingsForTest();
	await Settings.init({ inMemory: true });
	await initTheme();
});

afterAll(() => {
	resetSettingsForTest();
	setProjectDir(originalProjectDir);
});

afterEach(() => {
	vi.restoreAllMocks();
});

function makeSession() {
	return {
		state: { messages: [], model: undefined },
		messages: [],
		model: undefined,
		systemPrompt: [],
		agent: { state: { tools: [] } },
		skills: [],
		isStreaming: false,
		isAutoThinking: false,
		autoResolvedThinkingLevel: () => undefined,
		isFastModeActive: () => false,
		isFastModeEnabled: () => false,
		getGoalModeState: () => null,
		getAsyncJobSnapshot: () => ({ running: [] }),
		modelRegistry: { isUsingOAuth: () => false },
		sessionManager: {
			getSessionName: () => "vcs-refresh test",
			getUsageStatistics: () => ({
				input: 0,
				output: 0,
				cacheRead: 0,
				cacheWrite: 0,
				premiumRequests: 0,
				cost: 0,
			}),
		},
	} as unknown as ConstructorParameters<typeof StatusLineComponent>[0];
}

const fakeRefHead: GitRefHead = {
	kind: "ref",
	branchName: "main",
	ref: "refs/heads/main",
	commit: null,
	commonDir: "/fake/.git",
	gitDir: "/fake/.git",
	gitEntryPath: "/fake/.git",
	headPath: "/fake/.git/HEAD",
	repoRoot: "/fake",
	headContent: "ref: refs/heads/main\n",
};

const gitSegment: StatusLineSettings = {
	preset: "custom",
	leftSegments: ["git"],
	rightSegments: ["session_name"],
	separator: "powerline-thin",
	sessionAccent: false,
	transparent: false,
};

describe("StatusLineComponent repaints when an async VCS fetch resolves", () => {
	it("fires #onBranchChange when git status resolves on the cold paint", async () => {
		vi.spyOn(git.head, "resolveSync").mockReturnValue(fakeRefHead);
		vi.spyOn(git.branch, "default").mockReturnValue(Promise.withResolvers<string | null>().promise);
		const status = Promise.withResolvers<GitStatus | null>();
		vi.spyOn(git.status, "summary").mockReturnValue(status.promise);

		const onBranchChange = vi.fn();
		const component = new StatusLineComponent(makeSession());
		component.updateSettings(gitSegment);
		component.watchBranch(onBranchChange);

		component.getTopBorder(80); // cold paint kicks off the git-status fetch
		expect(onBranchChange).not.toHaveBeenCalled();

		status.resolve({ staged: 1, unstaged: 2, untracked: 3 });
		await Promise.resolve();
		await Promise.resolve();

		expect(onBranchChange).toHaveBeenCalled();
		component.dispose();
	});

	it("fires #onBranchChange when the jj label resolves on the cold paint", async () => {
		vi.spyOn(git.head, "resolveSync").mockReturnValue(null); // no git branch -> jj overlay
		vi.spyOn(git.branch, "default").mockReturnValue(Promise.withResolvers<string | null>().promise);
		vi.spyOn(git.status, "summary").mockReturnValue(Promise.withResolvers<GitStatus | null>().promise); // isolate the jj fire
		vi.spyOn(jj.repo, "rootSync").mockReturnValue("/fake/jj/root");
		const label = Promise.withResolvers<string | null>();
		vi.spyOn(jj.workingCopy, "label").mockReturnValue(label.promise);

		const onBranchChange = vi.fn();
		const component = new StatusLineComponent(makeSession());
		component.updateSettings(gitSegment);
		component.watchBranch(onBranchChange);

		component.getTopBorder(80); // cold paint kicks off the jj-label fetch
		expect(onBranchChange).not.toHaveBeenCalled();

		label.resolve("feature-x");
		await Promise.resolve();
		await Promise.resolve();

		expect(onBranchChange).toHaveBeenCalled();
		component.dispose();
	});

	it("fires #onBranchChange when jj status resolves on the cold paint", async () => {
		vi.spyOn(git.head, "resolveSync").mockReturnValue(null); // no git -> jj repo
		vi.spyOn(git.branch, "default").mockReturnValue(Promise.withResolvers<string | null>().promise);
		vi.spyOn(git.status, "summary").mockReturnValue(Promise.withResolvers<GitStatus | null>().promise);
		vi.spyOn(jj.repo, "rootSync").mockReturnValue("/fake/jj/root");
		vi.spyOn(jj.workingCopy, "label").mockReturnValue(Promise.withResolvers<string | null>().promise); // isolate the status fire
		const status = Promise.withResolvers<GitStatus | null>();
		vi.spyOn(jj.status, "summary").mockReturnValue(status.promise);

		const onBranchChange = vi.fn();
		const component = new StatusLineComponent(makeSession());
		component.updateSettings(gitSegment);
		component.watchBranch(onBranchChange);

		component.getTopBorder(80); // cold paint kicks off the jj-status fetch
		expect(onBranchChange).not.toHaveBeenCalled();

		status.resolve({ staged: 0, unstaged: 4, untracked: 1 });
		await Promise.resolve();
		await Promise.resolve();

		expect(onBranchChange).toHaveBeenCalled();
		component.dispose();
	});
});
describe("StatusLineComponent reftable branch resolve honors mid-flight invalidation", () => {
	it("discards a stale resolve invalidated mid-flight, keeps the fresh one", async () => {
		// Force the reftable async-resolve path: #getCurrentBranch only spawns
		// git.head.resolve when the repo resolves as reftable.
		const fakeRepo = {
			commonDir: "/fake/.git",
			gitDir: "/fake/.git",
			gitEntryPath: "/fake/.git",
			headPath: "/fake/.git/HEAD",
			repoRoot: "/fake",
		} satisfies GitRepository;
		vi.spyOn(git.repo, "resolveSync").mockReturnValue(fakeRepo);
		vi.spyOn(git.repo, "isReftableSync").mockReturnValue(true);
		// Keep the sibling async fetches quiet so only the branch resolve drives
		// #onBranchChange: git.status stays in flight forever, jj is no repo here.
		vi.spyOn(git.status, "summary").mockReturnValue(Promise.withResolvers<GitStatus | null>().promise);
		vi.spyOn(jj.repo, "rootSync").mockReturnValue(null);

		const refHead = (branchName: string): GitRefHead => ({
			...fakeRefHead,
			branchName,
			ref: `refs/heads/${branchName}`,
		});

		// Two controllable resolves: the stale one (R1) then the fresh one (R2).
		const r1 = Promise.withResolvers<GitHeadState | null>();
		const r2 = Promise.withResolvers<GitHeadState | null>();
		const resolveSpy = vi.spyOn(git.head, "resolve");
		resolveSpy.mockReturnValueOnce(r1.promise);
		resolveSpy.mockReturnValueOnce(r2.promise);

		const onBranchChange = vi.fn();
		const component = new StatusLineComponent(makeSession());
		component.updateSettings(gitSegment);
		component.watchBranch(onBranchChange);

		// Cold paint kicks the stale resolve (R1).
		component.getTopBorder(80);
		expect(git.head.resolve).toHaveBeenCalledTimes(1);

		// A HEAD move fires the watcher: invalidateGitCaches bumps the
		// generation and releases the in-flight slot.
		component.invalidateGitCaches();

		// The repaint starts a fresh resolve (R2) for the same cwd.
		component.getTopBorder(80);
		expect(git.head.resolve).toHaveBeenCalledTimes(2);

		// R1 (stale) lands first. Pre-fix it passed the in-flight-cwd guard
		// (R2 had re-set the slot), installed the stale branch, cleared the
		// marker, and caused R2 to be discarded — freezing the status line on
		// the pre-change branch.
		r1.resolve(refHead("stale-branch"));
		await Promise.resolve();
		await Promise.resolve();
		expect(onBranchChange).not.toHaveBeenCalled();

		// R2 (fresh) lands and commits.
		r2.resolve(refHead("fresh-branch"));
		await Promise.resolve();
		await Promise.resolve();
		expect(onBranchChange).toHaveBeenCalledTimes(1);

		// The committed value is the fresh branch, served from cache with no new
		// resolve, and the stale name never reaches the rendered segment.
		expect(git.head.resolve).toHaveBeenCalledTimes(2);
		const border = component.getTopBorder(80);
		expect(border.content).toContain("fresh-branch");
		expect(border.content).not.toContain("stale-branch");
		expect(git.head.resolve).toHaveBeenCalledTimes(2);

		component.dispose();
	});

	it("aborts an invalidated resolve and starts only one replacement resolve", async () => {
		const fakeRepo = {
			commonDir: "/fake/.git",
			gitDir: "/fake/.git",
			gitEntryPath: "/fake/.git",
			headPath: "/fake/.git/HEAD",
			repoRoot: "/fake",
		} satisfies GitRepository;
		vi.spyOn(git.repo, "resolveSync").mockReturnValue(fakeRepo);
		vi.spyOn(git.repo, "isReftableSync").mockReturnValue(true);
		vi.spyOn(git.status, "summary").mockReturnValue(Promise.withResolvers<GitStatus | null>().promise);
		vi.spyOn(jj.repo, "rootSync").mockReturnValue(null);

		const signals: AbortSignal[] = [];
		vi.spyOn(git.head, "resolve").mockImplementation((_cwd, signal) => {
			if (!signal) throw new Error("reftable resolve must receive an abort signal");
			signals.push(signal);
			const { promise, reject } = Promise.withResolvers<GitHeadState | null>();
			signal.addEventListener("abort", () => reject(signal.reason), { once: true });
			return promise;
		});

		const component = new StatusLineComponent(makeSession());
		component.updateSettings(gitSegment);
		component.getTopBorder(80);
		expect(git.head.resolve).toHaveBeenCalledTimes(1);

		component.invalidateGitCaches();
		expect(signals[0]?.aborted).toBe(true);
		component.invalidateGitCaches();
		component.getTopBorder(80);
		component.getTopBorder(80);
		expect(git.head.resolve).toHaveBeenCalledTimes(2);

		component.dispose();
		expect(signals[1]?.aborted).toBe(true);
		await Promise.resolve();
	});

	it("generic invalidate does not abort or restart a live reftable HEAD resolve", async () => {
		const fakeRepo = {
			commonDir: "/fake/.git",
			gitDir: "/fake/.git",
			gitEntryPath: "/fake/.git",
			headPath: "/fake/.git/HEAD",
			repoRoot: "/fake",
		} satisfies GitRepository;
		vi.spyOn(git.repo, "resolveSync").mockReturnValue(fakeRepo);
		vi.spyOn(git.repo, "isReftableSync").mockReturnValue(true);
		vi.spyOn(git.status, "summary").mockReturnValue(Promise.withResolvers<GitStatus | null>().promise);
		vi.spyOn(jj.repo, "rootSync").mockReturnValue(null);
		vi.spyOn(nodeFs, "watch").mockImplementation(() => {
			throw new Error("watch unavailable");
		});

		const signals: AbortSignal[] = [];
		const { promise, reject } = Promise.withResolvers<GitHeadState | null>();
		vi.spyOn(git.head, "resolve").mockImplementation((_cwd, signal) => {
			if (!signal) throw new Error("reftable resolve must receive an abort signal");
			signals.push(signal);
			signal.addEventListener("abort", () => reject(signal.reason), { once: true });
			return promise;
		});

		const component = new StatusLineComponent(makeSession());
		component.updateSettings(gitSegment);
		component.watchBranch(vi.fn());
		component.getTopBorder(80);
		expect(git.head.resolve).toHaveBeenCalledTimes(1);

		// Many generic invalidations (message events, model switches, theme
		// changes, …) must not abort the live resolve or fan out replacement
		// git subprocesses — the render path self-invalidates via cwd/context
		// cache-miss checks, so a generic paint only re-renders.
		for (let i = 0; i < 10; i++) {
			component.invalidate();
		}
		component.getTopBorder(80);
		component.getTopBorder(80);

		expect(signals[0]?.aborted).toBe(false);
		expect(git.head.resolve).toHaveBeenCalledTimes(1);

		// Disposal still aborts the in-flight resolve.
		component.dispose();
		expect(signals[0]?.aborted).toBe(true);
		await Promise.resolve();
	});

	it("polls a reftable branch after HEAD watcher installation fails", async () => {
		const fakeRepo = {
			commonDir: "/fake/.git",
			gitDir: "/fake/.git",
			gitEntryPath: "/fake/.git",
			headPath: "/fake/.git/HEAD",
			repoRoot: "/fake",
		} satisfies GitRepository;
		vi.spyOn(git.repo, "resolveSync").mockReturnValue(fakeRepo);
		vi.spyOn(git.repo, "isReftableSync").mockReturnValue(true);
		vi.spyOn(git.status, "summary").mockReturnValue(Promise.withResolvers<GitStatus | null>().promise);
		vi.spyOn(jj.repo, "rootSync").mockReturnValue(null);
		vi.spyOn(nodeFs, "watch").mockImplementation(() => {
			throw new Error("watch unavailable");
		});
		let now = 1_000_000;
		vi.spyOn(Date, "now").mockImplementation(() => now);
		vi.spyOn(git.head, "resolve")
			.mockResolvedValueOnce({ ...fakeRefHead, branchName: "before-change", ref: "refs/heads/before-change" })
			.mockResolvedValueOnce({ ...fakeRefHead, branchName: "after-change", ref: "refs/heads/after-change" });

		const component = new StatusLineComponent(makeSession());
		component.updateSettings(gitSegment);
		component.watchBranch(vi.fn());
		component.getTopBorder(80);
		await Promise.resolve();
		await Promise.resolve();
		expect(component.getTopBorder(80).content).toContain("before-change");
		expect(git.head.resolve).toHaveBeenCalledTimes(1);

		// No filesystem event arrives, but the next bounded poll observes the new HEAD.
		now += 5_001;
		component.getTopBorder(80);
		expect(git.head.resolve).toHaveBeenCalledTimes(2);
		await Promise.resolve();
		await Promise.resolve();
		expect(component.getTopBorder(80).content).toContain("after-change");
		component.dispose();
	});

	it("does not query an ancestor jj workspace while nested Git HEAD resolution is pending", async () => {
		const jjRootDir = await fs.mkdtemp(path.join(os.tmpdir(), "status-line-jj-root-"));
		const nestedGitCwd = path.join(jjRootDir, "nested-ordinary-git");
		await fs.mkdir(nestedGitCwd);
		const fakeRepo = {
			commonDir: `${nestedGitCwd}/.git`,
			gitDir: `${nestedGitCwd}/.git`,
			gitEntryPath: `${nestedGitCwd}/.git`,
			headPath: `${nestedGitCwd}/.git/HEAD`,
			repoRoot: nestedGitCwd,
		} satisfies GitRepository;
		vi.spyOn(git.repo, "resolveSync").mockReturnValue(fakeRepo);
		vi.spyOn(git.repo, "isReftableSync").mockReturnValue(true);
		vi.spyOn(git.head, "resolve").mockReturnValue(Promise.withResolvers<GitHeadState | null>().promise);
		vi.spyOn(git.status, "summary").mockReturnValue(Promise.withResolvers<GitStatus | null>().promise);
		const jjRoot = vi.spyOn(jj.repo, "rootSync").mockReturnValue("/workspace/jj-root");
		const jjLabel = vi.spyOn(jj.workingCopy, "label").mockReturnValue(Promise.resolve("ancestor-bookmark"));
		const jjStatus = vi
			.spyOn(jj.status, "summary")
			.mockReturnValue(Promise.resolve({ staged: 0, unstaged: 0, untracked: 0 }));
		setProjectDir(nestedGitCwd);

		try {
			const component = new StatusLineComponent(makeSession());
			component.updateSettings(gitSegment);
			component.getTopBorder(80);
			expect(git.head.resolve).toHaveBeenCalledTimes(1);
			expect(jjRoot).not.toHaveBeenCalled();
			expect(jjLabel).not.toHaveBeenCalled();
			expect(jjStatus).not.toHaveBeenCalled();
			component.dispose();
		} finally {
			setProjectDir(originalProjectDir);
			await fs.rm(jjRootDir, { recursive: true, force: true });
		}
	});

	it("does not query an ancestor jj workspace after nested Git HEAD resolution fails", async () => {
		const fakeRepo = {
			commonDir: "/nested/.git",
			gitDir: "/nested/.git",
			gitEntryPath: "/nested/.git",
			headPath: "/nested/.git/HEAD",
			repoRoot: "/nested",
		} satisfies GitRepository;
		vi.spyOn(git.repo, "resolveSync").mockReturnValue(fakeRepo);
		vi.spyOn(git.repo, "isReftableSync").mockReturnValue(true);
		vi.spyOn(git.head, "resolve").mockResolvedValue(null);
		vi.spyOn(git.status, "summary").mockReturnValue(Promise.withResolvers<GitStatus | null>().promise);
		const jjRoot = vi.spyOn(jj.repo, "rootSync").mockReturnValue("/workspace/jj-root");

		const component = new StatusLineComponent(makeSession());
		component.updateSettings(gitSegment);
		component.getTopBorder(80);
		await Promise.resolve();
		await Promise.resolve();
		component.getTopBorder(80);

		expect(git.head.resolve).toHaveBeenCalledTimes(1);
		expect(jjRoot).not.toHaveBeenCalled();
		component.dispose();
	});
});

describe("StatusLineComponent VCS watcher and jj request lifecycle", () => {
	const fakeRepo = {
		commonDir: "/fake/.git",
		gitDir: "/fake/.git",
		gitEntryPath: "/fake/.git",
		headPath: "/fake/.git/HEAD",
		repoRoot: "/fake",
	} satisfies GitRepository;

	it("retires an asynchronously failed watcher without an unhandled EventEmitter error", () => {
		const firstWatcher = Object.assign(new EventEmitter(), { close: vi.fn() }) as unknown as nodeFs.FSWatcher;
		const failedWatcher = Object.assign(new EventEmitter(), { close: vi.fn() }) as unknown as nodeFs.FSWatcher;
		const disposedWatcher = Object.assign(new EventEmitter(), { close: vi.fn() }) as unknown as nodeFs.FSWatcher;
		vi.spyOn(git.repo, "resolveSync").mockReturnValue(fakeRepo);
		vi.spyOn(git.repo, "isReftableSync").mockReturnValue(false);
		vi.spyOn(git.head, "resolveSync")
			.mockReturnValueOnce({ ...fakeRefHead, branchName: "before-error", ref: "refs/heads/before-error" })
			.mockReturnValueOnce({ ...fakeRefHead, branchName: "after-error", ref: "refs/heads/after-error" });
		vi.spyOn(git.branch, "default").mockReturnValue(Promise.withResolvers<string | null>().promise);
		vi.spyOn(git.status, "summary").mockReturnValue(Promise.withResolvers<GitStatus | null>().promise);
		vi.spyOn(jj.repo, "rootSync").mockReturnValue(null);
		vi.spyOn(nodeFs, "watch")
			.mockReturnValueOnce(firstWatcher)
			.mockReturnValueOnce(failedWatcher)
			.mockReturnValueOnce(disposedWatcher);

		const onBranchChange = vi.fn();
		const component = new StatusLineComponent(makeSession());
		component.updateSettings(gitSegment);
		component.watchBranch(onBranchChange);
		component.getTopBorder(80);
		expect(firstWatcher.listenerCount("error")).toBe(1);

		// Replacement detaches the first listener before closing that watcher.
		component.updateSettings(gitSegment);
		expect(firstWatcher.listenerCount("error")).toBe(0);
		expect(firstWatcher.close).toHaveBeenCalledTimes(1);
		expect(failedWatcher.listenerCount("error")).toBe(1);

		// `error` without a listener throws synchronously. The component must own
		// the event, retire the watcher, and request the repaint that observes the
		// invalidated VCS cache.
		expect(() => failedWatcher.emit("error", new Error("watch failed"))).not.toThrow();
		expect(failedWatcher.listenerCount("error")).toBe(0);
		expect(failedWatcher.close).toHaveBeenCalledTimes(1);
		expect(onBranchChange).toHaveBeenCalledTimes(1);
		expect(component.getTopBorder(80).content).toContain("after-error");

		component.updateSettings(gitSegment);
		expect(disposedWatcher.listenerCount("error")).toBe(1);
		component.dispose();
		expect(disposedWatcher.listenerCount("error")).toBe(0);
		expect(disposedWatcher.close).toHaveBeenCalledTimes(1);
	});

	it("discovers a repository created after setup with bounded single-flight polling", async () => {
		let now = 1_000_000;
		const repositoryCreatedAt = now + 5_000;
		vi.spyOn(Date, "now").mockImplementation(() => now);
		vi.spyOn(git.repo, "resolveSync").mockImplementation(() => (now >= repositoryCreatedAt ? fakeRepo : null));
		vi.spyOn(git.repo, "isReftableSync").mockReturnValue(true);
		vi.spyOn(git.status, "summary").mockReturnValue(Promise.withResolvers<GitStatus | null>().promise);
		vi.spyOn(jj.repo, "rootSync").mockReturnValue(null);
		const head = Promise.withResolvers<GitHeadState | null>();
		vi.spyOn(git.head, "resolve").mockReturnValue(head.promise);

		const component = new StatusLineComponent(makeSession());
		component.updateSettings(gitSegment);
		component.watchBranch(vi.fn());
		component.getTopBorder(80);
		expect(git.head.resolve).not.toHaveBeenCalled();

		now += 1_000;
		component.getTopBorder(80);
		expect(git.head.resolve).not.toHaveBeenCalled();

		// The bounded discovery interval reaches the new repository. Repeated
		// paints while its reftable resolve is hung must reuse the one request.
		now += 4_001;
		component.getTopBorder(80);
		component.getTopBorder(80);
		expect(git.head.resolve).toHaveBeenCalledTimes(1);

		head.resolve({ ...fakeRefHead, branchName: "created-later", ref: "refs/heads/created-later" });
		await Promise.resolve();
		await Promise.resolve();
		expect(component.getTopBorder(80).content).toContain("created-later");
		component.dispose();
	});

	it("aborts superseded jj branch and status queries without blocking their replacements", async () => {
		vi.spyOn(git.head, "resolveSync").mockReturnValue(null);
		vi.spyOn(git.branch, "default").mockReturnValue(Promise.withResolvers<string | null>().promise);
		vi.spyOn(git.status, "summary").mockReturnValue(Promise.withResolvers<GitStatus | null>().promise);
		vi.spyOn(jj.repo, "rootSync").mockReturnValue("/fake/jj/root");

		const labelRequests: Array<{ signal: AbortSignal; resolve: (value: string | null) => void }> = [];
		vi.spyOn(jj.workingCopy, "label").mockImplementation((_root, options) => {
			if (!options?.signal || options.timeoutMs !== jj.JJ_COMMAND_TIMEOUT_MS) {
				throw new Error("jj label requires the central bounded options");
			}
			const request = Promise.withResolvers<string | null>();
			options.signal.addEventListener("abort", () => request.resolve(null), { once: true });
			labelRequests.push({ signal: options.signal, resolve: request.resolve });
			return request.promise;
		});
		const statusRequests: Array<{ signal: AbortSignal; resolve: (value: GitStatus | null) => void }> = [];
		vi.spyOn(jj.status, "summary").mockImplementation((_root, options) => {
			if (!options?.signal || options.timeoutMs !== jj.JJ_COMMAND_TIMEOUT_MS) {
				throw new Error("jj status requires the central bounded options");
			}
			const request = Promise.withResolvers<GitStatus | null>();
			options.signal.addEventListener("abort", () => request.resolve(null), { once: true });
			statusRequests.push({ signal: options.signal, resolve: request.resolve });
			return request.promise;
		});

		const component = new StatusLineComponent(makeSession());
		component.updateSettings(gitSegment);
		component.getTopBorder(80);
		expect(labelRequests).toHaveLength(1);
		expect(statusRequests).toHaveLength(1);

		component.invalidateGitCaches();
		expect(labelRequests[0]?.signal.aborted).toBe(true);
		expect(statusRequests[0]?.signal.aborted).toBe(true);
		component.getTopBorder(80);
		expect(labelRequests).toHaveLength(2);
		expect(statusRequests).toHaveLength(2);

		labelRequests[1]?.resolve("fresh-bookmark");
		statusRequests[1]?.resolve({ staged: 0, unstaged: 1, untracked: 0 });
		await Promise.resolve();
		await Promise.resolve();
		expect(component.getTopBorder(80).content).toContain("fresh-bookmark");

		component.invalidateGitCaches();
		component.getTopBorder(80);
		expect(labelRequests).toHaveLength(3);
		expect(statusRequests).toHaveLength(3);
		component.dispose();
		expect(labelRequests[2]?.signal.aborted).toBe(true);
		expect(statusRequests[2]?.signal.aborted).toBe(true);
		await Promise.resolve();
	});
});

describe("StatusLineComponent applyCwdChange re-points watcher ownership", () => {
	let dirA: string;
	let dirB: string;
	let dirNoRepo: string;
	let repoA: GitRepository;
	let repoB: GitRepository;

	beforeAll(async () => {
		dirA = await fs.mkdtemp(path.join(os.tmpdir(), "status-line-repoA-"));
		dirB = await fs.mkdtemp(path.join(os.tmpdir(), "status-line-repoB-"));
		dirNoRepo = await fs.mkdtemp(path.join(os.tmpdir(), "status-line-norepo-"));
		repoA = {
			commonDir: path.join(dirA, ".git"),
			gitDir: path.join(dirA, ".git"),
			gitEntryPath: path.join(dirA, ".git"),
			headPath: path.join(dirA, ".git", "HEAD"),
			repoRoot: dirA,
		};
		repoB = {
			commonDir: path.join(dirB, ".git"),
			gitDir: path.join(dirB, ".git"),
			gitEntryPath: path.join(dirB, ".git"),
			headPath: path.join(dirB, ".git", "HEAD"),
			repoRoot: dirB,
		};
	});

	afterAll(async () => {
		setProjectDir(originalProjectDir);
		await Promise.all([
			fs.rm(dirA, { recursive: true, force: true }),
			fs.rm(dirB, { recursive: true, force: true }),
			fs.rm(dirNoRepo, { recursive: true, force: true }),
		]);
	});

	// Test double for node:fs.FSWatcher — extends EventEmitter with just the
	// `close` method the component calls. FSWatcher has dozens of members we
	// never exercise, so a structural implementation would be pure ceremony.
	function createFakeWatcher(): nodeFs.FSWatcher {
		return Object.assign(new EventEmitter(), { close: vi.fn() }) as unknown as nodeFs.FSWatcher;
	}

	it("retires the old watcher and re-points at the new repo on cwd change", () => {
		const watcherA = createFakeWatcher();
		const watcherB = createFakeWatcher();

		vi.spyOn(git.repo, "isReftableSync").mockReturnValue(false);
		vi.spyOn(git.repo, "linkedWorktreeSync").mockReturnValue(null);
		vi.spyOn(git.repo, "resolveSync").mockImplementation((cwd: string) => {
			if (cwd === dirA) return repoA;
			if (cwd === dirB) return repoB;
			return null;
		});
		vi.spyOn(git.head, "resolveSync").mockImplementation((cwd: string) => {
			if (cwd === dirA) return { ...fakeRefHead, branchName: "branch-a", ref: "refs/heads/branch-a" };
			if (cwd === dirB) return { ...fakeRefHead, branchName: "branch-b", ref: "refs/heads/branch-b" };
			return null;
		});
		vi.spyOn(git.branch, "default").mockReturnValue(Promise.withResolvers<string | null>().promise);
		vi.spyOn(git.status, "summary").mockReturnValue(Promise.withResolvers<GitStatus | null>().promise);
		vi.spyOn(jj.repo, "rootSync").mockReturnValue(null);
		const watchSpy = vi.spyOn(nodeFs, "watch").mockReturnValueOnce(watcherA).mockReturnValueOnce(watcherB);

		const onBranchChange = vi.fn();
		setProjectDir(dirA);
		const component = new StatusLineComponent(makeSession());
		component.updateSettings(gitSegment);
		component.watchBranch(onBranchChange);
		expect(component.getTopBorder(80).content).toContain("branch-a");

		// Move cwd to repo B — the SessionManager's cwd has already moved.
		setProjectDir(dirB);
		component.applyCwdChange();
		// applyCwdChange itself requests one repaint; clear it so subsequent
		// calls are attributable solely to watcher events.
		onBranchChange.mockClear();

		// Old watcher is retired: closed and its error listener detached.
		expect(watcherA.close).toHaveBeenCalledTimes(1);
		expect(watcherA.listenerCount("error")).toBe(0);
		// New watcher is live with an error listener attached.
		expect(watcherB.listenerCount("error")).toBe(1);

		// fs.watch is mocked to return EventEmitters without registering the
		// change callback, so extract it from the call args and attach it.
		const aCallArgs = watchSpy.mock.calls[0];
		const bCallArgs = watchSpy.mock.calls[1];
		const aListener = aCallArgs?.[1];
		const bListener = bCallArgs?.[1];
		expect(typeof aListener).toBe("function");
		expect(typeof bListener).toBe("function");
		if (typeof aListener === "function") watcherA.on("change", aListener as () => void);
		if (typeof bListener === "function") watcherB.on("change", bListener as () => void);

		// Stale change event from repo A's retired watcher must not invalidate
		// B's caches or request a repaint — the ownership guard rejects it.
		watcherA.emit("change");
		expect(onBranchChange).not.toHaveBeenCalled();

		// Fresh change event from repo B's watcher refreshes B.
		onBranchChange.mockClear();
		watcherB.emit("change");
		expect(onBranchChange).toHaveBeenCalledTimes(1);
		expect(component.getTopBorder(80).content).toContain("branch-b");

		// No watcher leak: dispose closes B, not A (A was already closed).
		component.dispose();
		expect(watcherB.close).toHaveBeenCalledTimes(1);
		expect(watcherB.listenerCount("error")).toBe(0);
		expect(watcherA.close).toHaveBeenCalledTimes(1);
	});

	it("falls back to bounded polling when the new cwd has no repository", () => {
		const watcherA = createFakeWatcher();

		vi.spyOn(git.repo, "isReftableSync").mockReturnValue(false);
		vi.spyOn(git.repo, "linkedWorktreeSync").mockReturnValue(null);
		vi.spyOn(git.repo, "resolveSync").mockImplementation((cwd: string) => {
			if (cwd === dirA) return repoA;
			return null;
		});
		vi.spyOn(git.head, "resolveSync").mockImplementation((cwd: string) => {
			if (cwd === dirA) return { ...fakeRefHead, branchName: "branch-a", ref: "refs/heads/branch-a" };
			return null;
		});
		vi.spyOn(git.branch, "default").mockReturnValue(Promise.withResolvers<string | null>().promise);
		vi.spyOn(git.status, "summary").mockReturnValue(Promise.withResolvers<GitStatus | null>().promise);
		vi.spyOn(jj.repo, "rootSync").mockReturnValue(null);
		vi.spyOn(nodeFs, "watch").mockReturnValueOnce(watcherA);

		const onBranchChange = vi.fn();
		setProjectDir(dirA);
		const component = new StatusLineComponent(makeSession());
		component.updateSettings(gitSegment);
		component.watchBranch(onBranchChange);
		component.getTopBorder(80);

		// Move to a directory with no git repo — watcher unavailable fallback.
		setProjectDir(dirNoRepo);
		onBranchChange.mockClear();
		component.applyCwdChange();

		// Old watcher retired; no new watcher created (fs.watch not called again).
		expect(watcherA.close).toHaveBeenCalledTimes(1);
		expect(nodeFs.watch).toHaveBeenCalledTimes(1);
		// applyCwdChange still requests a repaint so the stale segment clears.
		expect(onBranchChange).toHaveBeenCalledTimes(1);

		// Rendering does not crash and the git segment is blank for no-repo.
		const border = component.getTopBorder(80);
		expect(border).toBeDefined();
		expect(border.content).not.toContain("branch-a");

		component.dispose();
	});
});