@oh-my-pi/pi-coding-agent 17.0.9 → 17.1.0

package/src/modes/components/settings-selector.ts

@@ -221,6 +221,131 @@ class SelectSubmenu extends Container {
 	}
 }
 
+/**
+ * Submenu for array-of-enum settings: every option is a toggle row. Enter or
+ * Space flips membership; ordered lists render 1-based positions and reorder
+ * the highlighted member with ←/→. Changes apply live; Esc goes back.
+ */
+class MultiSelectSubmenu extends Container {
+	#selectList!: SelectList;
+	#value: string[];
+	#cursor = 0;
+	#selectListLineOffset = 0;
+
+	constructor(
+		private readonly title: string,
+		private readonly description: string,
+		private readonly options: ReadonlyArray<SelectItem>,
+		initial: readonly string[],
+		private readonly ordered: boolean,
+		private readonly onApply: (value: string[]) => void,
+		private readonly onClose: () => void,
+	) {
+		super();
+		// Drop stale ids (renamed/removed providers) so positions stay contiguous.
+		this.#value = initial.filter(id => options.some(option => option.value === id));
+		this.#rebuild();
+	}
+
+	#rebuild(): void {
+		this.clear();
+		this.addChild(new Text(theme.bold(theme.fg("accent", this.title)), 0, 0));
+		if (this.description) {
+			this.addChild(new Spacer(1));
+			this.addChild(new Text(theme.fg("muted", this.description), 0, 0));
+		}
+		this.addChild(new Spacer(1));
+
+		const items = this.options.map((option): SelectItem => {
+			const position = this.#value.indexOf(option.value);
+			const mark =
+				position === -1
+					? theme.fg("dim", this.ordered ? " · " : " ○ ")
+					: this.ordered
+						? theme.fg("accent", `${String(position + 1).padStart(2)}.`)
+						: theme.fg("accent", " ● ");
+			return { value: option.value, label: `${mark} ${option.label}`, description: option.description };
+		});
+		this.#selectList = new SelectList(items, Math.min(items.length, 12), getSelectListTheme());
+		this.#selectList.setSelectedIndex(this.#cursor);
+		this.#selectList.onSelect = item => this.#toggle(item.value);
+		this.#selectList.onSelectionChange = item => {
+			this.#cursor = this.options.findIndex(option => option.value === item.value);
+		};
+		this.#selectList.onCancel = this.onClose;
+		this.addChild(this.#selectList);
+
+		this.addChild(new Spacer(1));
+		const hint = this.ordered
+			? "  Enter/Space to toggle · ←/→ move · 1-9 place at position · Esc to go back"
+			: "  Enter/Space to toggle · Esc to go back";
+		this.addChild(new Text(theme.fg("dim", hint), 0, 0));
+	}
+
+	#apply(next: string[]): void {
+		this.#value = next;
+		this.onApply([...next]);
+		this.#rebuild();
+	}
+
+	#toggle(id: string): void {
+		const next = this.#value.includes(id) ? this.#value.filter(v => v !== id) : [...this.#value, id];
+		this.#apply(next);
+	}
+
+	#move(id: string, delta: -1 | 1): void {
+		const from = this.#value.indexOf(id);
+		if (from === -1) return;
+		const to = from + delta;
+		if (to < 0 || to >= this.#value.length) return;
+		const next = [...this.#value];
+		next[from] = next[to]!;
+		next[to] = id;
+		this.#apply(next);
+	}
+
+	/** Splice the option into the 1-based `position` of the selection (adding it if unselected). */
+	#placeAt(id: string, position: number): void {
+		const next = this.#value.filter(v => v !== id);
+		next.splice(Math.min(position - 1, next.length), 0, id);
+		this.#apply(next);
+	}
+
+	/** Concatenate children, recording the select list's line offset for mouse routing. */
+	override render(width: number): readonly string[] {
+		const lines: string[] = [];
+		for (const child of this.children) {
+			const childLines = child.render(Math.max(1, width));
+			if (child === this.#selectList) {
+				this.#selectListLineOffset = lines.length;
+			}
+			lines.push(...childLines);
+		}
+		return lines;
+	}
+
+	routeMouse(event: SgrMouseEvent, line: number, _col: number): void {
+		routeSelectListMouse(this.#selectList, event, line - this.#selectListLineOffset);
+	}
+
+	handleInput(data: string): void {
+		const current = this.options[this.#cursor]?.value;
+		if (data === " " && current !== undefined) {
+			this.#toggle(current);
+			return;
+		}
+		if (this.ordered && current !== undefined && (data === "\x1b[D" || data === "\x1b[C")) {
+			this.#move(current, data === "\x1b[D" ? -1 : 1);
+			return;
+		}
+		if (this.ordered && current !== undefined && data.length === 1 && data >= "1" && data <= "9") {
+			this.#placeAt(current, Number(data));
+			return;
+		}
+		this.#selectList.handleInput(data);
+	}
+}
+
 class ProviderLimitsSubmenu extends Container {
 	#selectList: SelectList | undefined;
 
@@ -854,6 +979,16 @@ export class SettingsSelectorComponent implements Component {
 					submenu: (_cv, done) => this.#createProviderLimitsInput(done),
 					changed,
 				};
+
+			case "multiselect":
+				return {
+					id: def.path,
+					label: def.label,
+					description: def.description,
+					currentValue: this.#formatMultiSelectValue(def, currentValue),
+					submenu: (_cv, done) => this.#createMultiSelect(def, done),
+					changed,
+				};
 		}
 	}
 
@@ -865,7 +1000,14 @@ export class SettingsSelectorComponent implements Component {
 	}
 
 	#isChanged(def: SettingDef, currentValue: unknown): boolean {
-		return !Object.is(currentValue, getDefault(def.path));
+		const defaultValue: unknown = getDefault(def.path);
+		if (Array.isArray(currentValue) && Array.isArray(defaultValue)) {
+			return (
+				currentValue.length !== defaultValue.length ||
+				currentValue.some((entry, index) => entry !== defaultValue[index])
+			);
+		}
+		return !Object.is(currentValue, defaultValue);
 	}
 
 	#getSubmenuCurrentValue(path: SettingPath, value: unknown): string {
@@ -1026,6 +1168,32 @@ export class SettingsSelectorComponent implements Component {
 		return entries.map(([provider, limit]) => `${provider}: ${limit}`).join(", ");
 	}
 
+	#createMultiSelect(def: SettingDef & { type: "multiselect" }, done: (value?: string) => void): Container {
+		const current: unknown = settings.get(def.path);
+		const initial = Array.isArray(current)
+			? current.filter((entry): entry is string => typeof entry === "string")
+			: [];
+		return new MultiSelectSubmenu(
+			def.label,
+			def.description,
+			def.options,
+			initial,
+			def.ordered,
+			value => {
+				settings.set(def.path, value as never);
+				this.callbacks.onChange(def.path, value);
+			},
+			() => done(this.#formatMultiSelectValue(def, settings.get(def.path))),
+		);
+	}
+
+	#formatMultiSelectValue(def: SettingDef & { type: "multiselect" }, value: unknown): string {
+		const ids = Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === "string") : [];
+		if (ids.length === 0) return def.ordered ? "default" : "none";
+		const labels = ids.map(id => def.options.find(option => option.value === id)?.label ?? id);
+		return def.ordered ? labels.join(" → ") : labels.join(", ");
+	}
+
 	#formatTextInputValue(def: SettingDef & { type: "text" }, value: unknown): string {
 		if (def.secret) return value ? "••••••••" : "";
 		return this.#formatTextInputEditValue(def.path, value);

package/src/modes/components/status-line/component.jj-cache.test.ts

@@ -0,0 +1,229 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, spyOn } from "bun:test";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { getProjectDir, setProjectDir } from "@oh-my-pi/pi-utils";
+import { Settings, settings } from "../../../config/settings";
+import type { AgentSession } from "../../../session/agent-session";
+import * as git from "../../../utils/git";
+import * as jj from "../../../utils/jj";
+import { getThemeByName, setThemeInstance } from "../../theme/theme";
+import { StatusLineComponent } from "./component";
+
+// Minimal session the git-only status line render path touches: state.messages
+// (token-rate scan), model window, streaming flag, and the async-job snapshot.
+// The `git` segment reads none of these — they only keep #buildStatusLine from
+// throwing while it renders the single segment under test.
+function makeSession(): AgentSession {
+	const model = { contextWindow: 128000 } as const;
+	return {
+		state: { messages: [], model },
+		messages: [],
+		model,
+		isStreaming: false,
+		sessionFile: undefined,
+		getAsyncJobSnapshot: () => null,
+		getContextUsage: () => ({ tokens: 0, contextWindow: 128000 }),
+	} as unknown as AgentSession;
+}
+
+// Drain the microtask queue so the fire-and-forget async jj lookups started by a
+// render() have applied their result to the cache. No real timers: only
+// already-resolved promises are awaited, so this stays deterministic.
+async function flushMicrotasks(): Promise<void> {
+	for (let i = 0; i < 8; i++) await Promise.resolve();
+}
+
+// Strip SGR/OSC escapes so assertions match on the visible branch label text.
+function visible(s: string): string {
+	return s.replace(/\x1b\][^\x07]*\x07/g, "").replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+const WIDTH = 200;
+
+let spies: Array<{ mockRestore(): void }> = [];
+let tmpA: string;
+let tmpB: string;
+let originalProjectDir: string;
+const ROOT_A = "/virtual/jj-root-a";
+const ROOT_B = "/virtual/jj-root-b";
+
+beforeAll(async () => {
+	await Settings.init({ inMemory: true });
+	const loaded = await getThemeByName("dark");
+	if (!loaded) throw new Error("theme unavailable");
+	setThemeInstance(loaded);
+	// Render only the git segment: shrinks the render surface to the code under
+	// test and keeps the fake session tiny. Constructor snapshots these, so they
+	// must be set before any `new StatusLineComponent`.
+	settings.override("statusLine.preset", "custom");
+	settings.override("statusLine.leftSegments", ["git"]);
+	settings.override("statusLine.rightSegments", []);
+	originalProjectDir = getProjectDir();
+	tmpA = fs.mkdtempSync(path.join(os.tmpdir(), "jjcache-a-"));
+	tmpB = fs.mkdtempSync(path.join(os.tmpdir(), "jjcache-b-"));
+});
+
+afterAll(() => {
+	settings.clearOverride("statusLine.preset");
+	settings.clearOverride("statusLine.leftSegments");
+	settings.clearOverride("statusLine.rightSegments");
+	setProjectDir(originalProjectDir);
+	fs.rmSync(tmpA, { recursive: true, force: true });
+	fs.rmSync(tmpB, { recursive: true, force: true });
+});
+
+beforeEach(() => {
+	// Force the jj fallback branch in #buildSegmentContext: git HEAD resolves to
+	// null (so gitBranch === null triggers #getJjBranch), and no repo/worktree is
+	// detected (so effectiveGitCwd stays the raw project dir we control).
+	spies = [
+		spyOn(git.head, "resolveSync").mockReturnValue(null),
+		spyOn(git.repo, "resolveSync").mockReturnValue(null),
+		spyOn(git.repo, "linkedWorktreeSync").mockReturnValue(null),
+		// jj status: return a clean summary so #getJjStatus never falls through to
+		// the real `git status` subprocess. Keeps the git segment's status empty so
+		// the visible content is exactly the branch label.
+		spyOn(jj.status, "summary").mockResolvedValue({ staged: 0, unstaged: 0, untracked: 0 }),
+		// Map each controlled project dir to a stable virtual jj root.
+		spyOn(jj.repo, "rootSync").mockImplementation(cwd => {
+			if (cwd === tmpA) return ROOT_A;
+			if (cwd === tmpB) return ROOT_B;
+			return null;
+		}),
+	];
+	setProjectDir(tmpA);
+});
+
+afterEach(() => {
+	for (const s of spies) s.mockRestore();
+	spies = [];
+});
+
+describe("StatusLineComponent jj cache coherence", () => {
+	it("invalidate() drops the throttled jj branch cache within its TTL and refetches", async () => {
+		// A live jj bookmark label; a second query for the SAME root returns a new
+		// label, simulating a colocated bookmark/HEAD move mid-TTL.
+		const branchSpy = spyOn(jj.workingCopy, "label").mockResolvedValue("bookmark-v1");
+		spies.push(branchSpy);
+
+		const statusLine = new StatusLineComponent(makeSession());
+
+		// First render kicks off the async lookup (returns the empty cache); after
+		// it resolves, a second render paints the fetched label.
+		statusLine.getTopBorder(WIDTH);
+		await flushMicrotasks();
+		expect(visible(statusLine.getTopBorder(WIDTH).content)).toContain("bookmark-v1");
+		expect(branchSpy).toHaveBeenCalledTimes(1);
+
+		// Move the bookmark: a plain render within the 5s TTL must keep serving the
+		// cached label without a refetch (guards that the TTL is real, so the next
+		// assertion proves invalidate() — not TTL expiry — forces the refresh).
+		branchSpy.mockResolvedValue("bookmark-v2");
+		const throttled = visible(statusLine.getTopBorder(WIDTH).content);
+		await flushMicrotasks();
+		expect(throttled).toContain("bookmark-v1");
+		expect(branchSpy).toHaveBeenCalledTimes(1);
+
+		// invalidate() (public watcher trigger) must reset the jj caches so the
+		// next render refetches despite being inside the TTL, and paint the new
+		// label — the finding-1 contract.
+		statusLine.invalidate();
+		statusLine.getTopBorder(WIDTH);
+		await flushMicrotasks();
+		expect(branchSpy).toHaveBeenCalledTimes(2);
+		expect(visible(statusLine.getTopBorder(WIDTH).content)).toContain("bookmark-v2");
+		expect(visible(statusLine.getTopBorder(WIDTH).content)).not.toContain("bookmark-v1");
+	});
+
+	it("a jj lookup that resolves after the root changed never lands in the new root's cache", async () => {
+		// Root A's query hangs on a deferred so it is still in flight when we
+		// switch repos; root B resolves with its own label.
+		const deferredA = Promise.withResolvers<string | null>();
+		const branchSpy = spyOn(jj.workingCopy, "label").mockImplementation(async root => {
+			if (root === ROOT_A) return deferredA.promise;
+			if (root === ROOT_B) return "branch-B";
+			return null;
+		});
+		spies.push(branchSpy);
+
+		const statusLine = new StatusLineComponent(makeSession());
+
+		// Render in repo A: starts the (hanging) lookup for ROOT_A. Nothing painted
+		// yet — the cache is empty and the query is unresolved.
+		expect(visible(statusLine.getTopBorder(WIDTH).content)).not.toContain("branch-A-STALE");
+		expect(branchSpy).toHaveBeenCalledTimes(1);
+
+		// Switch to repo B mid-flight. #jjRootFor(tmpB) re-points #jjRoot to ROOT_B
+		// and resets the jj caches; ROOT_A's lookup is now stale. The render can't
+		// start B's lookup yet — the single in-flight flag is still held by A.
+		setProjectDir(tmpB);
+		statusLine.getTopBorder(WIDTH);
+		await flushMicrotasks();
+		expect(branchSpy).toHaveBeenCalledTimes(1);
+
+		// Let ROOT_A's slow query finish, then drain its continuation. The
+		// root-keyed guard must DROP it: #jjRoot is ROOT_B, so A's label must never
+		// become B's cached branch, and A's completion must not advance B's
+		// throttle (leaving B free to refetch) — the finding-2/4 contract.
+		deferredA.resolve("branch-A-STALE");
+		await flushMicrotasks();
+
+		// The very next render paints synchronously from the current cache BEFORE
+		// any new fetch resolves. This is the only window the transient stale is
+		// observable: with the fix the cache is empty here (A's result was
+		// dropped), so this render both refuses to paint A's label AND is free to
+		// launch B's refetch. Without the fix, A's stale label is already sitting
+		// in B's cache and paints here.
+		const paintedImmediate = visible(statusLine.getTopBorder(WIDTH).content);
+		expect(paintedImmediate).not.toContain("branch-A-STALE");
+
+		// Steady state: B's (now unthrottled) refetch resolves and paints B's real
+		// label — confirming the switch left B's cache coherent, not poisoned.
+		await flushMicrotasks();
+		expect(visible(statusLine.getTopBorder(WIDTH).content)).toContain("branch-B");
+	});
+
+	it("a jj lookup that resolves after a same-root invalidation never lands as stale", async () => {
+		// The finding-6 race: a HEAD/bookmark move invalidates the caches while a
+		// branch query for the SAME root is still in flight. #invalidateGitCaches
+		// resets #jjRoot, but the next render re-resolves it to the identical root
+		// string — so a guard keyed only on root equality would accept the
+		// pre-invalidation result. The generation token must reject it.
+		const deferred = Promise.withResolvers<string | null>();
+		let call = 0;
+		const branchSpy = spyOn(jj.workingCopy, "label").mockImplementation(async () => {
+			call++;
+			// First query (pre-invalidation) hangs; later queries return the fresh label.
+			return call === 1 ? deferred.promise : "bookmark-fresh";
+		});
+		spies.push(branchSpy);
+
+		const statusLine = new StatusLineComponent(makeSession());
+
+		// Render in ROOT_A: starts the (hanging) first lookup. Nothing cached yet.
+		statusLine.getTopBorder(WIDTH);
+		await flushMicrotasks();
+		expect(branchSpy).toHaveBeenCalledTimes(1);
+
+		// A HEAD/bookmark move fires the watcher → invalidate(). The cwd is
+		// unchanged, so the next #jjRootFor re-resolves #jjRoot to the SAME ROOT_A.
+		statusLine.invalidate();
+		statusLine.getTopBorder(WIDTH);
+		await flushMicrotasks();
+
+		// The stale first query now resolves. The generation captured at its launch
+		// no longer matches (invalidate bumped it), so its label must be dropped —
+		// never cached, and the throttle must NOT be advanced on it.
+		deferred.resolve("bookmark-stale");
+		await flushMicrotasks();
+		const paintedImmediate = visible(statusLine.getTopBorder(WIDTH).content);
+		expect(paintedImmediate).not.toContain("bookmark-stale");
+
+		// Because the stale result did not advance the throttle, the post-invalidate
+		// cache is free to refetch and paint the fresh label.
+		await flushMicrotasks();
+		expect(visible(statusLine.getTopBorder(WIDTH).content)).toContain("bookmark-fresh");
+		expect(branchSpy).toHaveBeenCalledTimes(2);
+	});
+});

package/src/modes/components/status-line/component.ts

@@ -10,6 +10,7 @@ import type { OAuthAccountIdentity } from "../../../session/auth-storage";
 import { limitMatchesActiveAccount } from "../../../slash-commands/helpers/active-oauth-account";
 import { type ActiveRepoContext, resolveActiveRepoContextSync } from "../../../utils/active-repo-context";
 import * as git from "../../../utils/git";
+import * as jj from "../../../utils/jj";
 import { getSessionAccentAnsi, getSessionAccentHex } from "../../../utils/session-color";
 import { calculateTokensPerSecond } from "../../../utils/token-rate";
 import { sanitizeStatusText } from "../../shared";
@@ -26,6 +27,8 @@ import type {
 	StatusLineSettings,
 } from "./types";
 
+const JJ_REFRESH_TTL_MS = 5000;
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Context-usage memo
 // ═══════════════════════════════════════════════════════════════════════════
@@ -292,6 +295,21 @@ export class StatusLineComponent implements Component {
 	#cachedGitStatusCwd: string | undefined = undefined;
 	#gitStatusLastFetch = 0;
 	#gitStatusInFlightCwd: string | undefined = undefined;
+	#jjRoot: string | null | undefined = undefined;
+	#jjRootCwd: string | undefined = undefined;
+	#cachedJjBranch: string | null = null;
+	#jjBranchLastFetch = 0;
+	#jjBranchInFlight = false;
+	#cachedJjStatus: { staged: number; unstaged: number; untracked: number } | null = null;
+	#jjStatusLastFetch = 0;
+	#jjStatusInFlight = false;
+	// Bumped on every jj-cache reset — a cwd switch (#jjRootFor) or a HEAD /
+	// bookmark move (#invalidateGitCaches). An in-flight jj query captures this
+	// at launch; a mismatch on resolve means the caches were reset underneath it
+	// (including a reset that re-resolves to the SAME root, which a root-equality
+	// check cannot detect), so the result is stale and must be dropped rather
+	// than poison the fresh cache or advance its throttle.
+	#jjCacheGeneration = 0;
 
 	// PR lookup caching (invalidated on branch/repo context changes)
 	#cachedPr: { number: number; url: string } | null | undefined = undefined;
@@ -609,6 +627,16 @@ export class StatusLineComponent implements Component {
 		this.#cachedBranchRepoId = undefined;
 		this.#cachedBranchCwd = undefined;
 		this.#cachedPrContext = undefined;
+		// jj label/status share the git segment's lifecycle: a HEAD move (e.g. a
+		// colocated `jj new`/bookmark move) must drop the throttled jj caches too,
+		// mirroring #jjRootFor's per-cwd reset so the next render refetches.
+		this.#jjRoot = undefined;
+		this.#jjRootCwd = undefined;
+		this.#cachedJjBranch = null;
+		this.#jjBranchLastFetch = 0;
+		this.#cachedJjStatus = null;
+		this.#jjStatusLastFetch = 0;
+		this.#jjCacheGeneration++;
 	}
 	#getCurrentBranch(effectiveGitCwd?: string): string | null {
 		if (!this.#gitEnabled()) return null;
@@ -676,10 +704,14 @@ export class StatusLineComponent implements Component {
 				nextStatus = null;
 			} finally {
 				if (this.#gitStatusInFlightCwd === gitCwd) {
+					const prev = this.#cachedGitStatusCwd === gitCwd ? this.#cachedGitStatus : null;
 					this.#cachedGitStatus = nextStatus;
 					this.#cachedGitStatusCwd = gitCwd;
 					this.#gitStatusLastFetch = Date.now();
 					this.#gitStatusInFlightCwd = undefined;
+					if (!this.#disposed && this.#onBranchChange && JSON.stringify(prev) !== JSON.stringify(nextStatus)) {
+						this.#onBranchChange();
+					}
 				}
 			}
 		})();
@@ -687,6 +719,83 @@ export class StatusLineComponent implements Component {
 		return this.#cachedGitStatusCwd === gitCwd ? this.#cachedGitStatus : null;
 	}
 
+	// Resolve (and cache per cwd) the jj workspace root, resetting both jj caches
+	// on a cwd change so a directory switch refetches label + status.
+	#jjRootFor(cwd: string): string | null {
+		if (this.#jjRoot === undefined || this.#jjRootCwd !== cwd) {
+			this.#jjRootCwd = cwd;
+			this.#jjRoot = jj.repo.rootSync(cwd);
+			this.#cachedJjBranch = null;
+			this.#jjBranchLastFetch = 0;
+			this.#cachedJjStatus = null;
+			this.#jjStatusLastFetch = 0;
+			this.#jjCacheGeneration++;
+		}
+		return this.#jjRoot;
+	}
+
+	// jj working-copy bookmark label (nearest bookmark, change-id fallback), shown
+	// in the `git` segment where git HEAD is detached/absent under jj. Throttled,
+	// cached, and repaints on resolve.
+	#getJjBranch(effectiveGitCwd?: string): string | null {
+		const cwd = effectiveGitCwd ?? this.#resolveActiveRepoCache().effectiveGitCwd;
+		const root = this.#jjRootFor(cwd);
+		if (!root) return null;
+		if (this.#jjBranchInFlight || Date.now() - this.#jjBranchLastFetch < JJ_REFRESH_TTL_MS) {
+			return this.#cachedJjBranch;
+		}
+		this.#jjBranchInFlight = true;
+		const generation = this.#jjCacheGeneration;
+		(async () => {
+			let next: string | null = null;
+			try {
+				next = await jj.workingCopy.label(root);
+			} finally {
+				this.#jjBranchInFlight = false;
+				// Advance the throttle only if no reset raced this query; a reset
+				// leaves LastFetch at 0 so the current root refetches instead of
+				// being throttled on a superseded result.
+				if (this.#jjCacheGeneration === generation) this.#jjBranchLastFetch = Date.now();
+			}
+			// Drop a result whose caches were reset mid-flight — a repo switch OR a
+			// same-root HEAD/bookmark move — so a superseded label never lands in
+			// the live cache.
+			if (this.#jjCacheGeneration !== generation || this.#disposed) return;
+			const changed = next !== this.#cachedJjBranch;
+			this.#cachedJjBranch = next;
+			if (changed && this.#onBranchChange) this.#onBranchChange();
+		})();
+		return this.#cachedJjBranch;
+	}
+
+	// jj working-copy status counts (`@` vs its parent), used in place of git
+	// status in a jj repo where `git status` has no `.git` to read. Throttled,
+	// cached, and repaints on resolve like #getJjBranch.
+	#getJjStatus(effectiveGitCwd?: string): { staged: number; unstaged: number; untracked: number } | null {
+		const cwd = effectiveGitCwd ?? this.#resolveActiveRepoCache().effectiveGitCwd;
+		const root = this.#jjRootFor(cwd);
+		if (!root) return null;
+		if (this.#jjStatusInFlight || Date.now() - this.#jjStatusLastFetch < JJ_REFRESH_TTL_MS) {
+			return this.#cachedJjStatus;
+		}
+		this.#jjStatusInFlight = true;
+		const generation = this.#jjCacheGeneration;
+		(async () => {
+			let next: { staged: number; unstaged: number; untracked: number } | null = null;
+			try {
+				next = await jj.status.summary(root);
+			} finally {
+				this.#jjStatusInFlight = false;
+				if (this.#jjCacheGeneration === generation) this.#jjStatusLastFetch = Date.now();
+			}
+			if (this.#jjCacheGeneration !== generation || this.#disposed) return;
+			const prev = this.#cachedJjStatus;
+			this.#cachedJjStatus = next;
+			if (this.#onBranchChange && JSON.stringify(prev) !== JSON.stringify(next)) this.#onBranchChange();
+		})();
+		return this.#cachedJjStatus;
+	}
+
 	#lookupPr(effectiveGitCwd?: string): { number: number; url: string } | null {
 		if (!this.#gitEnabled()) return null;
 
@@ -1102,8 +1211,20 @@ export class StatusLineComponent implements Component {
 		const activeRepoCache = shouldResolveActiveRepo
 			? this.#resolveActiveRepoCache()
 			: { projectDir, activeRepo: null, effectiveGitCwd: projectDir, worktree: null };
-		const gitBranch = includeGit || includePr ? this.#getCurrentBranch(activeRepoCache.effectiveGitCwd) : null;
-		const gitStatus = includeGit ? this.#getGitStatus(activeRepoCache.effectiveGitCwd) : null;
+		let gitBranch = includeGit || includePr ? this.#getCurrentBranch(activeRepoCache.effectiveGitCwd) : null;
+		// A jj repo has no git branch to read: git HEAD is detached (colocated) or
+		// absent. Gate BOTH the jj branch label and the jj status counts on that
+		// same condition, captured before the label overlay rewrites gitBranch, so
+		// a nested ordinary git checkout under a parent jj workspace keeps its own
+		// git branch AND its own git status instead of the ancestor jj status.
+		const gitHeadIsJjLike = gitBranch === "detached" || gitBranch === null;
+		if (includeGit && gitHeadIsJjLike) {
+			gitBranch = this.#getJjBranch(activeRepoCache.effectiveGitCwd) ?? gitBranch;
+		}
+		const gitStatus = includeGit
+			? ((gitHeadIsJjLike ? this.#getJjStatus(activeRepoCache.effectiveGitCwd) : null) ??
+				this.#getGitStatus(activeRepoCache.effectiveGitCwd))
+			: null;
 		const gitPr = includePr ? this.#lookupPr(activeRepoCache.effectiveGitCwd) : null;
 		return {
 			session: this.session,

package/src/modes/components/tool-execution.ts

@@ -782,9 +782,18 @@ export class ToolExecutionComponent extends Container implements NativeScrollbac
 		return this.isTranscriptBlockFinalized() ? undefined : 0;
 	}
 
-	/** Keeps the in-flight `vibe_wait` TV wall out of immutable native scrollback. */
+	/**
+	 * Keeps in-flight TV-wall frames out of immutable native scrollback: the
+	 * `vibe_wait` wall and displaceable snapshots (`hub` waiting polls, `todo`
+	 * lists). Their frames replace each other rather than append, and their
+	 * rows mutate every spinner tick — an unpinned commit records a per-tick
+	 * frozen snapshot AND force-seals the block (see TranscriptContainer's
+	 * committed-snapshot seal), so the next poll stacks a new frame instead of
+	 * displacing this one.
+	 */
 	isNativeScrollbackLiveRegionPinned(): boolean {
-		return this.#toolName === "vibe_wait" && !this.isTranscriptBlockFinalized();
+		if (this.isTranscriptBlockFinalized()) return false;
+		return this.#toolName === "vibe_wait" || this.#displaceableByToolName !== undefined;
 	}
 
 	/**