dsh-git-badge 0.16.1 → 0.17.1

package/lib/client.js

@@ -56,8 +56,17 @@ window.__ModuleLoader__.load({
 		const Menu = primitives === null ? void 0 : primitives.Menu;
 		const rankByName = primitives === null ? void 0 : primitives.rankByName;
 
-		/** Module-level git-status cache. Entries are invalidated by SSE events, never by age. */
+		/**
+		 * Module-level git-status cache. Entries are invalidated by SSE events,
+		 * never by age — and BOUNDED, because a long-lived tab opens and closes
+		 * many sessions and nothing else removes an entry. When the cap is
+		 * exceeded the oldest-INSERTED key is evicted (Map order is insertion,
+		 * not use); an evicted surface simply refetches, which the in-flight map
+		 * collapses like any other request.
+		 */
 		const GIT_CACHE = new Map();
+		/** The cache's entry bound — each surface is one key, plus lazy detail keys. */
+		const GIT_CACHE_LIMIT = 64;
 		/** In-flight fetches per cacheKey: bursts collapse into one request. */
 		const GIT_INFLIGHT = new Map();
 		/** Slow safety-net poll: refreshes even if the SSE stream is silently dead. */
@@ -138,7 +147,7 @@ window.__ModuleLoader__.load({
 		 * `options.detail` / `options.pr` ask the node half for the chip's extras
 		 * (see targetQuery). `options.enabled: false` holds the fetch back
 		 * entirely — that is what makes the hover card's extra fields LAZY: the
-		 * chip renders without them and only starts paying for `log -3` plus a
+		 * chip renders without them and only starts paying for a `log -10` plus a
 		 * stash list once a pointer actually rests on it. The hook is still called
 		 * unconditionally (hooks may not be conditional); the GATE is inside.
 		 */
@@ -173,6 +182,9 @@ window.__ModuleLoader__.load({
 					if (data !== null && data.error !== void 0 && GIT_CACHE.has(cacheKey)) return;
 					if (data !== null && typeof data.workspace === "string") resolvedWorkspace = data.workspace;
 					GIT_CACHE.set(cacheKey, { at: Date.now(), data });
+					if (GIT_CACHE.size > GIT_CACHE_LIMIT) {
+						GIT_CACHE.delete(GIT_CACHE.keys().next().value);
+					}
 					if (alive) setState({ key: cacheKey, data });
 				};
 				const load = () => {
@@ -232,45 +244,37 @@ window.__ModuleLoader__.load({
 
 
 		/**
-		 * The /gh picker's sub-actions — the skill invocations the checkout
-		 * justifies, most urgent first. The server's `next` (the ranked top rule,
-		 * already carrying args/why/what) always leads; the client adds the other
-		 * justified actions as secondary entries, mirroring the server's category
-		 * rules but never re-deciding the winner.
+		 * The actions BOTH surfaces render — the server's list, verbatim.
+		 *
+		 * This half used to re-derive pull/push/commit/pr from the raw counts,
+		 * which meant two implementations of the same conditions drifting apart:
+		 * the card once promoted a client-only extra into its action row, and
+		 * `/gh pr` was offered on the default branch. The node half owns the
+		 * rules and the ranking now; the client adds presentation only — the risk
+		 * gate for `clean`, and the labels.
 		 */
 		function ghSkillActions(info) {
 			if (info === void 0 || info === null || info.git !== true) return [];
-			const subs = [];
-			const seen = new Set();
-			const add = (args, why, what) => {
-				if (args === void 0 || args === null || args === "" || seen.has(args)) return;
-				seen.add(args);
-				subs.push({ args, why, what });
+			return Array.isArray(info.actions) ? info.actions : [];
+		}
+
+		/**
+		 * The risk gate the menu shows for `/gh clean`, in the host's own
+		 * confirmation shape (RiskConfirmation: title, description, an acknowledge
+		 * checkbox, two button labels). Confirm stays disabled until the box is
+		 * ticked — that is the "are you sure?", before the invocation is even sent.
+		 * The agent then re-establishes the exact list with `git clean -n` and asks
+		 * again: two gates, because this one names the risk and that one names the
+		 * files.
+		 */
+		function cleanGate() {
+			return {
+				title: "Remove untracked files?",
+				description: "Untracked files have no reflog and no stash entry — once removed they cannot be recovered. The agent will show the exact list (`git clean -n`) and ask again before removing anything.",
+				acknowledgeLabel: "I understand untracked files cannot be recovered",
+				cancelLabel: "Cancel",
+				confirmLabel: "Continue"
 			};
-			const next = info.next;
-			if (next !== void 0 && next !== null) add(next.args, next.why, next.what);
-			const ahead = info.ahead || 0;
-			const behind = info.behind || 0;
-			const staged = info.stagedFiles || 0;
-			const unstaged = info.unstagedFiles || 0;
-			const untracked = info.untrackedFiles || 0;
-			if (behind > 0 && ahead > 0) {
-				add("sync", ahead + " ahead, " + behind + " behind — diverged", "rebase your commits onto upstream and push (asks before any force)");
-			} else {
-				if (behind > 0) add("pull", behind + " behind " + (info.upstream ?? "upstream"), "update this branch from upstream");
-				if (ahead > 0) add("push", ahead + " ahead of " + (info.upstream ?? "upstream"), "push local commits to the remote");
-			}
-			if (staged > 0) add("commit", staged + " staged", "commit the staged changes");
-			if (unstaged > 0) add("commit", unstaged + " unstaged", "stage and commit the working changes");
-			if (unstaged === 0 && untracked > 0) add("commit", untracked + " untracked", "stage the new files and commit them");
-			const pr = info.pr;
-			if (pr !== void 0 && pr !== null && pr.number !== void 0) {
-				if (pr.state === "failing") add("checks " + pr.number, "checks failing on #" + pr.number, "watch the CI checks on pull request " + pr.number);
-				add("pr view " + pr.number, "open pull request #" + pr.number, "show pull request " + pr.number + " on GitHub");
-			} else if (ahead === 0 && behind === 0 && info.upstream !== void 0 && staged + unstaged + untracked === 0) {
-				add("pr", "branch is pushed and has no pull request", "open a pull request for this branch");
-			}
-			return subs.slice(0, 6);
 		}
 
 		/**
@@ -305,16 +309,29 @@ window.__ModuleLoader__.load({
 		 *  - clean workspaces stay quiet: arrows only when nonzero, no ✎ at 0
 		 *  - no upstream: arrows omitted entirely
 		 */
-		function formatGitSuffix(info) {
-			const parts = [];
+		/**
+		 * The upstream sync arrows (" ↑1 ↓2"), or "". Split out from the file
+		 * count so each rides the surface that OWNS it: the arrows belong to the
+		 * branch (they are the branch's standing against its upstream, and the
+		 * branch name's hover and compare link cover them), while ✎n belongs to the
+		 * count's names tooltip.
+		 */
+		function formatSync(info) {
 			const hasUpstream = info.ahead !== void 0 || info.behind !== void 0;
 			const files = (info.changedFiles || 0) + (info.untrackedFiles || 0);
-			if (hasUpstream && (files > 0 || info.ahead > 0 || info.behind > 0)) {
-				parts.push("\u2191" + (info.ahead || 0));
-				parts.push("\u2193" + (info.behind || 0));
-			}
-			if (files > 0) parts.push("\u270E" + files);
-			return parts.length > 0 ? " " + parts.join(" ") : "";
+			if (!hasUpstream || (files === 0 && !(info.ahead > 0) && !(info.behind > 0))) return "";
+			return " \u2191" + (info.ahead || 0) + " \u2193" + (info.behind || 0);
+		}
+
+		/** The ✎n file count (" ✎3"), or "". */
+		function formatFileCount(info) {
+			const files = (info.changedFiles || 0) + (info.untrackedFiles || 0);
+			return files > 0 ? " \u270E" + files : "";
+		}
+
+		/** Both halves, in chip order — kept for callers that want the whole suffix. */
+		function formatGitSuffix(info) {
+			return formatSync(info) + formatFileCount(info);
 		}
 
 		/**
@@ -544,9 +561,57 @@ window.__ModuleLoader__.load({
 		 */
 		const ACTION_STYLE = { flex: "none", marginLeft: "auto", marginRight: "8px", fontWeight: 500 };
 
-		/** The action badge: floated, weighted, and coloured by severity. */
-		function SessionGitBadge({ sessionId }) {
+		/**
+		 * The row's own run state, from the shell's standard kit.
+		 *
+		 * The renderer that assembles slots hands EVERY entry the sessions store as
+		 * a selector hook (`useSessions`) — the same kit that supplies
+		 * `useWorkspaces` — which is how a row can tell an idle session from one
+		 * mid-turn without the seam having to carry it. A shell that does not seed
+		 * that kit leaves the prop undefined: then we cannot know, and the badge
+		 * behaves exactly as it did before rather than guessing "idle".
+		 *
+		 * One helper and one call site, so the hook order is identical on every path
+		 * (the fallback is a plain function, never a hook).
+		 */
+		function useSessionRunning(useSessions, sessionId) {
+			const select = typeof useSessions === "function" ? useSessions : () => void 0;
+			return select((state) => state?.byId?.[sessionId]?.running) === true;
+		}
+
+		/**
+		 * Report the idle gate ONCE, the way the boot diagnostics report the seam and
+		 * the Tooltip primitive. Whether the shell actually handed a slot the
+		 * sessions store is invisible from anywhere else, and a gate that silently
+		 * never fires is indistinguishable from a gate that never needed to.
+		 */
+		let idleGateReported = false;
+		function reportIdleGate(present) {
+			if (idleGateReported) return;
+			idleGateReported = true;
+			console.info(
+				"[dsh-git-badge] session-row idle gate = " +
+					(present
+						? "on (the standard kit supplies useSessions)."
+						: "off (no useSessions prop) — the token cannot tell a running turn, so it shows as before.")
+			);
+		}
+
+		/**
+		 * The action badge: floated, weighted, and coloured by severity — and shown
+		 * only when the session is IDLE. A turn in flight is precisely when a git
+		 * suggestion is noise: the checkout is still moving and the agent has not
+		 * finished, so the action describes a state that is about to change. Nothing
+		 * about the action itself changes; the gate is the whole feature.
+		 *
+		 * The filter is on RENDER, not on the fetch: hiding the row must not take the
+		 * hover card's detail line down with it — both read the same cached status.
+		 */
+		function SessionGitBadge({ sessionId, useSessions }) {
 			const info = useGitStatus(sessionId === void 0 ? void 0 : { kind: "session", id: sessionId }, { pr: true });
+			const running = useSessionRunning(useSessions, sessionId);
+			reportIdleGate(typeof useSessions === "function");
+			if (running) return null;
 			if (sessionId === void 0 || info === void 0 || info.git !== true) return null;
 			const action = actionToken(info);
 			if (action === "") return null;
@@ -651,6 +716,70 @@ window.__ModuleLoader__.load({
 			return name;
 		}
 
+		/**
+		 * ONE commit line, shared by the branch hover and the PR token's hover so
+		 * the two cannot drift apart again: a fixed-width monospace hash cell, so
+		 * every description starts on the same column and the list reads as a
+		 * table, then `subject · age`. `sign` belongs to the branch hover — "+"
+		 * (only on this branch) or "−" (only on main); the PR list passes none,
+		 * because all of its commits are `base..HEAD`.
+		 *
+		 * The cell needs `display: inline-block` for `minWidth` to mean anything: an
+		 * inline span ignores it, which is exactly how the PR list came to render a
+		 * hash with NO gap at all — it reused the card's label style, whose
+		 * `minWidth` and `flex` only do anything inside a flex row.
+		 */
+		function CommitLine({ commit, sign = "" }) {
+			return react_jsx_runtime.jsxs("span", {
+				style: { whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis" },
+				children: [
+					react_jsx_runtime.jsx("span", {
+						style: {
+							color: "var(--dsw-alias-label-tertiary, #9ea7ad)",
+							fontFamily: "monospace",
+							display: "inline-block",
+							minWidth: "68px",
+							flex: "none"
+						},
+						children: sign + commit.hash
+					}),
+					commit.subject + (commit.when === "" ? "" : "  \u00B7 " + shortWhen(commit.when))
+				]
+			});
+		}
+
+		/**
+		 * The PR token's own hover body — the commits IN THIS PULL REQUEST
+		 * (`base..HEAD`), and nothing else: the token already says the number and
+		 * CI state, so the one question left is "what is in it?". Same line format
+		 * as the branch hover's commit list (see CommitLine — one renderer, so the
+		 * columns line up in both by construction), and the card's own width
+		 * behaviour: full-width lines, nowrap, ellipsis.
+		 */
+		function PrCommitsList({ info, pending = false }) {
+			const commits = info?.prCommits;
+			if (!Array.isArray(commits) || commits.length === 0) {
+				// `pending`: the detail payload has not landed yet, so "no commits"
+				// would be a false negative — name the pull request the token points
+				// at instead, the way the mark's card degrades to the base response.
+				if (pending) {
+					return react_jsx_runtime.jsx("span", { style: CARD_CONTAINER, children: formatPrDetail(info?.pr) ?? "loading\u2026" });
+				}
+				return react_jsx_runtime.jsx("span", { style: CARD_CONTAINER, children: "no commits beyond the base branch" });
+			}
+			return react_jsx_runtime.jsxs("div", { style: CARD_CONTAINER, children: [
+				react_jsx_runtime.jsxs("div", {
+					style: { display: "flex", flexDirection: "column", gap: "2px", minWidth: 0 },
+					children: [
+						...commits.map((commit) => react_jsx_runtime.jsx(CommitLine, { commit }, commit.hash)),
+						(typeof info.prCommitsTotal === "number" && info.prCommitsTotal > commits.length
+							? "\u2026 and " + (info.prCommitsTotal - commits.length) + " more"
+							: null)
+					]
+				})
+			] });
+		}
+
 		const CARD_CONTAINER = {
 			display: "flex",
 			flexDirection: "column",
@@ -669,12 +798,13 @@ window.__ModuleLoader__.load({
 		 * the one question the count poses ("what are these?"). One stacked
 		 * column with sub-headers: UNSTAGED (tracked, edited — valid regardless
 		 * of the collapsed untracked retry) then UNTRACKED. Reads the same lazy
-		 * detail payload the mark's card uses; no tooltip at all when neither
-		 * list has names (the count itself is absent on a clean tree, so an
-		 * empty list is rare — a mid-fetch hover shows it plain until the
-		 * response lands).
+		 * detail payload the mark's card uses. The wrapper is always mounted (see
+		 * withTooltip) and the label degrades while the names are in flight: the
+		 * COUNTS are already in the base response, so it restates the breakdown
+		 * rather than claiming an empty list. "no changed files" is reserved for a
+		 * landed payload that genuinely has no names.
 		 */
-		function CountNames({ info }) {
+		function CountNames({ info, pending = false }) {
 			const sections = [
 				{
 					label: "staged",
@@ -693,6 +823,11 @@ window.__ModuleLoader__.load({
 				}
 			].filter((section) => Array.isArray(section.names) && section.names.length > 0);
 			if (sections.length === 0) {
+				// `pending`: the names have not been fetched yet, but the COUNTS have —
+				// restate those rather than the false "no changed files".
+				if (pending) {
+					return react_jsx_runtime.jsx("span", { style: CARD_CONTAINER, children: formatFileBreakdown(info) });
+				}
 				return react_jsx_runtime.jsx("span", { style: CARD_CONTAINER, children: "no changed files" });
 			}
 			return react_jsx_runtime.jsxs("div", { style: CARD_CONTAINER, children:
@@ -741,27 +876,11 @@ window.__ModuleLoader__.load({
 				if (value === void 0 || value === null || value === "") return;
 				rows.push(cardRow(label, value));
 			};
-			add("upstream", info?.upstream === void 0 ? "none configured" : info.upstream);
-			const ahead = info?.ahead || 0;
-			const behind = info?.behind || 0;
-			// The sync row speaks ONLY about the upstream it names: with no
-			// upstream configured there are no ahead/behind counts at all (no
-			// `# branch.ab` header), and falling back to 0/0 would claim "in
-			// sync" — a lie the upstream row directly contradicts. Omit it; the
-			// "none configured" row above carries the fact.
-			if (info?.upstream !== void 0) {
-				add("sync", ahead === 0 && behind === 0
-					? "in sync with upstream"
-					: "\u2191" + ahead + " \u2193" + behind);
-			}
-			// The merge-state row, in WORDS (deliberately not arrows — the sync
-			// row above already uses ↑↓ for the push axis, and two arrow pairs
-			// with different references would be read as one). "merge" is its
-			// label because it is the merge axis — the counterpart of "sync",
-			// the push axis — and it stays correct whatever the default branch
-			// is named. A BLOCKED verdict becomes the reason (review required,
-			// checks failing, draft) so a dead-end word names the next action;
-			// CLEAN stays silent — the action row already offers /gh merge.
+			// ONLY the merge axis, and it ALWAYS renders. The old upstream and sync
+			// rows spoke about the push axis (the branch's own remote), which the
+			// merge row subsumes: "1 ahead, 0 behind main" is the same fact stated
+			// against the branch that matters, in words rather than arrows. A row
+			// that can be absent is a row the reader has to reconstruct.
 			const pr = info?.pr;
 			const mergeParts = [];
 			if (pr !== void 0 && pr !== null && pr.number !== void 0) {
@@ -771,12 +890,15 @@ window.__ModuleLoader__.load({
 						: pr.state === "failing" ? "blocked: checks failing"
 						: "blocked");
 				} else if (pr.state === "failing") mergeParts.push("blocked: checks failing");
-				else if (pr.mergeState !== "CLEAN" && pr.review === "REVIEW_REQUIRED") mergeParts.push("blocked: review required");
+				else if (pr.mergeState === "CLEAN" || (pr.state === "passing" && pr.review === "APPROVED")) mergeParts.push("ready to merge");
+				else if (pr.review === "REVIEW_REQUIRED") mergeParts.push("blocked: review required");
+			} else {
+				mergeParts.push("no pull request");
 			}
 			if (info?.mainAhead !== void 0 || info?.mainBehind !== void 0) {
 				mergeParts.push((info.mainAhead || 0) + " ahead, " + (info.mainBehind || 0) + " behind main");
 			}
-			if (mergeParts.length > 0) add("merge", mergeParts.join(" \u00B7 "));
+			add("merge", mergeParts.join(" \u00B7 "));
 			const commits = info?.branchCommits;
 			if (Array.isArray(commits) && commits.length > 0) {
 				// Full-width block, not the label/value two-column row: commit lines
@@ -788,23 +910,9 @@ window.__ModuleLoader__.load({
 					react_jsx_runtime.jsxs("div", {
 						style: { display: "flex", flexDirection: "column", gap: "2px", minWidth: 0 },
 						children:
-							commits.map((commit) => react_jsx_runtime.jsxs("span", {
-								style: { whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis" },
-								children: [
-									// fixed-width monospace hash cell: every description starts
-									// on the same column, so the list reads as a table
-									react_jsx_runtime.jsx("span", {
-										style: {
-											color: "var(--dsw-alias-label-tertiary, #9ea7ad)",
-											fontFamily: "monospace",
-											display: "inline-block",
-											minWidth: "68px",
-											flex: "none"
-										},
-										children: (commit.sign === "+" ? "+" : commit.sign === "\u2212" ? "\u2212" : "") + commit.hash + ":"
-									}),
-									commit.subject + (commit.when === "" ? "" : "  \u00B7 " + shortWhen(commit.when))
-								]
+							commits.map((commit) => react_jsx_runtime.jsx(CommitLine, {
+								commit,
+								sign: commit.sign === "+" ? "+" : commit.sign === "\u2212" ? "\u2212" : ""
 							}, commit.hash))
 					}, "branch-commits")
 				);
@@ -891,11 +999,13 @@ window.__ModuleLoader__.load({
 				rows.push(cardRow(label, value));
 			};
 			// The "action" row — the top line, in the card's ordinary row layout:
-			// the gh skill invocation the checkout justifies, derived from the same
-			// state the /gh picker uses (first sub-action wins). Plain text, no
-			// affordance: the actionable surface is the (+) menu's /gh picker, and
-			// this row is the read-only pointer to it.
-			const topAction = ghSkillActions(data)[0];
+			// the SERVER's ranked suggestion, and nothing else. The client's
+			// extras (secondary picker entries) must never promote themselves into
+			// this line: when the server says there is nothing to do — clean and
+			// synced — the row is omitted, and "no suggestion" stays a suggestion.
+			// Plain text, no affordance: the actionable surface is the (+) menu's
+			// /gh picker, and this row is the read-only pointer to it.
+			const topAction = data.next;
 			if (topAction !== void 0) {
 				// git-comment convention: the invocation, two spaces, then "# "
 				// plus what it does
@@ -920,6 +1030,24 @@ window.__ModuleLoader__.load({
 		}
 
 		//#region composer chip (upstream additive surface: conversation.input.left)
+		/**
+		 * The ONE copy of the hover-card degrade rule: wrap a node in the shell's
+		 * Tooltip when the primitive exists, and render the node bare otherwise — a
+		 * missing card is a smaller failure than a missing badge. `label` is the
+		 * thunk the Tooltip calls only when it opens, so the card's element tree
+		 * stays out of closed tooltips.
+		 *
+		 * ALWAYS mount the wrapper — never conditionally, once its data arrives.
+		 * The primitive is uncontrolled (it has no `open` prop) and opens on the
+		 * CHILD's mouseenter, so a wrapper mounted after the pointer is already
+		 * inside can never open for that visit: the pointer has to leave and
+		 * return. Gate the LABEL's content instead.
+		 */
+		function withTooltip(node, label, maxWidth) {
+			if (Tooltip === void 0) return node;
+			return react_jsx_runtime.jsx(Tooltip, { side: "top", maxWidth, label, children: node });
+		}
+
 		/**
 		 * Chip line in the input row: git state of the workspace the CURRENT
 		 * conversation is attached to. It targets the session id and lets the node
@@ -955,7 +1083,7 @@ window.__ModuleLoader__.load({
 			const target = sessionId === void 0 ? void 0 : { kind: "session", id: sessionId };
 			// the PR/CI token is always on the chip, so its fetch is not gated
 			const info = useGitStatus(target, { pr: true });
-			// The card's extras cost a `log -3` plus a stash list, so they are
+			// The card's extras cost a `log -10` plus a stash list, so they are
 			// fetched only once a pointer actually RESTS on the chip, then kept
 			// fresh by the same SSE path. Eagerly asking would add both invocations
 			// to every refresh — and a refresh fires on every file edit.
@@ -980,45 +1108,52 @@ window.__ModuleLoader__.load({
 			// so the extras are paid for exactly when the card that can render them
 			// is about to open. Defined inside the component: it closes over the
 			// hovered state that gates the detail fetch.
-			const hoverableMark = (() => {
-				const mark = react_jsx_runtime.jsx("span", {
+			const hoverableMark = withTooltip(
+				react_jsx_runtime.jsx("span", {
 					onPointerEnter: () => setHovered(true),
 					style: { display: "inline-flex", alignItems: "center", flex: "none", cursor: "default" },
 					children: react_jsx_runtime.jsx(StatusMark, { info })
-				});
-				if (Tooltip === void 0) return mark;
-				return react_jsx_runtime.jsx(Tooltip, {
-					side: "top",
-					// matches the body cap: the tooltip must never be the clamp
-				maxWidth: 600,
-					// a function label keeps the card's element tree out of every render
-					// until the tooltip actually opens
-					label: () => react_jsx_runtime.jsx(HoverCard, { info, detail }),
-					children: mark
-				});
-			})();
+				}),
+				// a function label keeps the card's element tree out of every render
+				// until the tooltip actually opens
+				() => react_jsx_runtime.jsx(HoverCard, { info, detail }),
+				600 // matches the body cap: the tooltip must never be the clamp
+			);
 			// the mark is an element now rather than a leading glyph in the string, so
 			// the SAME StatusMark the sidebar row draws carries the status here too;
 			// the container's 4px gap supplies the space the emoji's own did
 			// The branch NAME is its own hover surface: the commits this branch adds
 			// (BranchCommitsList), sharing the mark's lazy detail fetch. The rest of
 			// the leading text (operation token) and the count keep their own
-			// surfaces. Degrades to plain text without the Tooltip primitive or
-			// when the branch adds nothing beyond upstream.
+			// surfaces. The wrapper is always mounted (see withTooltip); without the
+			// Tooltip primitive the name renders plain.
 			const branchHover = (() => {
 				// The branch name links to the compare view (base...branch) — the web
 				// page of exactly what the lineage tooltip lists. Vouched http(s)
 				// only (the node half rebuilt the URL from parsed parts); new tab,
 				// never navigating the conversation away.
 				const isLink = typeof detail?.compareUrl === "string" && detail.compareUrl.startsWith("https://");
-				const branch = isLink
+				// The sync arrows ride WITH the branch: they are the branch's standing
+				// against its upstream, so the same hover (lineage) and the same link
+				// (compare view, where the arrows are the diff) cover them. The ✎n
+				// count stays its own surface — it answers a different question.
+				const sync = formatSync(info);
+				const label = info.branch + sync;
+				// The Tooltip's CHILD must not change element type once the detail
+				// payload lands: the primitive opens on the child's mouseenter and has
+				// no `open` prop, so a node replaced under the pointer may never be
+				// re-entered. The outer span is the stable hover surface; only this
+				// inner node swaps (plain text -> anchor) as the compare URL arrives.
+				const inner = isLink
 					? react_jsx_runtime.jsx("a", {
 						href: detail.compareUrl,
 						target: "_blank",
 						rel: "noopener noreferrer",
-						"aria-label": "Compare " + info.branch + " with main on GitHub",
-						onPointerEnter: () => { setHovered(true); setBranchLinkHover(true); },
+						"aria-label": "Compare " + info.branch + " with main on GitHub" + (sync === "" ? "" : ", " + (info.ahead || 0) + " ahead and " + (info.behind || 0) + " behind upstream"),
+						onPointerEnter: () => setBranchLinkHover(true),
 						onPointerLeave: () => setBranchLinkHover(false),
+						// focus joins hover: a keyboard user needs the same underline, and
+						// focus (unlike a pointer) must also start the detail fetch
 						onFocus: () => { setHovered(true); setBranchLinkHover(true); },
 						onBlur: () => setBranchLinkHover(false),
 						style: {
@@ -1026,24 +1161,19 @@ window.__ModuleLoader__.load({
 							textDecoration: branchLinkHover ? "underline" : "none",
 							cursor: "pointer"
 						},
-						children: info.branch
+						children: label
 					})
-					: react_jsx_runtime.jsx("span", {
-						onPointerEnter: () => setHovered(true),
-						style: { cursor: "default" },
-						children: info.branch
-					});
-				if (Tooltip === void 0 || detail === void 0 || detail === null) {
-					// mid-fetch the branch shows plain; the lineage tooltip is
-					// unconditional once the payload lands
-					return branch;
-				}
-				return react_jsx_runtime.jsx(Tooltip, {
-					side: "top",
-					maxWidth: 480,
-					label: () => react_jsx_runtime.jsx(BranchLineage, { info: detail }),
-					children: branch
+					: label;
+				const branch = react_jsx_runtime.jsx("span", {
+					onPointerEnter: () => setHovered(true),
+					style: { cursor: isLink ? "pointer" : "default" },
+					children: inner
 				});
+				// ALWAYS wrapped. A wrapper mounted only once the lazy detail arrives
+				// cannot open for the visit that fetched it (see the child-stability
+				// note above); until the payload lands the lineage degrades to the base
+				// response, the way the mark's own card already does.
+				return withTooltip(branch, () => react_jsx_runtime.jsx(BranchLineage, { info: detail ?? info }), 480);
 			})();
 			const text = formatOperationToken(info);
 			// The ✎n count is its OWN hover surface: a names-only tooltip (see
@@ -1051,25 +1181,71 @@ window.__ModuleLoader__.load({
 			// either triggers it once — and degrades to a plain count on a shell
 			// without the Tooltip primitive.
 			const countHover = (() => {
+				// ✎n only: the sync arrows moved to the branch's surface above
+				const countText = formatFileCount(info);
 				const count = react_jsx_runtime.jsx("span", {
 					onPointerEnter: () => setHovered(true),
 					style: { cursor: "default" },
-					children: formatGitSuffix(info)
-				});
-				const hasNames = (Array.isArray(detail?.untrackedNames) && detail.untrackedNames.length > 0)
-					|| (Array.isArray(detail?.unstagedNames) && detail.unstagedNames.length > 0);
-				if (Tooltip === void 0 || !hasNames) {
-					return count;
-				}
-				return react_jsx_runtime.jsx(Tooltip, {
-					side: "top",
-					maxWidth: 480,
-					label: () => react_jsx_runtime.jsx(CountNames, { info: detail }),
-					children: count
+					children: countText
 				});
+				// always wrapped, for the same reason as the branch: the primitive
+				// opens on the child's mouseenter, so a wrapper added after the
+				// pointer arrives never opens. While the names are in flight the label
+				// restates the breakdown the base response already carries.
+				const pending = detail === void 0 || detail === null;
+				return withTooltip(count, () => react_jsx_runtime.jsx(CountNames, { info: detail ?? info, pending }), 480);
 			})();
 			const prToken = formatPrToken(info);
 			const prUrl = prLinkUrl(info);
+			// The PR token, with its own hover: the commits IN THIS PR (see
+			// PrCommitsList). Built here so the link/plain cases and the tooltip
+			// compose once instead of nesting a third conditional in the children.
+			// The token is its OWN detail gate: resting on it (or focusing it)
+			// enables the same `detail=1` fetch the mark and the branch do. Without
+			// that, a pointer going straight to the token had rested on nothing that
+			// fetches, so `prCommits` was never requested and this hover could not
+			// open at all — the data it renders is detail-only.
+			const prTokenHover = (() => {
+				const token = prUrl === void 0
+					? react_jsx_runtime.jsx("span", {
+						// the glyph is not the only channel: the token says what the
+						// CI state IS, for anyone who cannot see it
+						"aria-label": prTokenLabel(info),
+						onPointerEnter: () => setHovered(true),
+						style: { cursor: "default" },
+						children: prToken
+					})
+					: react_jsx_runtime.jsx("a", {
+						href: prUrl,
+						// a new tab, because navigating THIS one away from the app
+						// would lose the conversation; noopener/noreferrer keep the
+						// opened tab from getting a handle on it
+						target: "_blank",
+						rel: "noopener noreferrer",
+						"aria-label": prTokenLabel(info) + ", opens on GitHub in a new tab",
+						// the chip's own colour rather than the browser's link blue /
+						// visited purple, so the token still reads as one row. The
+						// affordance is the pointer cursor plus an underline on hover
+						// or focus, set HERE rather than left to the host stylesheet:
+						// a shell that resets anchors would otherwise drop it silently.
+						style: {
+							color: "inherit",
+							textDecoration: linkHover ? "underline" : "none",
+							cursor: "pointer"
+						},
+						// focus joins hover — the token is keyboard-reachable now, and a
+						// keyboard user needs the same "this is a link" signal
+						onPointerEnter: () => { setHovered(true); setLinkHover(true); },
+						onPointerLeave: () => setLinkHover(false),
+						onFocus: () => { setHovered(true); setLinkHover(true); },
+						onBlur: () => setLinkHover(false),
+						children: prToken
+					});
+				// always wrapped (see the branch): while the commits are in flight the
+				// label names the PR state the base response already carries
+				const pending = detail === void 0 || detail === null;
+				return withTooltip(token, () => react_jsx_runtime.jsx(PrCommitsList, { info: detail ?? info, pending }), 480);
+			})();
 			const chip = react_jsx_runtime.jsxs("span", {
 				style: {
 					display: "inline-flex",
@@ -1103,43 +1279,7 @@ window.__ModuleLoader__.load({
 						branchHover,
 						react_jsx_runtime.jsx("span", { key: "text", children: text }),
 					countHover,
-					prToken === ""
-						? null
-						: prUrl === void 0
-							? react_jsx_runtime.jsx("span", {
-									key: "pr",
-									// the glyph is not the only channel: the token says what the
-									// CI state IS, for anyone who cannot see it
-									"aria-label": prTokenLabel(info),
-									children: prToken
-								})
-							: react_jsx_runtime.jsx("a", {
-									key: "pr",
-									href: prUrl,
-									// a new tab, because navigating THIS one away from the app
-									// would lose the conversation; noopener/noreferrer keep the
-									// opened tab from getting a handle on it
-									target: "_blank",
-									rel: "noopener noreferrer",
-									"aria-label": prTokenLabel(info) + ", opens on GitHub in a new tab",
-									// the chip's own colour rather than the browser's link blue /
-									// visited purple, so the token still reads as one row. The
-									// affordance is the pointer cursor plus an underline on hover
-									// or focus, set HERE rather than left to the host stylesheet:
-									// a shell that resets anchors would otherwise drop it silently.
-									style: {
-										color: "inherit",
-										textDecoration: linkHover ? "underline" : "none",
-										cursor: "pointer"
-									},
-									// focus joins hover — the token is keyboard-reachable now, and a
-									// keyboard user needs the same "this is a link" signal
-									onPointerEnter: () => setLinkHover(true),
-									onPointerLeave: () => setLinkHover(false),
-									onFocus: () => setLinkHover(true),
-									onBlur: () => setLinkHover(false),
-									children: prToken
-								}),
+					prTokenHover,
 					/**
 					 * The seam-absent notice: the market-install notification for the
 					 * state a blocked postinstall leaves behind — chip working, sidebar
@@ -1424,7 +1564,12 @@ window.__ModuleLoader__.load({
 										info = await fetch("/api/git-badge?" + query).then((r) => r.json());
 									}
 									const actions = ghSkillActions(info);
-									return actions.map((action) => ({ label: "/gh " + action.args, detail: action.why, args: action.args }));
+									return actions.map((action) => ({
+										label: "/gh " + action.args,
+										detail: action.why,
+										args: action.args,
+										...action.danger === true ? { confirmation: cleanGate() } : {}
+									}));
 								} catch (error) {
 									console.error("[dsh-git-badge] /gh options failed:", error);
 									return [];
@@ -1667,7 +1812,7 @@ window.__ModuleLoader__.load({
 		// Additive; the host reads apply/inject and ignores the rest. The suite
 		// drives these to assert the REQUEST contract — which surface asks for the
 		// expensive extras — without a browser, a fetch or a network.
-		exports.__internals = { targetQuery, formatPrToken, formatFileBreakdown, formatPrDetail, formatCheckoutDetail, worktreeDetail, actionToken, ghSkillActions, moveCategory };
+		exports.__internals = { targetQuery, formatPrToken, formatFileBreakdown, formatPrDetail, formatCheckoutDetail, worktreeDetail, actionToken, ghSkillActions, cleanGate, moveCategory };
 		return module.exports;
 	}
 });