dsh-git-badge 0.19.0 → 0.20.1

package/lib/client.js

@@ -1,28 +1,24 @@
 /**
  * dsh-git-badge — client half.
  *
- * Both surfaces show the SAME status mark — a circle, or a tree for a linked
- * worktree, filled with the status colour — so status and worktree-ness read
- * identically wherever they appear.
+ * Every surface rides an UPSTREAM seat. No patch, no manual step.
  *
  * Surfaces:
- *  - sidebar.workspaces.sessionRow (seam): session-row badge — the status mark
- *    and the PR/CI token, immediately after the session title. Deliberately shows
- *    NO branch and no worktree name: the row lists conversations, and which
- *    checkout the badge describes is the hover card's business.
- *  - sidebar.session.row.hover (upstream, no patch): the hover-card line that
- *    names that checkout, rendered inside the card upstream ALREADY shows for a
+ *  - sidebar.session.row.leading: the session row's token as a single glyph in
+ *    the row's 16px leading cell, from the node half's `rowToken`. Upstream
+ *    renders this seat only while the session is IDLE.
+ *  - sidebar.session.row.hover: the hover card that explains the token and
+ *    names the checkout, rendered inside the card upstream ALREADY shows for a
  *    session row rather than in a tooltip nested inside it.
- *  - conversation.input.left (upstream): chip — status mark + branch + a
+ *  - conversation.input.left: chip — status mark + branch + a
  *    worktree's name + in-progress operation token + sync/dirty suffix + the
  *    PR/CI token, with a HOVER CARD carrying the breakdown the chip has no room
  *    for (file detail, recent commits, stash, PR state, and the conversation's own
  *    checkout when the badge followed a worktree).
  *
  * The chip's hover card needs nothing but the upstream slot: the Tooltip
- * primitive is seeded by the shell itself, so the card works on a PRISTINE
- * install with no seam patch. Its extra fields are fetched only once a pointer
- * rests on the chip, so the everyday badge pays for none of them.
+ * primitive is seeded by the shell itself. Its extra fields are fetched only once
+ * a pointer rests on the chip, so the everyday badge pays for none of them.
  */
 window.__ModuleLoader__.load({
 	id: "dsh-git-badge",
@@ -50,11 +46,6 @@ window.__ModuleLoader__.load({
 			primitives = null;
 		}
 		const Tooltip = primitives === null ? void 0 : primitives.Tooltip;
-		// The shell's pull-down primitive (what the input-area selectors use) and
-		// its candidate ranker. Same guarded require as Tooltip: a shell without
-		// them loses the pull-down affordances, never the badges.
-		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,
@@ -75,16 +66,14 @@ window.__ModuleLoader__.load({
 		/**
 		 * A request target names WHO is asking, never a filesystem path — the node
 		 * half resolves the directory itself, so a surface never needs to know
-		 * one. The chip targets its conversation (`session`); a sidebar row
-		 * targets the workspace id the seam hands it. The query string doubles as
-		 * the cache key.
+		 * one. Every surface here targets its conversation (`session`). The query
+		 * string doubles as the cache key.
 		 *
-		 * The two optional additions are the INPUT CHIP's alone, and each is an
-		 * explicit request rather than something every badge pays for:
-		 *   - `detail=1` — recent commits and stash for the hover card;
-		 *   - `pr=1` — the branch's GitHub PR/CI state.
-		 * A sidebar row asks for neither, so surveying N workspaces never costs N
-		 * forge calls (see the node half's PR region).
+		 * The two optional additions, each an explicit request:
+		 *   - `detail=1` — recent commits and stash for the chip's hover card;
+		 *   - `pr=1` — the branch's GitHub PR/CI state, which both the chip and
+		 *     the row token need (the leading glyph and the hover card share this
+		 *     exact key, so they cost one request between them).
 		 */
 		function targetQuery(target, options) {
 			if (target === void 0 || target.id === void 0) return void 0;
@@ -98,11 +87,9 @@ window.__ModuleLoader__.load({
 		//#region SSE change feed (one EventSource per page, ref-counted)
 		const eventListeners = new Set();
 		let eventSource = null;
-		let eventRefs = 0;
 
 		function subscribeGitEvents(onChange) {
 			eventListeners.add(onChange);
-			eventRefs += 1;
 			if (eventSource === null) {
 				eventSource = new EventSource("/api/git-badge/events");
 				// NAMED frames: the node half writes `event: change`, and onmessage
@@ -129,8 +116,7 @@ window.__ModuleLoader__.load({
 			}
 			return () => {
 				eventListeners.delete(onChange);
-				eventRefs -= 1;
-				if (eventRefs === 0 && eventSource !== null) {
+				if (eventListeners.size === 0 && eventSource !== null) {
 					eventSource.close();
 					eventSource = null;
 				}
@@ -181,7 +167,7 @@ window.__ModuleLoader__.load({
 					// event or the fallback poll succeeds.
 					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 });
+					GIT_CACHE.set(cacheKey, { data });
 					if (GIT_CACHE.size > GIT_CACHE_LIMIT) {
 						GIT_CACHE.delete(GIT_CACHE.keys().next().value);
 					}
@@ -217,32 +203,6 @@ window.__ModuleLoader__.load({
 			return state.key === cacheKey ? state.data : void 0;
 		}
 
-		/**
-		 * Three-state status, checked top-down, first match wins:
-		 *  - "error": unmerged files (mid-conflict, git is blocked) — or a dirty
-		 *    tree that is ALSO behind upstream (unsaved edits on an outdated
-		 *    base: commit-then-pull friction ahead).
-		 *  - "warn": dirty files, or any ahead/behind (routine work or sync
-		 *    pending — including the previously "quiet" green-but-↓1 case).
-		 *  - "ok": clean and in sync.
-		 * Red never means merely "behind": a clean tree one commit behind is
-		 * normal between pulls, not an alarm.
-		 *
-		 * The single source of truth for that summary. BOTH surfaces render it the
-		 * same way (see StatusMark): a circle, or a tree in a linked worktree,
-		 * filled with the colour below.
-		 */
-		function badgeStatus(info) {
-			const dirty = info.dirty === true;
-			const behind = (info.behind || 0) > 0;
-			const ahead = (info.ahead || 0) > 0;
-			const conflict = (info.unmergedFiles || 0) > 0;
-			if (conflict || (dirty && behind)) return "error";
-			if (dirty || ahead || behind) return "warn";
-			return "ok";
-		}
-
-
 		/**
 		 * The actions BOTH surfaces render — the server's list, verbatim.
 		 *
@@ -278,49 +238,32 @@ window.__ModuleLoader__.load({
 		}
 
 		/**
-		 * Mark fill per status, from the app's own semantic tokens so BOTH surfaces
-		 * follow light/dark and custom themes — which a hardcoded emoji cannot do.
-		 * The literals are only fallbacks for use outside DSH.
-		 */
-		const MARK_FILL = {
-			error: "var(--dsw-alias-state-error-primary, #e5484d)",
-			warn: "var(--dsw-alias-state-warn-primary, #d29922)",
-			ok: "var(--dsw-alias-state-success-primary, #30a46c)"
-		};
-
-		/**
-		 * Accessible name per status, WITHOUT the "git" prefix — the mark adds
-		 * "git: " or "git worktree: ", so shape and colour are never the only
-		 * channel for either fact.
-		 */
-		const STATUS_LABEL = {
-			error: "conflict, or uncommitted changes on an outdated base",
-			warn: "uncommitted changes, or out of sync with upstream",
-			ok: "clean and in sync"
-		};
-
-		/**
-		 * Sync/dirty suffix — INPUT CHIP ONLY. The sidebar row shows status alone;
+		 * Base/dirty suffix — INPUT CHIP ONLY. The sidebar row shows status alone;
 		 * the chip is the surface that carries the numbers. Rule set:
 		 *  - dirty files render as ✎n (pencil = worktree files, distinct from
-		 *    the ↑/↓ commit-sync axis)
-		 *  - while dirty, BOTH sync counts render including zeros (↑0 ↓2 ✎3),
+		 *    the ↑/↓ commit axis)
+		 *  - while dirty, BOTH counts render including zeros (↑0 ↓2 ✎3),
 		 *    so every number is positionally attributable
 		 *  - clean workspaces stay quiet: arrows only when nonzero, no ✎ at 0
-		 *  - no upstream: arrows omitted entirely
+		 *  - no base known: arrows omitted entirely
 		 */
+		/** The base branch's name, for the arrows and the card's base row. */
+		function baseNameFor(info) {
+			return typeof info?.mainBranch === "string" && info.mainBranch !== "" ? info.mainBranch : "main";
+		}
+
 		/**
-		 * 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.
+		 * The BASE ahead/behind arrows and the base's name (" ↑4 ↓0 main"), the
+		 * branch's standing against the branch it will merge into. Naming the base
+		 * stops the arrows from reading as the git-native upstream count. The
+		 * branch's own remote sync is not a number here: the action glyph (`push`,
+		 * `pull`) carries the actionable part.
 		 */
-		function formatSync(info) {
-			const hasUpstream = info.ahead !== void 0 || info.behind !== void 0;
+		function formatBaseSync(info) {
+			const hasBase = info.mainAhead !== void 0 || info.mainBehind !== void 0;
 			const files = (info.changedFiles || 0) + (info.untrackedFiles || 0);
-			if (!hasUpstream || (files === 0 && !(info.ahead > 0) && !(info.behind > 0))) return "";
-			return " \u2191" + (info.ahead || 0) + " \u2193" + (info.behind || 0);
+			if (!hasBase || (files === 0 && !(info.mainAhead > 0) && !(info.mainBehind > 0))) return "";
+			return " \u2191" + (info.mainAhead || 0) + " \u2193" + (info.mainBehind || 0) + " " + baseNameFor(info);
 		}
 
 		/** The ✎n file count (" ✎3"), or "". */
@@ -329,11 +272,6 @@ window.__ModuleLoader__.load({
 			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);
-		}
-
 		/**
 		 * PR / CI token — INPUT CHIP ONLY, and absent entirely when the node half
 		 * has nothing to say (no `gh`, no GitHub remote, no PR for the branch), so
@@ -344,21 +282,41 @@ window.__ModuleLoader__.load({
 		 */
 		const PR_STATE_GLYPH = { passing: "\u2713", pending: "\u2026", failing: "\u2717", none: "" };
 		const PR_STATE_LABEL = { passing: "checks passing", pending: "checks running", failing: "checks failing", none: "no checks" };
+		/** The PR's state label, defaulting to "no checks". */
+		function prStateLabel(pr) {
+			return PR_STATE_LABEL[pr.state] === void 0 ? PR_STATE_LABEL.none : PR_STATE_LABEL[pr.state];
+		}
 
-		/** ` PR#142 ✗` (plus ` draft`), or "" when there is no PR to report. */
-		function formatPrToken(info) {
+		/**
+		 * The CI state -> colour, for the token's STATE GLYPH only. The number and
+		 * the link keep the chip's own muted colour, so the token still reads as one
+		 * row and only the state shouts. These are the same app state tokens the
+		 * action glyph uses.
+		 */
+		const PR_STATE_COLOUR = {
+			passing: "var(--dsw-alias-state-success-primary, #30a46c)",
+			pending: "var(--dsw-alias-state-warn-primary, #d29922)",
+			failing: "var(--dsw-alias-state-error-primary, #e5484d)"
+		};
+
+		/** The PR token's parts, so its plain text and its coloured form cannot drift. */
+		function prTokenParts(info) {
 			const pr = info.pr;
-			if (pr === void 0 || pr === null || pr.number === void 0) return "";
+			if (pr === void 0 || pr === null || pr.number === void 0) return null;
 			const state = PR_STATE_GLYPH[pr.state] === void 0 ? "none" : pr.state;
-			const glyph = PR_STATE_GLYPH[state];
-			return " PR#" + pr.number + (glyph === "" ? "" : " " + glyph) + (pr.draft === true ? " draft" : "");
+			return {
+				number: " PR#" + pr.number,
+				glyph: PR_STATE_GLYPH[state],
+				colour: PR_STATE_COLOUR[state] ?? META_STYLE.color,
+				draft: pr.draft === true ? " draft" : ""
+			};
 		}
 
 		/** The token's accessible name: "pull request 142, checks failing, draft". */
 		function prTokenLabel(info) {
 			const pr = info.pr;
 			if (pr === void 0 || pr === null || pr.number === void 0) return void 0;
-			const state = PR_STATE_LABEL[pr.state] === void 0 ? PR_STATE_LABEL.none : PR_STATE_LABEL[pr.state];
+			const state = prStateLabel(pr);
 			return "pull request " + pr.number + ", " + state + (pr.draft === true ? ", draft" : "");
 		}
 
@@ -424,90 +382,6 @@ window.__ModuleLoader__.load({
 			whiteSpace: "nowrap"
 		};
 
-		/**
-		 * Status mark, SHARED BY BOTH SURFACES: the same shape in the same fill
-		 * wherever it appears, so the sidebar row and the input chip read
-		 * identically. The FILL is the status colour; the SHAPE carries
-		 * worktree-ness — a circle for a main checkout, a tree for a linked
-		 * worktree — so the two facts never compete for the same channel.
-		 *
-		 * Drawn rather than typed because 🌳 is a COLOUR EMOJI: CSS cannot tint
-		 * its leaves, and a mark that carries the status has to be paintable.
-		 * Three overlapping crown lobes plus a trunk stay legible at this size.
-		 *
-		 * Neither colour nor shape is the only channel: the accessible name
-		 * states both.
-		 */
-		function StatusMark({ info }) {
-			const status = badgeStatus(info);
-			const fill = MARK_FILL[status];
-			const isWorktree = info.isWorktree === true;
-			const svg = {
-				// 14px, NOT 12px: a colour emoji draws well above its nominal size — the
-				// 🔴/🟡/🟢 dot this replaces put down ~13-14px of ink at the surfaces'
-				// 12px font-size, so a 12px box read as a shrunken dot.
-				width: 14,
-				height: 14,
-				viewBox: "0 0 12 12",
-				role: "img",
-				"aria-label":
-					(isWorktree ? "git worktree: " : "git: ") +
-					STATUS_LABEL[status] +
-					// a followed checkout is not where the conversation lives, and the
-					// accessible name says so — the session registered it explicitly
-					(info.worktreeFollowed === true ? " (registered for this session)" : ""),
-				focusable: "false",
-				style: { flex: "none", display: "block", color: META_STYLE.color }
-			};
-			if (!isWorktree) {
-				// a plain filled disc: this is a main checkout. It fills its box so the
-				// ink lands at the size the emoji dot used to.
-				return react_jsx_runtime.jsx("svg", { ...svg, children: react_jsx_runtime.jsx("circle", { cx: 6, cy: 6, r: 5.5, fill }) });
-			}
-			return react_jsx_runtime.jsxs("svg", {
-				...svg,
-				children: [
-					// trunk first, so the crown's lobes overlap and join it. These are the
-					// 12px-era coordinates scaled 1.15 about the tree's centre, so its ink
-					// stays comparable to the disc's instead of reading small beside it.
-					react_jsx_runtime.jsx("rect", { key: "trunk", x: 5.25, y: 7.3, width: 1.5, height: 4.14, rx: 0.63, fill: "currentColor" }),
-					react_jsx_runtime.jsx("circle", { key: "crown-1", cx: 6, cy: 3.62, r: 3.57, fill }),
-					react_jsx_runtime.jsx("circle", { key: "crown-2", cx: 3.24, cy: 5.46, r: 2.53, fill }),
-					react_jsx_runtime.jsx("circle", { key: "crown-3", cx: 8.76, cy: 5.46, r: 2.53, fill })
-				]
-			});
-		}
-
-		/**
-		 * The ONE thing this conversation needs from you, or "" when it needs
-		 * nothing.
-		 *
-		 * A session row's job is TRIAGE — "does this need me?" — so this is not the
-		 * chip's status restated: it is a short imperative, present only when an
-		 * action is genuinely warranted, first match wins. Silence is the common and
-		 * correct answer: uncommitted work is a state rather than a chore, and DRAFT,
-		 * BLOCKED, BEHIND, UNSTABLE and UNKNOWN are things to wait for, not to do.
-		 *
-		 * `merge` keys on GitHub's OWN verdict (`mergeStateStatus === "CLEAN"`) rather
-		 * than a checks-plus-reviews judgement assembled here: mergeability depends on
-		 * branch protection and required reviews, which is the forge's business. A PR
-		 * read that could not answer has no `mergeState`, so it stays silent.
-		 */
-		function actionToken(info) {
-			if (info === void 0 || info === null || info.git !== true) return "";
-			if ((info.unmergedFiles || 0) > 0) return "resolve";
-			const pr = info.pr === void 0 || info.pr === null ? void 0 : info.pr;
-			if (pr !== void 0) {
-				if (pr.state === "failing") return "fix CI";
-				if (pr.review === "CHANGES_REQUESTED") return "review";
-				if (pr.mergeState === "CLEAN") return "merge";
-			}
-			// diverged counts as behind: reconciling is the action either way
-			if ((info.behind || 0) > 0) return "pull";
-			if ((info.ahead || 0) > 0) return "push";
-			return "";
-		}
-
 		/**
 		 * Session-row badge — the ACTION, and nothing else:
 		 *   Session title…                                        merge
@@ -534,70 +408,132 @@ window.__ModuleLoader__.load({
 		 * below reuses THIS request rather than issuing its own.
 		 */
 		/**
-		 * Action -> colour. Colour here means SEVERITY — how much this needs you —
-		 * rather than identity: a broken build and a conflict are the loud ones, a
-		 * requested review is a nudge, `merge` is the all-clear, and routine sync is
-		 * the quiet end of the same ramp rather than outside it. That last move is
-		 * deliberate: grey put `push` below the threshold of notice, so the one row
-		 * that wanted a decision read as a timestamp. The WORD remains the channel
-		 * (colour only reinforces it), and the tokens are the app's own, so both
-		 * themes work.
+		 * Severity -> colour. The NODE half decides the severity
+		 * (`error` | `warn` | `success` | `business`) and every surface paints from
+		 * that one field, so the chip and the row cannot disagree about how loud a
+		 * state is. Colour here means SEVERITY — how much this needs you — rather
+		 * than identity: a broken build and a conflict are the loud ones, a requested
+		 * review is a nudge, `merge` is the all-clear, and routine work is the quiet
+		 * blue end of the same ramp rather than outside it. The WORD remains the
+		 * channel (colour only reinforces it), and the tokens are the app's own, so
+		 * both themes work.
 		 */
-		const ACTION_COLOUR = {
-			resolve: "var(--dsw-alias-state-error-primary, #e5484d)",
-			"fix CI": "var(--dsw-alias-state-error-primary, #e5484d)",
-			review: "var(--dsw-alias-state-warn-primary, #d29922)",
-			merge: "var(--dsw-alias-state-success-primary, #30a46c)",
-			pull: "var(--dsw-alias-state-business-primary, #3b82f6)",
-			push: "var(--dsw-alias-state-business-primary, #3b82f6)"
+		const SEVERITY_FILL = {
+			error: "var(--dsw-alias-state-error-primary, #e5484d)",
+			warn: "var(--dsw-alias-state-warn-primary, #d29922)",
+			success: "var(--dsw-alias-state-success-primary, #30a46c)",
+			business: "var(--dsw-alias-state-business-primary, #3b82f6)"
 		};
 
 		/**
-		 * Action -> glyph. The SHAPE channel, beside the colour: a glyph makes the
-		 * row readable before the word is parsed, and it survives a monochrome or
-		 * colour-blind view where the tint alone would not. Keys mirror
-		 * ACTION_COLOUR exactly; a missing entry degrades to the bare word.
+		 * Action -> TEXT glyph. The SHAPE channel for the five tokens whose icon is a
+		 * character. The other six are DRAWN (see DRAWN_ICONS) and deliberately have
+		 * NO entry here: a leftover text fallback would be a second, unreachable
+		 * rendering of the same icon — and for `merge` it was exactly the check mark
+		 * the drawn Octicon replaced.
+		 *
+		 * A missing entry degrades to the bare word.
 		 */
 		const ACTION_GLYPH = {
+			resume: "\u23F5",
 			resolve: "!",
 			"fix CI": "\u2717",
 			review: "\u25C6",
-			merge: "\u2713",
-			pull: "\u2193",
-			push: "\u2191"
+			commit: "\u271A"
 		};
 
 		/**
-		 * The action's own style, on top of META_STYLE:
-		 *  - `marginLeft: auto` floats it right, so a column of actions lines up down
-		 *    the sidebar — that alignment is what makes the list scannable;
-		 *  - `marginRight` keeps it clear of the relative time beside it (the first cut
-		 *    sat flush and read `merge11m`);
-		 *  - weight 600 plus a little padding make it a PILL, so the token reads as a
-		 *    tag rather than as loose text the eye can skip;
-		 *  - the radius is the app's own small one, so the pill belongs to the shell.
+		 * The icons DRAWN rather than typed, each with its own grid and render size.
 		 *
-		 * The FILL is not set here: it is the action's own colour at low alpha, which
-		 * only SessionGitBadge can build.
+		 * `↑ ↓ ⇄ ↻` are hairline strokes in the shell's font, and no weight or size
+		 * makes them as solid as the filled glyphs; these four are paths on a 12x12
+		 * grid, painted with `currentColor`, so each arrow matches the text's weight
+		 * and centres on it. `in sync` is drawn for the same reason: the idle disc
+		 * must be exactly round, not a font's idea of a circle.
+		 *
+		 * `merge` is Remix Icon's `git-merge-line` (24x24), vendored VERBATIM rather
+		 * than redrawn, and rendered at 16px to fill the row's 16px leading cell.
+		 * Unicode has no merge glyph at all, so every tool draws this shape family.
+		 * Its ink is inset (about 16 of its 24 units), so at 16px it puts down
+		 * ~10.7px — the arrows' weight, which a 12px render would miss.
+		 *
+		 * The other five tokens stay text.
 		 */
-		const ACTION_STYLE = {
-			flex: "none",
-			marginLeft: "auto",
-			marginRight: "8px",
-			fontWeight: 600,
-			padding: "0 6px",
-			borderRadius: "var(--dsw-radius-sm, 4px)"
+		const DRAWN_ICONS = {
+			push: { size: 12, viewBox: "0 0 12 12", shapes: [{ d: "M6 1 L10.6 6.6 H7.5 V11 H4.5 V6.6 H1.4 Z" }] },
+			pull: { size: 12, viewBox: "0 0 12 12", shapes: [{ d: "M6 11 L1.4 5.4 H4.5 V1 H7.5 V5.4 H10.6 Z" }] },
+			sync: {
+				size: 12,
+				viewBox: "0 0 12 12",
+				shapes: [
+					{ d: "M1.5 3.4 H8.4 V2 L11 4 L8.4 6 V4.6 H1.5 Z" },
+					{ d: "M10.5 8.6 H3.6 V10 L1 8 L3.6 6 V7.4 H10.5 Z" }
+				]
+			},
+			update: {
+				size: 12,
+				viewBox: "0 0 12 12",
+				shapes: [
+					{ d: "M6 1.9 A4.1 4.1 0 1 1 1.9 6", stroke: true },
+					{ d: "M4.3 0.4 L8.3 1.9 L4.3 3.4 Z" }
+				]
+			},
+			"in sync": { size: 12, viewBox: "0 0 12 12", shapes: [{ circle: true }] },
+			// Remix Icon `git-merge-line` (24x24), vendored verbatim from
+			// https://github.com/Remix-Design/RemixIcon/blob/master/icons/Development/git-merge-line.svg
+			// EXP-1: this is an experiment. Swapping back to GitHub's Octicon
+			// `git-merge` is this one entry — a 16x16 grid, same shape family.
+			merge: {
+				size: 16,
+				viewBox: "0 0 24 24",
+				shapes: [{ d: "M7.10508 8.78991C7.45179 10.0635 8.61653 11 10 11H14C16.4703 11 18.5222 12.7915 18.9274 15.1461C20.1303 15.5367 21 16.6668 21 18C21 19.6569 19.6569 21 18 21C16.3431 21 15 19.6569 15 18C15 16.7334 15.7849 15.6501 16.8949 15.2101C16.5482 13.9365 15.3835 13 14 13H10C8.87439 13 7.83566 12.6281 7 12.0004V15.1707C8.16519 15.5825 9 16.6938 9 18C9 19.6569 7.65685 21 6 21C4.34315 21 3 19.6569 3 18C3 16.6938 3.83481 15.5825 5 15.1707V8.82929C3.83481 8.41746 3 7.30622 3 6C3 4.34315 4.34315 3 6 3C7.65685 3 9 4.34315 9 6C9 7.26661 8.21506 8.34988 7.10508 8.78991ZM6 7C6.55228 7 7 6.55228 7 6C7 5.44772 6.55228 5 6 5C5.44772 5 5 5.44772 5 6C5 6.55228 5.44772 7 6 7ZM6 19C6.55228 19 7 18.5523 7 18C7 17.4477 6.55228 17 6 17C5.44772 17 5 17.4477 5 18C5 18.5523 5.44772 19 6 19ZM18 19C18.5523 19 19 18.5523 19 18C19 17.4477 18.5523 17 18 17C17.4477 17 17 17.4477 17 18C17 18.5523 17.4477 19 18 19Z" }]
+			}
 		};
 
+		/**
+		 * The icon NODE: a drawn shape for the six drawn tokens, a text glyph for the
+		 * rest. The parent span carries the accessible name, so the drawing is
+		 * decoration (`aria-hidden`).
+		 */
+		function actionGlyphNode(token) {
+			const icon = DRAWN_ICONS[token];
+			if (icon === void 0) return ACTION_GLYPH[token] ?? token;
+			return react_jsx_runtime.jsx("svg", {
+				viewBox: icon.viewBox,
+				width: icon.size,
+				height: icon.size,
+				"aria-hidden": true,
+				focusable: "false",
+				style: { display: "block", flex: "none", color: "inherit" },
+				children: icon.shapes.map((shape, index) => shape.circle === true
+					? react_jsx_runtime.jsx("circle", {
+						cx: shape.cx ?? 6,
+						cy: shape.cy ?? 6,
+						r: shape.r ?? 5,
+						fill: "currentColor"
+					}, "shape-" + index)
+					: react_jsx_runtime.jsx("path", shape.stroke === true
+						? { d: shape.d, fill: "none", stroke: "currentColor", strokeWidth: 2, strokeLinecap: "round", strokeLinejoin: "round" }
+						: { d: shape.d, fill: "currentColor" }, "shape-" + index))
+			});
+		}
+
+		/**
+		 * The icon's own type style, for the TEXT glyphs only. A drawn arrow is a
+		 * fixed 12px box, so size and weight do not apply to it; the six text glyphs
+		 * sit one pixel larger than the surrounding 12px text.
+		 */
+		const GLYPH_TEXT = { fontSize: "13px" };
+
 		/**
 		 * 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".
+		 * mid-turn without the row slot having to carry it. A shell that does not
+		 * seed that kit leaves the prop undefined: then we cannot know, and the
+		 * glyph 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).
@@ -608,8 +544,8 @@ window.__ModuleLoader__.load({
 		}
 
 		/**
-		 * 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
+		 * Report the idle gate ONCE, the way the boot diagnostics report 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.
 		 */
@@ -626,60 +562,357 @@ window.__ModuleLoader__.load({
 		}
 
 		/**
-		 * The action badge: a severity-tinted pill carrying a glyph and the word — 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 leading-cell token glyph — the row's compact signal, on upstream's
+		 * own `sidebar.session.row.leading` seat. No patch and no seam.
 		 *
-		 * 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.
+		 * It asks for PR state too (`pr: true`), the SAME query the row card uses,
+		 * so the glyph shows the same PR tokens (`merge`, `review`, `fix CI`) as
+		 * the card — not only the local ones. The matching query string means the
+		 * glyph and the card share one cache entry and one in-flight read. The
+		 * price is one forge read per row per TTL.
+		 *
+		 * Geometry: the cell is `width:16px; flex:none` and the row has `gap:0`, so
+		 * a word would overflow into the title. Only one glyph is drawn, and no
+		 * wrapper changes the cell's box.
+		 *
+		 * The glyph is NOT `aria-hidden`: with no word beside it, it is the
+		 * accessible name. With nothing to say the cell renders NOTHING: no token
+		 * means no action, so there is no icon and no colour to explain.
+		 *
+		 * It carries NO hover of its own. The row is already a HoverCard anchor,
+		 * and the explanation rides the row's own card (SessionGitDetail) — so
+		 * hovering the glyph shows exactly what hovering the session line shows.
 		 */
-		function SessionGitBadge({ sessionId, useSessions }) {
+		function LeadingTokenGlyph({ 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;
-			const colour = ACTION_COLOUR[action];
-			const style = { ...META_STYLE, ...ACTION_STYLE };
-			if (colour !== void 0) {
-				style.color = colour;
-				// The pill's fill is the action's own colour at low alpha, so severity is
-				// a wash a row can carry rather than a shout. color-mix is a current-browser
-				// feature: where it is unsupported the pill keeps its geometry, colour,
-				// glyph and weight, and only the tint is lost.
-				style.background = `color-mix(in srgb, ${colour} 18%, transparent)`;
+			const token = info.rowToken;
+			if (typeof token === "string" && token !== "") {
+				const colour = SEVERITY_FILL[info.rowSeverity];
+				return react_jsx_runtime.jsx("span", {
+					role: "img",
+					"aria-label": "git action: " + token,
+					// The fallback overlay in the SAME cell is suppressed by this
+					// marker, so a status transition can never paint two glyphs.
+					"data-git-badge-leading": "",
+					style: { ...META_STYLE, ...(colour === void 0 ? {} : { color: colour }), ...GLYPH_TEXT, display: "inline-flex", alignItems: "center" },
+					children: actionGlyphNode(token)
+				});
 			}
-			// The glyph is DECORATION: `aria-hidden` keeps the accessible name the bare
-			// word, and the trailing space in its own text separates the two on screen
-			// without a margin. A missing glyph entry degrades to the word alone.
-			const glyph = ACTION_GLYPH[action];
-			return react_jsx_runtime.jsxs("span", {
-				style,
-				children:
-					glyph === void 0
-						? action
-						: [react_jsx_runtime.jsx("span", { "aria-hidden": true, children: `${glyph} ` }, "glyph"), action]
-			});
+			return null;
 		}
 
+		//#region leading-cell fallback (a solid status dot owns the cell)
+		/**
+		 * The leading cell's SOLID status dots. Upstream replaces the whole
+		 * `sidebar.session.row.leading` seat with one of these whenever the row's
+		 * primary state is not idle, so the plugin's glyph is not mounted at all:
+		 * `done` (green) when a background turn finished unread, `warning` (orange)
+		 * when a pending interaction waits. `ongoing` is the running spinner, an
+		 * `svg` with no solid dot, and stays upstream's alone.
+		 */
+		const ROW_FALLBACK_DOT = '[data-state="done"], [data-state="warning"]';
+
 		/**
-		 * Session-row hover-card line — everything the action word cannot say: which
-		 * checkout the row's status describes, and which pull request the action
-		 * refers to. It renders through the upstream sidebar.session.row.hover
-		 * seat, inside the card upstream already opens for a row.
+		 * The fallback's stylesheet. The plugin paints the token into the occupied
+		 * 16px cell from a marker attribute, so it adds NO foreign node to a
+		 * React-managed cell: the dot element steps aside and a `::after` draws the
+		 * node half's glyph, coloured by the severity custom property.
 		 *
-		 * This matters MORE now that the row shows only an imperative: `merge` with no
-		 * way to see merge WHAT would be a nag rather than a hint, so the line appears
-		 * whenever there is something to name — a worktree, a pull request, or both.
+		 * `:has()` keeps the real seat and the fallback exclusive even during the
+		 * one commit where a row flips back to idle: a cell that already holds
+		 * `data-git-badge-leading` never paints the overlay. A browser without
+		 * `:has()` drops the whole rule, so the fallback is simply absent — it can
+		 * never double-draw.
+		 */
+		const ROW_FALLBACK_OVERLAY = "[data-git-badge-overlay]:not(:has([data-git-badge-leading]))";
+		const ROW_FALLBACK_CSS = [
+			ROW_FALLBACK_OVERLAY + " > span:first-child > " + ROW_FALLBACK_DOT + " { display: none; }",
+			ROW_FALLBACK_OVERLAY + " > span:first-child::after {",
+			'  content: var(--git-badge-glyph, "");',
+			"  display: inline-flex;",
+			"  align-items: center;",
+			"  justify-content: center;",
+			"  width: 16px;",
+			"  height: 20px;",
+			"  color: var(--git-badge-color, currentColor);",
+			"  font-size: 13px;",
+			"  line-height: 1;",
+			"}",
+			ROW_FALLBACK_OVERLAY + "[data-git-badge-drawn] > span:first-child::after {",
+			'  content: "";',
+			"  background-color: var(--git-badge-color, currentColor);",
+			"  -webkit-mask-image: var(--git-badge-mask-src);",
+			"  mask-image: var(--git-badge-mask-src);",
+			"  -webkit-mask-repeat: no-repeat;",
+			"  mask-repeat: no-repeat;",
+			"  -webkit-mask-position: center;",
+			"  mask-position: center;",
+			"  -webkit-mask-size: var(--git-badge-mask-size, 12px);",
+			"  mask-size: var(--git-badge-mask-size, 12px);",
+			"}"
+		].join("\n");
+
+		/**
+		 * One `DRAWN_ICONS` entry as a CSS mask URL, so the fallback paints the
+		 * EXACT artwork the real seat draws. The mask supplies the shape and the
+		 * element's `background-color` supplies the severity colour, which is why
+		 * the SVG is painted black: only its alpha is read.
+		 */
+		function glyphMaskDataUri(icon) {
+			const shapes = icon.shapes.map((shape) => {
+				if (shape.circle === true) return '<circle cx="6" cy="6" r="5"/>';
+				if (shape.stroke === true) return '<path d="' + shape.d + '" fill="none" stroke="#000" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>';
+				return '<path d="' + shape.d + '" fill="#000"/>';
+			}).join("");
+			const svg = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="' + icon.viewBox + '">' + shapes + "</svg>";
+			return 'url("data:image/svg+xml;charset=utf-8,' + encodeURIComponent(svg) + '")';
+		}
+
+		/**
+		 * The fallback's mark for a token, or undefined when the dot should stay.
 		 *
-		 * It makes no request of its own: the same `{ pr: true }` query as the badge
-		 * above resolves to the same cache key, so a card that mounts for every row
-		 * still costs one fetch per row, and a cold cache is served by the badge's
-		 * own in-flight request. That is why the badge must keep asking for `pr=1`.
+		 * `in sync` is deliberately excluded: it is a disc, the row's own dot is
+		 * also a dot, and replacing an unread marker with "nothing to do" would
+		 * throw away the only signal that the turn ended. Only a real action earns
+		 * the cell.
+		 */
+		function fallbackGlyph(token, severity) {
+			if (typeof token !== "string" || token === "" || token === "in sync") return void 0;
+			const colour = SEVERITY_FILL[severity];
+			const drawn = DRAWN_ICONS[token];
+			if (drawn !== void 0) return { mask: glyphMaskDataUri(drawn), size: drawn.size + "px", colour };
+			const glyph = ACTION_GLYPH[token];
+			if (glyph === void 0) return void 0;
+			return { glyph, colour };
+		}
+
+		/** Write one mark onto the row element. */
+		function applyFallbackMark(host, mark) {
+			host.setAttribute("data-git-badge-overlay", "");
+			if (mark.mask !== void 0) {
+				host.setAttribute("data-git-badge-drawn", "");
+				host.style.setProperty("--git-badge-mask-src", mark.mask);
+				host.style.setProperty("--git-badge-mask-size", mark.size);
+				host.style.removeProperty("--git-badge-glyph");
+			} else {
+				host.removeAttribute("data-git-badge-drawn");
+				host.style.removeProperty("--git-badge-mask-src");
+				host.style.removeProperty("--git-badge-mask-size");
+				// JSON.stringify keeps the quotes `content: var(...)` needs.
+				host.style.setProperty("--git-badge-glyph", JSON.stringify(mark.glyph));
+			}
+			if (mark.colour === void 0) host.style.removeProperty("--git-badge-color");
+			else host.style.setProperty("--git-badge-color", mark.colour);
+		}
+
+		/** Remove every trace of a mark, so the row is exactly as upstream left it. */
+		function clearFallbackMark(host) {
+			if (host === void 0 || host === null) return;
+			host.removeAttribute("data-git-badge-overlay");
+			host.removeAttribute("data-git-badge-drawn");
+			host.style.removeProperty("--git-badge-glyph");
+			host.style.removeProperty("--git-badge-mask-src");
+			host.style.removeProperty("--git-badge-mask-size");
+			host.style.removeProperty("--git-badge-color");
+		}
+
+		/** The row (`[data-row-key]`) an element sits in, or undefined. */
+		function rowHost(node) {
+			const closest = node?.closest;
+			if (typeof closest !== "function") return void 0;
+			return closest.call(node, "[data-row-key]") ?? void 0;
+		}
+
+		/**
+		 * The whole fallback decision in one testable call: does the cell hold a
+		 * SOLID dot, and does the node half have an action to show? The cell is the
+		 * authority, so no client-side copy of upstream's status precedence can
+		 * drift. Returns whether the overlay is on.
+		 */
+		function syncRowFallback(host, info) {
+			if (host === void 0 || host === null) return false;
+			const cell = host.firstElementChild;
+			const occupied = cell !== void 0 && cell !== null && typeof cell.querySelector === "function" && cell.querySelector(ROW_FALLBACK_DOT) !== null;
+			if (!occupied) {
+				clearFallbackMark(host);
+				return false;
+			}
+			const token = info !== void 0 && info !== null && info.git === true ? info.rowToken : void 0;
+			const mark = fallbackGlyph(token, info?.rowSeverity);
+			if (mark === void 0) {
+				clearFallbackMark(host);
+				return false;
+			}
+			applyFallbackMark(host, mark);
+			return true;
+		}
+
+		/** One stylesheet per page; the loader tags it for its own bookkeeping. */
+		let rowFallbackStyle = false;
+		function ensureRowFallbackStyle() {
+			if (rowFallbackStyle) return;
+			if (typeof document === "undefined" || document.head === void 0 || document.head === null) return;
+			try {
+				const style = document.createElement("style");
+				style.setAttribute("data-plugin", "dsh-git-badge");
+				style.textContent = ROW_FALLBACK_CSS;
+				document.head.appendChild(style);
+				rowFallbackStyle = true;
+			} catch {
+				// a missing or closed <head> must never break the badge
+			}
+		}
+
+		/**
+		 * The marker that carries the fallback. It MUST ride
+		 * `sidebar.workspaces.session.row.action`, because that strip is hidden by
+		 * CSS rather than unmounted: it is the one per-row seat React mounts in
+		 * every state, so it is the only place from which a row can be marked while
+		 * upstream's dot owns the leading cell. It renders a hidden span and adds
+		 * no button.
+		 */
+		function RowFallbackGlyph({ sessionId }) {
+			const ref = react.useRef(null);
+			const [occupied, setOccupied] = react.useState(false);
+			// `enabled` is the LAZY gate: a row with no solid dot keeps costing
+			// nothing, exactly as it did before the fallback existed.
+			const info = useGitStatus(sessionId === void 0 ? void 0 : { kind: "session", id: sessionId }, { pr: true, enabled: occupied });
+			react.useEffect(() => {
+				ensureRowFallbackStyle();
+				const host = rowHost(ref.current);
+				if (host === void 0) return;
+				const cell = host.firstElementChild;
+				if (cell === void 0 || cell === null || typeof cell.querySelector !== "function") return;
+				const sync = () => setOccupied(cell.querySelector(ROW_FALLBACK_DOT) !== null);
+				sync();
+				if (typeof MutationObserver !== "function") return;
+				const observer = new MutationObserver(sync);
+				// The dot swaps in as a child; a state change edits `data-state` in
+				// place, so both must be watched. The row's own attributes are NOT
+				// observed, which is what keeps the mark from re-triggering itself.
+				observer.observe(cell, { childList: true, subtree: true, attributes: true, attributeFilter: ["data-state"] });
+				return () => observer.disconnect();
+			}, [sessionId]);
+			// Layout effect: the mark lands in the same commit that reveals the dot,
+			// so the fallback does not flash the green/orange dot first.
+			react.useLayoutEffect(() => {
+				syncRowFallback(rowHost(ref.current), info);
+			}, [info, occupied]);
+			return react_jsx_runtime.jsx("span", { ref, "aria-hidden": true, style: { display: "none" } });
+		}
+		//#endregion
+
+		const CARD_CONTAINER = {
+			display: "flex",
+			flexDirection: "column",
+			gap: "4px",
+			fontSize: "12px",
+			lineHeight: "18px",
+			// Auto-width: the card fits its widest row instead of a guessed
+			// constant, capped at 600px. The Tooltip's maxWidth must stay >= the
+			// cap or IT becomes the clamp.
+			width: "max-content",
+			maxWidth: "600px"
+		};
+		const CARD_ROW = { display: "flex", gap: "8px", alignItems: "baseline" };
+		const CARD_LABEL = { color: "var(--dsw-alias-label-tertiary, #9ea7ad)", flex: "none", minWidth: "62px" };
+		const CARD_VALUE = { minWidth: 0, overflowWrap: "anywhere", whiteSpace: "normal" };
+		// The chip card's HEADER: the action sentence as a heading, not a labelled
+		// row. `fontWeight` is also the hook the suite uses to find it.
+		const CHIP_HEADER = { display: "flex", alignItems: "baseline", gap: "6px", fontWeight: 600 };
+		// A section rule between the checkout rows and the branch rows. The label
+		// makes the split explicit instead of leaving `state`/`base` to look like
+		// more checkout detail.
+		const CARD_DIVIDER = {
+			marginTop: "4px",
+			paddingTop: "6px",
+			borderTop: ".5px solid var(--dsw-alias-border-l4, #e4e8eb)",
+			color: "var(--dsw-alias-label-tertiary, #9ea7ad)",
+			fontSize: "10px",
+			lineHeight: "14px",
+			letterSpacing: ".08em",
+			textTransform: "uppercase"
+		};
+
+		/** One label/value row — the shape every hover body shares. */
+		function cardRow(label, value) {
+			return react_jsx_runtime.jsxs("div", {
+				style: CARD_ROW,
+				children: [
+					react_jsx_runtime.jsx("span", { style: CARD_LABEL, children: label }),
+					react_jsx_runtime.jsx("span", { style: CARD_VALUE, children: value })
+				]
+			}, label);
+		}
+
+		/** Push one label/value row unless the value is empty. */
+		function addRow(rows, label, value) {
+			if (value === void 0 || value === null || value === "") return;
+			rows.push(cardRow(label, value));
+		}
+
+		/**
+		 * The action SENTENCE as a raw value. SHARED by the session-row card
+		 * (actionRow wraps it in the card label/value shape) and the chip card
+		 * (actionHeader wraps it in a heading), so the two cannot describe the icon
+		 * differently. Returns undefined when the checkout has no token.
+		 *
+		 * The glyph is DECORATION here: the word follows it, so `aria-hidden` keeps
+		 * the accessible name the bare action.
+		 */
+		function actionRow(info) {
+			const token = info?.rowToken;
+			if (typeof token !== "string" || token === "") return void 0;
+			const why = typeof info.rowTokenWhy === "string" && info.rowTokenWhy !== "" ? info.rowTokenWhy : void 0;
+			const colour = SEVERITY_FILL[info.rowSeverity];
+			const value = [];
+			if (DRAWN_ICONS[token] !== void 0 || ACTION_GLYPH[token] !== void 0) {
+				value.push(react_jsx_runtime.jsx("span", {
+					"aria-hidden": true,
+					style: { color: colour === void 0 ? META_STYLE.color : colour, fontWeight: 700, display: "inline-flex", alignItems: "center" },
+					children: actionGlyphNode(token)
+				}, "action-glyph"));
+				value.push(" ");
+			}
+			value.push(token + (why === void 0 ? "" : " \u2014 " + why));
+			return value;
+		}
+
+		/**
+		 * The chip card's HEADER: the same sentence actionRow produces, rendered as a
+		 * heading so the checkout's verdict leads the card instead of sitting in a
+		 * labelled row. It calls actionRow, so the two surfaces cannot drift.
+		 */
+		function actionHeader(info) {
+			const value = actionRow(info);
+			if (value === void 0) return void 0;
+			return react_jsx_runtime.jsx("div", { style: CHIP_HEADER, children: value }, "action-header");
+		}
+
+		/**
+		 * Session-row hover card — everything the action glyph cannot say: what the
+		 * action means and why, which checkout the row's status describes, and which
+		 * pull request it refers to. It renders through the upstream
+		 * sidebar.session.row.hover seat, inside the card upstream already opens for
+		 * a row.
+		 *
+		 * LABEL/VALUE ROWS, the shape the chip card uses. The `action` row comes from
+		 * the shared actionRow() helper, so the two cards cannot describe the icon
+		 * differently; `checkout` and `pull request` follow.
+		 *
+		 * This matters MORE now that the row shows only a glyph: `merge` with no way
+		 * to see merge WHAT would be a nag rather than a hint, so the card renders
+		 * whenever there is something to name — the row's action, a worktree, a pull
+		 * request, or any combination.
+		 *
+		 * It makes no request of its own: the same `{ pr: true }` query as the
+		 * leading glyph resolves to the same cache key, so a card that mounts for
+		 * every row still costs one fetch per row, and a cold cache is served by
+		 * the glyph's own in-flight request.
 		 *
 		 * Only a WORKTREE's checkout is spelled out. For a main checkout the branch is
 		 * the ordinary case and repeating it on every session's card would be noise;
@@ -688,18 +921,35 @@ window.__ModuleLoader__.load({
 		function SessionGitDetail({ sessionId }) {
 			const info = useGitStatus(sessionId === void 0 ? void 0 : { kind: "session", id: sessionId }, { pr: true });
 			if (info === void 0 || info.git !== true) return null;
-			const bits = [];
+			const rows = [];
+			const add = (label, value) => addRow(rows, label, value);
+			// The HEADER, the shape the chip card leads with: the same sentence from
+			// the same actionRow, so the two cards cannot describe the icon
+			// differently, and the sentence gains the 62px label column's width.
+			const header = actionHeader(info);
+			if (header !== void 0) rows.push(header);
 			if (info.isWorktree === true) {
+				// WHICH tree, not just that there is one: the row's glyph cannot say
+				// it, and the branch is ordinary for a main checkout.
 				const name = typeof info.worktreeName === "string" ? info.worktreeName : "";
-				const checkout = [name === "" ? String(info.branch) : name + " on " + info.branch];
-				// the node half followed this tree because it is the one whose branch
-				// has the open PR — say so, because nothing on the row can
-
-				bits.push("checkout: " + checkout.join(" \u00B7 "));
+				add("checkout", name === "" ? String(info.branch) : name + " on " + info.branch);
 			}
-			const pr = formatPrDetail(info.pr);
-			if (pr !== void 0) bits.push("pull request " + pr);
-			return bits.length === 0 ? null : react_jsx_runtime.jsx("span", { style: META_STYLE, children: bits.join(" \u00B7 ") });
+			// The dirty breakdown, so a higher-ranked token cannot hide uncommitted
+			// work. formatFileBreakdown says "clean" when there is none; a clean row
+			// keeps its short card.
+			const changes = formatFileBreakdown(info);
+			if (changes !== "clean") add("changes", changes);
+			add("pull request", formatPrDetail(info.pr));
+			if (rows.length === 0) return null;
+			// The row's hover card is upstream's FIXED-WIDTH box: HoverCard.module.css
+			// pins `.card` to 244px. `width: max-content` (CARD_CONTAINER) would
+			// overflow it, so the stack FILLS the box instead and the value cells wrap
+			// inside it. The chip card is different — its Tooltip sizes to the content,
+			// so it keeps max-content.
+			return react_jsx_runtime.jsx("div", {
+				style: { ...CARD_CONTAINER, width: "100%", maxWidth: "100%" },
+				children: rows
+			});
 		}
 
 		/**
@@ -722,7 +972,7 @@ window.__ModuleLoader__.load({
 		/** The PR's full state as text, for the card: "#142 · checks failing · draft · review approved". */
 		function formatPrDetail(pr) {
 			if (pr === void 0 || pr === null || pr.number === void 0) return void 0;
-			const state = PR_STATE_LABEL[pr.state] === void 0 ? PR_STATE_LABEL.none : PR_STATE_LABEL[pr.state];
+			const state = prStateLabel(pr);
 			const bits = ["#" + pr.number, state];
 			if (pr.draft === true) bits.push("draft");
 			if (pr.review !== void 0) bits.push(String(pr.review).toLowerCase().replace(/_/g, " "));
@@ -810,50 +1060,6 @@ window.__ModuleLoader__.load({
 			});
 		}
 
-		/**
-		 * 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",
-			gap: "4px",
-			fontSize: "12px",
-			lineHeight: "18px",
-			// Auto-width: the card fits its widest row instead of a guessed
-			// constant, capped at 600px. The Tooltip's maxWidth must stay >= the
-			// cap or IT becomes the clamp.
-			width: "max-content",
-			maxWidth: "600px"
-		};
 		/**
 		 * The ✎n count's own hover body — the changed-file lists and NOTHING
 		 * else: the full card stays on the status mark, and this tooltip answers
@@ -925,35 +1131,31 @@ window.__ModuleLoader__.load({
 		}
 
 		/**
-		 * The branch name's own hover body — the branch's LINEAGE, and it ALWAYS
-		 * renders once the lazy detail payload has landed. Rows: upstream, sync
-		 * in words, the branch's last 10 commits (WHAT THIS BRANCH HAS, full
-		 * stop — no base-relative filtering, which empties on every push or
-		 * merge). The pull request has no row here — the chip's own PR token
-		 * already carries number, CI state and the link.
+		 * The branch LINEAGE rows, for the chip's one card. The state row always
+		 * renders (the pull-request verdict, or the base-branch note); the base row
+		 * follows when the counts are known; then the branch's last 10 commits
+		 * (WHAT THIS BRANCH HAS, full stop — no base-relative filtering, which
+		 * empties on every push or merge). The pull request has no row here — the
+		 * chip's own PR token already carries number, CI state and the link.
 		 */
-		function BranchLineage({ info }) {
+		function lineageRows(info) {
 			const rows = [];
-			const add = (label, value) => {
-				if (value === void 0 || value === null || value === "") return;
-				rows.push(cardRow(label, value));
-			};
-			// 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 add = (label, value) => addRow(rows, label, value);
+			// The STATE row always renders. The old upstream and sync rows spoke
+			// about the push axis (the branch's own remote), which the state row
+			// subsumes: the merge verdict is the fact that matters. The base counts
+			// stay a SEPARATE row below, so a reader never reconstructs either.
 			const pr = info?.pr;
-			const mergeParts = [];
+			const stateParts = [];
 			if (pr !== void 0 && pr !== null && pr.number !== void 0) {
-				if (pr.draft === true) mergeParts.push("blocked: draft");
+				if (pr.draft === true) stateParts.push("blocked: draft");
 				else if (pr.mergeState === "BLOCKED") {
-					mergeParts.push(pr.review === "REVIEW_REQUIRED" ? "blocked: review required"
+					stateParts.push(pr.review === "REVIEW_REQUIRED" ? "blocked: review required"
 						: pr.state === "failing" ? "blocked: checks failing"
 						: "blocked");
-				} else if (pr.state === "failing") mergeParts.push("blocked: checks failing");
-				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 if (pr.state === "failing") stateParts.push("blocked: checks failing");
+				else if (pr.mergeState === "CLEAN" || (pr.state === "passing" && pr.review === "APPROVED")) stateParts.push("ready to merge");
+				else if (pr.review === "REVIEW_REQUIRED") stateParts.push("blocked: review required");
 			} else if (info?.defaultBranch === true) {
 				// The default branch is the BASE, not a branch with a missing PR:
 				// pull requests merge INTO it and none is ever opened FROM it, so
@@ -961,18 +1163,21 @@ window.__ModuleLoader__.load({
 				// exist. The node half computes `defaultBranch` for exactly this
 				// suppression (see the comment where it is set in lib/index.js);
 				// until now only the action rules consulted it, not this row.
-				mergeParts.push("base branch \u00B7 pull requests merge into this");
+				stateParts.push("base branch \u00B7 pull requests merge into this");
 			} else {
-				mergeParts.push("no pull request");
+				stateParts.push("no pull request");
 			}
-			// The counts are this branch's standing against its BASE, so on the
-			// base itself they are self-referential ("N ahead, M behind main" while
-			// ON main) and the divergence they would state is already the chip's own
-			// \u2191a \u2193b token. Suppress them on the default branch, with or without a PR.
+			// The state row states the PR verdict and nothing else.
+			add("state", stateParts.join(" \u00B7 "));
+			// The counts are this branch's standing against its BASE, so on the base
+			// itself they are self-referential ("N ahead, M behind main" while ON
+			// main) and the divergence they would state is already the chip's own
+			// \u2191a \u2193b token. Suppress them on the default branch, with or without a
+			// PR. A SEPARATE row from state: whether the PR can merge and how far the
+			// branch is from its base are two facts, so neither hides the other.
 			if (info?.defaultBranch !== true && (info?.mainAhead !== void 0 || info?.mainBehind !== void 0)) {
-				mergeParts.push((info.mainAhead || 0) + " ahead, " + (info.mainBehind || 0) + " behind main");
+				add("base", (info.mainAhead || 0) + " ahead, " + (info.mainBehind || 0) + " behind " + baseNameFor(info));
 			}
-			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
@@ -993,13 +1198,9 @@ window.__ModuleLoader__.load({
 			}
 			// NO pull-request row: the chip's own PR token (number, CI state, link)
 			// carries it — a second rendering two pixels away is pure duplication.
-			return react_jsx_runtime.jsx("div", { style: CARD_CONTAINER, children: rows });
+			return rows;
 		}
 
-		const CARD_ROW = { display: "flex", gap: "8px", alignItems: "baseline" };
-		const CARD_LABEL = { color: "var(--dsw-alias-label-tertiary, #9ea7ad)", flex: "none", minWidth: "62px" };
-		const CARD_VALUE = { minWidth: 0, overflowWrap: "anywhere" };
-
 		// The host's plugin-card chrome, reproduced inline: its CSS module is not
 		// exported to plugins, so these values mirror PluginCard.module.css so our
 		// card sits in the same list as its siblings.
@@ -1045,52 +1246,43 @@ window.__ModuleLoader__.load({
 			flex: "none"
 		};
 
-		/** One label/value row — the shape every hover body shares. */
-		function cardRow(label, value) {
-			return react_jsx_runtime.jsxs("div", {
-				style: CARD_ROW,
-				children: [
-					react_jsx_runtime.jsx("span", { style: CARD_LABEL, children: label }),
-					react_jsx_runtime.jsx("span", { style: CARD_VALUE, children: value })
-				]
-			}, label);
-		}
-
-
 		/**
-		 * Hover card body for the input chip — INPUT CHIP ONLY. Pure presentation
-		 * over fields the status response already carries, plus the `detail=1`
-		 * additions (recent commits, stash) when they have arrived. Everything is
-		 * spelled out in text, so no fact here depends on a colour or a glyph.
+		 * The checkout's verdict rows, for the chip's one card — INPUT CHIP ONLY.
+		 * Pure presentation over fields the status response already carries, plus
+		 * the `detail=1` additions (recent commits, stash) when they have arrived.
+		 * Everything is spelled out in text, so no fact here depends on a colour or
+		 * a glyph.
 		 */
-		function HoverCard({ info, detail }) {
+		function statusRows(info, detail) {
 			// the detail payload is a superset of the plain one, so it wins when it
 			// has landed; until then the card still shows the base facts
 			const data = detail === void 0 ? info : detail;
 			const rows = [];
-			const add = (label, value) => {
-				if (value === void 0 || value === null || value === "") return;
-				rows.push(cardRow(label, value));
-			};
-			// The "action" row — the top line, in the card's ordinary row layout:
-			// 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 add = (label, value) => addRow(rows, label, value);
+			// The ACTION header, first: the SAME sentence the session-row card renders,
+			// from the same helper, so the chip card explains the icon the row shows.
+			// It is a heading, not a labelled row, so the verdict leads the card.
+			const header = actionHeader(data);
+			if (header !== void 0) rows.push(header);
+			// The "next step" row — 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
-				add("action", "/gh " + topAction.args + "  # " + topAction.what);
+				// plus what it does. The marker makes the one actionable line findable
+				// among the detail rows.
+				add("next step", "\u25B8 /gh " + topAction.args + "  # " + topAction.what);
 			}
 			// The branch lineage rows (branch, upstream, sync, pull request) moved
 			// to the branch NAME's hover — the card is the checkout's verdict, not
 			// the branch's CV. The branch name is also the chip's own text, so a
 			// card row for it was pure repetition.
-			add("files", formatFileBreakdown(info));
-			add("operation", info.operation === void 0 || info.operation === null ? void 0 : String(info.operation));
+			add("changes", formatFileBreakdown(data));
+			add("operation", data.operation === void 0 || data.operation === null ? void 0 : String(data.operation));
 			// WHICH checkout the badge describes, when it is a worktree. The chip shows
 			// the branch alone, so this row is the only place the tree is named.
 			add("worktree", worktreeDetail(data));
@@ -1102,10 +1294,36 @@ window.__ModuleLoader__.load({
 			// The conversation's OWN directory, present only when the badge is
 			// describing a followed worktree — the chip's branch and counts are the
 			// tree's in that case, so this is where the checkout's own state stays
-			// visible. Absent until the `detail=1` response lands, like commits/stash.
-			if (data.worktreeFollowed === true) add("checkout", formatCheckoutDetail(data.checkout));
+			// visible. Labelled `own checkout` because `checkout` now names the
+			// checkout a session-row card describes. Absent until the `detail=1`
+			// response lands, like commits/stash.
+			if (data.worktreeFollowed === true) add("own checkout", formatCheckoutDetail(data.checkout));
 			add("stash", data.stashCount === void 0 ? void 0 : data.stashCount + " stashed");
-			return react_jsx_runtime.jsx("div", { style: CARD_CONTAINER, children: rows });
+			return rows;
+		}
+
+		/**
+		 * The chip's ONE card, behind the leading cluster (the action glyph and the
+		 * branch name together). It stacks the checkout's verdict rows over the
+		 * branch's lineage rows, so one hover answers both "what is this checkout
+		 * doing" and "what is on this branch".
+		 *
+		 * One card, not two: the glyph and the branch are one target, and the branch
+		 * is the element that always exists — so a clean checkout, which has no
+		 * glyph, still opens the card from its branch name.
+		 */
+		function ChipCard({ info, detail }) {
+			const data = detail === void 0 ? info : detail;
+			const rows = statusRows(info, detail);
+			const lineage = lineageRows(data);
+			return react_jsx_runtime.jsx("div", {
+				style: CARD_CONTAINER,
+				children: [
+					...rows,
+					lineage.length === 0 ? null : react_jsx_runtime.jsx("div", { style: CARD_DIVIDER, children: "branch" }, "branch-divider"),
+					...lineage
+				]
+			});
 		}
 
 		//#region composer chip (upstream additive surface: conversation.input.left)
@@ -1128,211 +1346,152 @@ window.__ModuleLoader__.load({
 		}
 
 		/**
-		 * 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
-		 * half resolve the workspace, so this surface needs no `workspaces`
-		 * service, no cwd and no path plumbing at all. Works on unpatched installs
-		 * (conversation.input.left is an upstream additive slot), and stays useful
-		 * next to the sidebar rows because it is context-anchored ("where am I")
-		 * rather than surveying.
-		 *
-		 * This is the ONLY surface that asks the node half for the extras (`pr=1`
-		 * always, `detail=1` on hover), because it is the only one that renders
-		 * them — see targetQuery.
+		 * The chip's leading action glyph, or null when the checkout needs none.
+		 * The SAME token the sidebar row draws, in the node half's severity colour.
+		 * No token means NO GLYPH: a clean, synced checkout has no action to triage,
+		 * so it shows no icon rather than a decorative dot.
 		 */
+		function chipGlyphNode(info) {
+			const token = info.rowToken;
+			if (typeof token !== "string" || token === "") return null;
+			return react_jsx_runtime.jsx("span", {
+				key: "glyph",
+				role: "img",
+				"aria-label": "git action: " + token,
+				style: { color: SEVERITY_FILL[info.rowSeverity] ?? META_STYLE.color, flex: "none", ...GLYPH_TEXT, display: "inline-flex", alignItems: "center" },
+				children: actionGlyphNode(token)
+			});
+		}
+
 		/**
-		 * Set LATE (see apply) — never at apply() time, because the workspace
-		 * browser may not have declared the seam yet and a hint set then would
-		 * lie to patched installs for the whole session. Every chip render reads
-		 * it, so it reaches the DOM on the next refresh after it is set.
+		 * The shared anchor for the chip's two links — the branch compare link and
+		 * the PR token. Both were near-identical `<a>` elements; this is the one
+		 * copy of target, rel, cursor and handler wiring, so they cannot drift.
+		 * `underline` is the hover/focus state and `children` is the label.
 		 */
-		let seamHint = null;
+		function chipAnchor(props) {
+			return react_jsx_runtime.jsx("a", {
+				href: props.href,
+				target: "_blank",
+				rel: "noopener noreferrer",
+				"aria-label": props.ariaLabel,
+				onPointerEnter: props.onPointerEnter,
+				onPointerLeave: props.onPointerLeave,
+				onFocus: props.onFocus,
+				onBlur: props.onBlur,
+				style: {
+					color: "inherit",
+					textDecoration: props.underline ? "underline" : "none",
+					cursor: "pointer"
+				},
+				children: props.children
+			});
+		}
 
 		/**
-		 * Dismissal of the seam-absent notice, deliberately MODULE-level rather
-		 * than component state: a useState flag would un-dismiss when the chip
-		 * remounts (a sidebar toggle, a route change), and the × the user just
-		 * clicked would silently stop meaning anything. Session-scoped on
-		 * purpose — it resets at the next boot, so a seam that is STILL absent
-		 * asks again, while one fixed by apply + restart never nags at all.
+		 * The branch name, as a compare anchor when the detail payload vouches an
+		 * http(s) URL. The sync arrows ride WITH the branch: they are the branch's
+		 * standing against its upstream, so the same hover and the same link cover
+		 * them. The ✎n count keeps its own surface.
 		 */
-		let seamNoticeDismissed = false;
-
-		function ComposerGitChip({ sessionId }) {
-			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 -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.
-			const [hovered, setHovered] = react.useState(false);
-			// the PR token's own hover/focus state: it underlines on hover (and on
-			// focus) rather than at rest, and that underline is applied inline below
-			const [linkHover, setLinkHover] = react.useState(false);
-			// seamHint is module state set once, 5s after boot; dismissing it needs a
-			// re-render that no fetch will schedule, so the × bumps a counter here.
-			const [, bumpNotice] = react.useState(0);
-			const seamNotice = seamHint !== null && !seamNoticeDismissed ? seamHint : null;
-			// the branch link's hover underline — the PR token's pattern: the
-			// affordance appears on hover/focus, never at rest. Its OWN state, not
-			// the PR token's linkHover: two links sharing one flag would
-			// underline both when either is hovered.
-			const [branchLinkHover, setBranchLinkHover] = react.useState(false);
-			const detail = useGitStatus(target, { pr: true, detail: true, enabled: hovered });
-			if (info === void 0 || info.git !== true) return null;
+		function chipBranchInner(info, detail, isBranchLink, hoveredLink, setHovered, setHoveredLink) {
+			const sync = formatBaseSync(info);
+			const branchLabel = info.branch + sync;
+			if (!isBranchLink) return branchLabel;
+			return chipAnchor({
+				href: detail.compareUrl,
+				ariaLabel: "Compare " + info.branch + " with " + baseNameFor(info) + " on GitHub" + (sync === "" ? "" : ", " + (info.mainAhead || 0) + " ahead and " + (info.mainBehind || 0) + " behind " + baseNameFor(info)),
+				underline: hoveredLink === "branch",
+				onPointerEnter: () => setHoveredLink("branch"),
+				onPointerLeave: () => setHoveredLink(null),
+				onFocus: () => { setHovered(true); setHoveredLink("branch"); },
+				onBlur: () => setHoveredLink(null),
+				children: branchLabel
+			});
+		}
 
-			// The status mark wrapped in the chip's hover card — the card's ONLY
-			// anchor. Pointer rest here (and only here) enables the detail=1 fetch,
-			// 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 = withTooltip(
+		/**
+		 * The LEADING CLUSTER — the action glyph (when the checkout needs one) and
+		 * the branch name — wrapped in the one hover card. It is the chip card's ONLY
+		 * anchor: pointer rest here enables the detail=1 fetch.
+		 */
+		function chipLeadingHover(info, detail, tokenGlyph, branchInner, isBranchLink, setHovered) {
+			return 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 })
+					style: { display: "inline-flex", alignItems: "center", gap: "6px", flex: "none", cursor: isBranchLink ? "pointer" : "default" },
+					children: [tokenGlyph, react_jsx_runtime.jsx("span", { key: "branch", children: branchInner })]
 				}),
-				// 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
+				() => react_jsx_runtime.jsx(ChipCard, { info, detail }),
+				600
 			);
-			// 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. 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://");
-				// 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" + (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: {
-							color: "inherit",
-							textDecoration: branchLinkHover ? "underline" : "none",
-							cursor: "pointer"
-						},
-						children: label
-					})
-					: 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
-			// UntrackedList). It shares the mark's lazy detail fetch — resting on
-			// 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),
+		}
+
+		/**
+		 * The ✎n count as its OWN hover surface: a names-only tooltip. It shares
+		 * the mark's lazy detail fetch and degrades to a plain count without the
+		 * Tooltip primitive.
+		 */
+		function chipCountHover(info, detail, setHovered) {
+			const countText = formatFileCount(info);
+			const count = react_jsx_runtime.jsx("span", {
+				onPointerEnter: () => setHovered(true),
+				style: { cursor: "default" },
+				children: countText
+			});
+			const pending = detail === void 0 || detail === null;
+			return withTooltip(count, () => react_jsx_runtime.jsx(CountNames, { info: detail ?? info, pending }), 480);
+		}
+
+		/**
+		 * The PR token: the number, the CI state glyph and the GitHub link, and
+		 * nothing else. It has NO hover card of its own — the chip/branch card
+		 * already lists the branch's commits. ONE element, split so the STATE GLYPH
+		 * can take the CI colour while the number keeps the chip's muted colour.
+		 */
+		function chipPrTokenHover(info, hoveredLink, setHoveredLink) {
+			const prParts = prTokenParts(info);
+			const prToken = prParts === null ? null : [
+				prParts.number,
+				prParts.glyph === "" ? null : react_jsx_runtime.jsx("span", {
+					key: "pr-state",
+					style: { color: prParts.colour },
+					children: " " + prParts.glyph
+				}),
+				prParts.draft
+			];
+			const prUrl = prLinkUrl(info);
+			if (prUrl === void 0) {
+				// plain token: no hover, so it wires no pointer handlers
+				return react_jsx_runtime.jsx("span", {
+					// the glyph is not the only channel: the token says what the CI state IS
+					"aria-label": prTokenLabel(info),
 					style: { cursor: "default" },
-					children: countText
+					children: prToken
 				});
-				// 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", {
+			}
+			return chipAnchor({
+				href: prUrl,
+				ariaLabel: prTokenLabel(info) + ", opens on GitHub in a new tab",
+				underline: hoveredLink === "pr",
+				onPointerEnter: () => setHoveredLink("pr"),
+				onPointerLeave: () => setHoveredLink(null),
+				onFocus: () => setHoveredLink("pr"),
+				onBlur: () => setHoveredLink(null),
+				children: prToken
+			});
+		}
+
+		/** The chip row itself: leading cluster, operation text, count and PR token. */
+		function chipAssemble(leadingHover, text, countHover, prTokenHover) {
+			return react_jsx_runtime.jsxs("span", {
 				style: {
 					display: "inline-flex",
 					alignItems: "center",
 					flex: "none",
-					// 6px, not 4px: the PR token leads with a space, and CSS drops
-					// leading whitespace at the start of a flex item, so 4px read as no
-					// separation at all between the branch and `PR#…`
+					// 6px, not 4px: the PR token leads with a space, and CSS drops leading
+					// whitespace at the start of a flex item, so 4px read as no separation
+					// at all between the branch and `PR#…`
 					gap: "6px",
 					color: "var(--dsw-alias-label-secondary, #5b6570)",
 					fontSize: "12px",
@@ -1340,92 +1499,57 @@ window.__ModuleLoader__.load({
 					whiteSpace: "nowrap",
 					cursor: "default"
 				},
-				// the long-form explanation, on hover; the inline seam-notice below is
-				// the visible channel (its text is the short form, its title this).
-				// null until the delayed check in apply() proves the seam never
-				// appeared.
-				title: seamHint === null ? undefined : seamHint,
 				children: [
-					// The hover card belongs to the STATUS SYMBOL, not the badge: the
-					// circle is the "what does this colour mean" element, and a card
-					// opening sideways from a hover on the branch text got in the way of
-					// the very pull-down this row now carries. The detail fetch
-					// (enabled: hovered) follows the same pointer, so nothing pays for
-					// extras the card no longer shows. The seam-absent native title
-					// stays on the whole chip — it is about the badge, not the mark.
-					hoverableMark,
-
-						branchHover,
-						react_jsx_runtime.jsx("span", { key: "text", children: text }),
+					leadingHover,
+					react_jsx_runtime.jsx("span", { key: "text", children: text }),
 					countHover,
-					prTokenHover,
-					/**
-					 * The seam-absent notice: the market-install notification for the
-					 * state a blocked postinstall leaves behind — chip working, sidebar
-					 * rows structurally off, nothing patched, nothing to restart INTO.
-					 * It is only ever TRUE (seamHint is set 5s after boot, only after
-					 * the composed graph is given its chance), and it is self-resolving:
-					 * apply + restart makes the seam declare, and this never renders
-					 * again. That is what distinguishes it from the old restart notice,
-					 * which outlived the restart it asked for. Dismissal is a session
-					 * value (see seamNoticeDismissed), so the × means "stop asking this
-					 * boot", never "stop asking forever".
-					 */
-					seamNotice === null
-						? null
-						: react_jsx_runtime.jsxs(
-								"span",
-								{
-									style: {
-										display: "inline-flex",
-										alignItems: "center",
-										gap: "6px",
-										paddingLeft: "6px",
-										borderLeft: "1px solid var(--dsw-alias-border-secondary, #d0d7de)",
-										whiteSpace: "normal",
-										maxWidth: "320px"
-									},
-									children: [
-										react_jsx_runtime.jsx(
-											"span",
-											{
-												title: seamHint,
-												children: "sidebar badges off — run `npx dsh-git-badge apply`"
-											},
-											"explain"
-										),
-										react_jsx_runtime.jsx(
-											"button",
-											{
-												"aria-label": "Dismiss the sidebar-badges notice (returns next boot while the seam is absent)",
-												onClick: () => {
-													seamNoticeDismissed = true;
-													bumpNotice((n) => n + 1);
-												},
-												style: {
-													cursor: "pointer",
-													color: "inherit",
-													background: "none",
-													border: "1px solid var(--dsw-alias-border-secondary, #d0d7de)",
-													borderRadius: "4px",
-													fontSize: "11px",
-													lineHeight: "18px",
-													padding: "0 6px",
-													flex: "none"
-												},
-												children: "×"
-											},
-											"dismiss"
-										)
-									]
-								},
-								"seam-notice"
-							),
+					prTokenHover
 				]
 			});
-			// No Tooltip primitive (a shell that does not seed it): the mark renders
-			// bare and the badge still works — the card is an enhancement, the
-			// badge is the feature.
+		}
+
+		/**
+		 * 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
+		 * half resolve the workspace, so this surface needs no `workspaces`
+		 * service, no cwd and no path plumbing at all. `conversation.input.left`
+		 * is an upstream additive slot, so it works on every install, and it stays
+		 * useful next to the session row because it is context-anchored ("where am
+		 * I") rather than surveying.
+		 *
+		 * This is the ONLY surface that asks the node half for the extras (`pr=1`
+		 * always, `detail=1` on hover), because it is the only one that renders
+		 * them — see targetQuery.
+		 */
+		function ComposerGitChip({ sessionId }) {
+			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 -10` plus a stash list, so they are fetched
+			// only once a pointer actually RESTS on the chip. A refresh fires on every
+			// file edit, so eagerly asking would add both invocations to every refresh.
+			const [hovered, setHovered] = react.useState(false);
+			// Which of the chip's two links is hovered/focused — ONE enum, not two
+			// booleans: "branch" | "pr" | null. The anchor underlines only when its
+			// own value matches, so hovering one link never underlines the other.
+			const [hoveredLink, setHoveredLink] = react.useState(null);
+			const detail = useGitStatus(target, { pr: true, detail: true, enabled: hovered });
+			if (info === void 0 || info.git !== true) return null;
+
+			const tokenGlyph = chipGlyphNode(info);
+			// The branch name links to the compare view (base...branch). Vouched http(s)
+			// only; new tab, never navigating the conversation away.
+			const isBranchLink = typeof detail?.compareUrl === "string" && detail.compareUrl.startsWith("https://");
+			const branchInner = chipBranchInner(info, detail, isBranchLink, hoveredLink, setHovered, setHoveredLink);
+			// The Tooltip's CHILD must not change element type once the detail payload
+			// lands, so the cluster span is the stable hover surface. ALWAYS wrapped.
+			const leadingHover = chipLeadingHover(info, detail, tokenGlyph, branchInner, isBranchLink, setHovered);
+			const text = formatOperationToken(info);
+			const countHover = chipCountHover(info, detail, setHovered);
+			const prTokenHover = chipPrTokenHover(info, hoveredLink, setHoveredLink);
+			const chip = chipAssemble(leadingHover, text, countHover, prTokenHover);
+			// No Tooltip primitive (a shell that does not seed it): the leading cluster
+			// renders bare and the badge still works — the card is an enhancement.
 			return chip;
 		}
 
@@ -1435,7 +1559,7 @@ window.__ModuleLoader__.load({
 		// node half resolves the workspace, so the client never needs a service
 		// lookup. Fewer declared services also means fewer ways to fail to load.
 		/** The built-in ranking order — what "Reset to default" restores. */
-		const DEFAULT_ORDER = ["operation", "unmerged", "sync", "publish", "merge", "commit", "checks"];
+		const DEFAULT_ORDER = ["operation", "unmerged", "conflict", "review", "sync", "publish", "merge", "commit", "checks"];
 
 		/**
 		 * Move one category within the ranking order — the card's only reorder
@@ -1455,6 +1579,8 @@ window.__ModuleLoader__.load({
 		const CATEGORY_LABELS = {
 			operation: ["operation", "resume a paused merge/rebase"],
 			unmerged: ["unmerged", "resolve conflict markers"],
+			conflict: ["conflict", "a pull request that conflicts with its base"],
+			review: ["review", "a review to address, or a review to wait for"],
 			sync: ["sync", "pull, or rebase + confirmed force-push"],
 			publish: ["publish", "push local commits"],
 			merge: ["merge", "a merge-ready pull request"],
@@ -1590,12 +1716,12 @@ window.__ModuleLoader__.load({
 			});
 		}
 
-		const inject = ["slots", "inputTriggers"];
+		const inject = ["slots"];
 
 		/**
-		 * Register the badge into the seams. The seam owner hands each entry the row
-		 * owner share as props; the row badge destructures `{ sessionId }` and
-		 * deliberately ignores the cwd it may also be given.
+		 * Register the badge into upstream's own seats. The slot owner hands each
+		 * entry the row owner share as props; the row surfaces destructure
+		 * `{ sessionId }` and deliberately ignore the cwd they may also be given.
 		 */
 		function apply(ctx) {
 			// The /gh command contribution (the (+) commands menu): the state-aware
@@ -1810,33 +1936,31 @@ window.__ModuleLoader__.load({
 				}
 			}
 
-			// inject() re-evaluates when a seam's declaration appears, so boot
-			// order relative to the workspace browser does not matter. On an
-			// unpatched install the seam is never declared, so this callback never
-			// fires and the row badge simply never renders.
-			//
-			// The registration is reported from INSIDE the callback on purpose: a
-			// `spec()` check here at apply() time runs before the workspace browser
-			// declares the seam, so it reports the boot race rather than the
-			// outcome. That mistake made the old one-shot line claim "sidebar rows
-			// = off" while five row badges were rendering.
-			let rowsReported = false;
-			ctx.slots.inject("sidebar.workspaces.sessionRow", () => {
-				if (!rowsReported) {
-					rowsReported = true;
-					console.info("[dsh-git-badge] surfaces: sidebar session rows = on (seam present).");
-				}
-				return ctx.slots.register({
-					name: "sidebar.workspaces.sessionRow",
-					id: "git-badge-row"
-				}, SessionGitBadge);
-			});
-			// The row is ALREADY a HoverCard anchor upstream, so a badge that opened
-			// its own tooltip would nest two cards. This renders the provenance line
+			// The row's token rides upstream's OWN `sidebar.session.row.leading`
+			// seat: a 16px cell the workspace browser renders in the row's leading
+			// cluster. No patch and no declaration to make.
+			ctx.slots.inject("sidebar.session.row.leading", () => ctx.slots.register({
+				name: "sidebar.session.row.leading",
+				id: "git-badge-row-leading"
+			}, LeadingTokenGlyph));
+			// The seat above is mounted ONLY while the row's primary state is idle
+			// (upstream's own contract). A row that owns a solid status dot — an
+			// unread completion, or a pending interaction — keeps that cell to
+			// itself, so the token glyph would be invisible exactly when the turn
+			// that produced it just ended, until the session is opened. This strip is
+			// ALWAYS mounted (hidden by CSS, not unmounted), so a marker rides it and
+			// the stylesheet paints the token over the dot. The rule stays honest: no
+			// upstream byte changes, and the cell still belongs to upstream.
+			ctx.slots.inject("sidebar.workspaces.session.row.action", () => ctx.slots.register({
+				name: "sidebar.workspaces.session.row.action",
+				id: "git-badge-row-fallback",
+				order: 300
+			}, RowFallbackGlyph));
+			ensureRowFallbackStyle();
+			// The row is ALREADY a HoverCard anchor upstream, so a glyph that opened
+			// its own tooltip would nest two cards. This renders the explanation
 			// inside that card instead, through the hover seat upstream declares
-			// itself (sidebar.session.row.hover) — no seam patch and no request of
-			// its own. Upstream 0.2.0-rc.2 threads renderSlot into the card and adds
-			// the seat; before that this needed a patched sessionRow.detail seam.
+			// itself (sidebar.session.row.hover) — no request of its own.
 			ctx.slots.inject("sidebar.session.row.hover", () => ctx.slots.register({
 				name: "sidebar.session.row.hover",
 				id: "git-badge-row-detail"
@@ -1852,29 +1976,9 @@ window.__ModuleLoader__.load({
 				id: "git-badge-chip",
 				inject: (sessionId) => ({ sessionId })
 			}, ComposerGitChip));
-			const seamDeclared = ctx.slots.spec("sidebar.workspaces.sessionRow") !== void 0;
-			console.info(
-				"[dsh-git-badge] surfaces: input chip = on; sidebar session rows = " +
-					(seamDeclared
-						? "on (seam present)."
-						: // discoverability: the chip works everywhere, but the session rows
-							// need the seam patch, and on a market install nothing else says so.
-							// The patcher ships IN this package — no clone needed.
-							"off (seam absent) — run `npx dsh-git-badge apply` to add them, then restart dsh web.")
-			);
-			// The chip tooltip can only be set LATE. At apply() time the workspace
-			// browser may not have declared the seam yet (the boot race documented
-			// above), so claiming absence here would lie to patched installs for the
-			// whole session — the exact mistake that made the old one-shot line
-			// claim "sidebar rows = off" while five row badges were rendering. Give
-			// the composed graph a beat to settle; only a seam that is STILL absent
-			// earns the hint, and every chip render after that carries it.
-			setTimeout(() => {
-				if (rowsReported) return; // seam present; badges rendered — nothing to hint about
-				if (ctx.slots.spec("sidebar.workspaces.sessionRow") !== void 0) return;
-				seamHint =
-					"Session-row badges are off: run `npx dsh-git-badge apply`, then restart dsh web. (Input-chip badges are unaffected.)";
-			}, 5000);
+			// No seam, no apply step: the leading seat and the hover seat are both
+			// upstream's own. Report the surfaces once, for diagnostics.
+			console.info("[dsh-git-badge] surfaces: input chip = on; sidebar row token = on (upstream leading seat).");
 			// The hover card depends on a primitive the SHELL seeds, not on anything
 			// this plugin declares. Report the outcome rather than letting a missing
 			// seed look like a missing feature: the try/catch above deliberately keeps
@@ -1893,7 +1997,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, linkedWorktreesDetail, actionToken, ghSkillActions, cleanGate, moveCategory };
+		exports.__internals = { targetQuery, worktreeDetail, linkedWorktreesDetail, ghSkillActions, cleanGate, moveCategory, fallbackGlyph, glyphMaskDataUri, syncRowFallback, clearFallbackMark, ROW_FALLBACK_CSS, ROW_FALLBACK_DOT };
 		return module.exports;
 	}
 });