dsh-git-badge 0.5.5 → 0.7.0

package/lib/client.js

@@ -1,9 +1,16 @@
 /**
  * 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.
+ *
  * Surfaces:
- *  - sidebar.workspaces.row (seam): full row badge — emoji, branch, sync, ✎files
- *  - conversation.input.left (upstream): compact chip — emoji + branch only
+ *  - sidebar.workspaces.row (seam): row badge — workspace name, the status mark
+ *    floated right, and a worktree's name beside it. Deliberately shows NO
+ *    branch: the chip is the surface that names it.
+ *  - conversation.input.left (upstream): chip — status mark + branch + a
+ *    worktree's name + in-progress operation token + sync/dirty suffix
  * The hover card is intentionally untouched.
  */
 window.__ModuleLoader__.load({
@@ -22,6 +29,19 @@ window.__ModuleLoader__.load({
 		/** Slow safety-net poll: refreshes even if the SSE stream is silently dead. */
 		const FALLBACK_POLL_MS = 60000;
 
+		/**
+		 * 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.
+		 */
+		function targetQuery(target) {
+			if (target === void 0 || target.id === void 0) return void 0;
+			const param = target.kind === "workspace" ? "workspace" : "session";
+			return param + "=" + encodeURIComponent(target.id);
+		}
+
 		//#region SSE change feed (one EventSource per page, ref-counted)
 		const eventListeners = new Set();
 		let eventSource = null;
@@ -32,25 +52,27 @@ window.__ModuleLoader__.load({
 			eventRefs += 1;
 			if (eventSource === null) {
 				eventSource = new EventSource("/api/git-badge/events");
-				eventSource.onmessage = (message) => {
-					let path;
+				// NAMED frames: the node half writes `event: change`, and onmessage
+				// never fires for a named event
+				eventSource.addEventListener("change", (message) => {
+					let payload;
 					try {
-						path = JSON.parse(message.data).path;
+						payload = JSON.parse(message.data);
 					} catch {
 						return;
 					}
-					// invalidate every cache entry for this workspace, then refetch
-					for (const key of [...GIT_CACHE.keys()]) {
-						if (key === path) GIT_CACHE.delete(key);
-					}
+					// The server names the workspace it watched, so a subscriber that
+					// asked by id matches without ever knowing a path. Each
+					// subscriber refetches itself, and the per-key in-flight map
+					// collapses the resulting burst into one request.
 					for (const fn of [...eventListeners]) {
 						try {
-							fn(path);
+							fn(payload);
 						} catch {
 							/* one bad subscriber must not starve the rest */
 						}
 					}
-				};
+				});
 			}
 			return () => {
 				eventListeners.delete(onChange);
@@ -65,76 +87,122 @@ window.__ModuleLoader__.load({
 
 		/**
 		 * Shared git-status hook. Fetches once on mount and then only when the
-		 * node half's watcher reports a change for this workspace (SSE), plus a
-		 * slow safety-net poll in case the stream dies silently. Returns
-		 * undefined while loading and for non-git paths.
+		 * node half's watcher reports a change for this target (SSE), plus a slow
+		 * safety-net poll in case the stream dies silently. Returns undefined
+		 * while loading and for non-git workspaces.
 		 */
-		function useGitStatus(cwd) {
-			const cacheKey = cwd;
+		function useGitStatus(target) {
+			const cacheKey = targetQuery(target);
 			const hit = cacheKey === void 0 ? void 0 : GIT_CACHE.get(cacheKey);
-			const [info, setInfo] = react.useState(hit !== void 0 ? hit.data : void 0);
+			// state carries the key it belongs to: switching conversations changes
+			// the key, and showing the previous session's badge until the new fetch
+			// lands would be wrong
+			const [state, setState] = react.useState({ key: cacheKey, data: hit === void 0 ? void 0 : hit.data });
 			react.useEffect(() => {
-			if (cacheKey === void 0) return;
-			let alive = true;
-			const apply = (data) => {
-				// A degraded response (git timeout/failure) must never clobber a
-				// good cached badge — keep the last-known state until a real
-				// event or the fallback poll succeeds.
-				if (data !== null && data.error !== void 0 && GIT_CACHE.has(cacheKey)) return;
-				GIT_CACHE.set(cacheKey, { at: Date.now(), data });
-				if (alive) setInfo(data);
-			};
-			const load = () => {
-				// dedupe: an in-flight fetch for this key serves all callers
-				let pending = GIT_INFLIGHT.get(cacheKey);
-				if (pending === void 0) {
-					pending = fetch("/api/git-badge?path=" + encodeURIComponent(cwd))
-						.then((r) => r.json())
-						.finally(() => GIT_INFLIGHT.delete(cacheKey));
-					GIT_INFLIGHT.set(cacheKey, pending);
+				if (cacheKey === void 0) return;
+				let alive = true;
+				// The workspace this target resolved to, taken from the response (the
+				// server echoes it). THIS is what events are matched against: an event
+				// carries a workspace id, and a session-targeted chip has only a
+				// session id, so comparing the two directly never matches.
+				let resolvedWorkspace;
+				// Re-seed from cache when the key changes (switching conversations):
+				// render the last-known badge immediately instead of blanking until the
+				// fetch lands, and take the workspace id from it so events still match.
+				const cached = GIT_CACHE.get(cacheKey);
+				if (cached !== void 0) {
+					if (typeof cached.data?.workspace === "string") resolvedWorkspace = cached.data.workspace;
+					setState({ key: cacheKey, data: cached.data });
 				}
-				pending.then(apply).catch(() => {});
-			};
-			load();
-			// this workspace's watcher events → refetch
-			const unsubscribe = subscribeGitEvents((path) => {
-				if (path === cwd) load();
-			});
-			const fallback = setInterval(load, FALLBACK_POLL_MS);
-			return () => {
-				alive = false;
-				unsubscribe();
-				clearInterval(fallback);
-			};
-		}, [cacheKey]);
-			return info;
+				const apply = (data) => {
+					// A degraded response (git timeout/failure) must never clobber a
+					// good cached badge — keep the last-known state until a real
+					// 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 });
+					if (alive) setState({ key: cacheKey, data });
+				};
+				const load = () => {
+					// dedupe: an in-flight fetch for this key serves all callers
+					let pending = GIT_INFLIGHT.get(cacheKey);
+					if (pending === void 0) {
+						pending = fetch("/api/git-badge?" + cacheKey)
+							.then((r) => r.json())
+							.finally(() => GIT_INFLIGHT.delete(cacheKey));
+						GIT_INFLIGHT.set(cacheKey, pending);
+					}
+					pending.then(apply).catch(() => {});
+				};
+				load();
+				const unsubscribe = subscribeGitEvents((payload) => {
+					// An event with no workspace id (no watcher record for that path)
+					// cannot be attributed, and neither can one arriving before we have
+					// resolved our own target — refetch rather than guess, since a
+					// missed refresh is the bug this guards and an extra request is cheap
+					// (the in-flight map collapses bursts).
+					if (payload.workspace === void 0 || resolvedWorkspace === void 0 || payload.workspace === resolvedWorkspace) load();
+				});
+				const fallback = setInterval(load, FALLBACK_POLL_MS);
+				return () => {
+					alive = false;
+					unsubscribe();
+					clearInterval(fallback);
+				};
+			}, [cacheKey]);
+			return state.key === cacheKey ? state.data : void 0;
 		}
 
 		/**
-		 * Three-state dot color, shared by the sidebar row badge and the
-		 * composer chip. Checked top-down, first match wins:
-		 *  - RED: unmerged files (mid-conflict, git is blocked) — or a dirty
+		 * 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).
-		 *  - YELLOW: dirty files, or any ahead/behind (routine work or sync
+		 *  - "warn": dirty files, or any ahead/behind (routine work or sync
 		 *    pending — including the previously "quiet" green-but-↓1 case).
-		 *  - GREEN: clean and in sync.
+		 *  - "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 badgeDot(info) {
+		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 "\uD83D\uDD34";
-			if (dirty || ahead || behind) return "\uD83D\uDFE1";
-			return "\uD83D\uDFE2";
+			if (conflict || (dirty && behind)) return "error";
+			if (dirty || ahead || behind) return "warn";
+			return "ok";
 		}
 
 		/**
-		 * Sync/dirty suffix — INPUT CHIP ONLY. The sidebar row badge shows
-		 * status + branch alone; the chip is the detailed surface. Rule set:
+		 * 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;
+		 * 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),
@@ -154,6 +222,68 @@ window.__ModuleLoader__.load({
 			return parts.length > 0 ? " " + parts.join(" ") : "";
 		}
 
+		/**
+		 * In-progress operation token — INPUT CHIP ONLY (the row shows the status
+		 * tree alone). A paused rebase or cherry-pick whose conflicts are all
+		 * already staged has no unmerged files, so the three-state summary cannot
+		 * distinguish it from ordinary dirty work; this says which
+		 * history-rewriting operation git is waiting on.
+		 */
+		const OPERATION_LABELS = {
+			merge: "\u2694merge",
+			squash: "\u2694squash",
+			"cherry-pick": "\u2694cherry-pick",
+			revert: "\u2694revert",
+			bisect: "\u2694bisect",
+			rebase: "\u2694rebase",
+			sequencer: "\u2694sequencer"
+		};
+
+		/** ` ⚔rebase` when an operation is paused, else "". */
+		function formatOperationToken(info) {
+			const label = OPERATION_LABELS[info.operation];
+			return label === void 0 ? "" : " " + label;
+		}
+
+		/**
+		 * Linked-worktree NAME token — INPUT CHIP ONLY, and only the name: worktree-
+		 * ness itself is carried by the status mark's shape (a tree instead of a
+		 * circle) on both surfaces. The chip has no other workspace identity, so
+		 * several worktrees of one repository would otherwise render identical chips
+		 * with no way to tell which checkout a conversation is in. The node half
+		 * reports whether this is a linked worktree plus its directory NAME (never a
+		 * path).
+		 *
+		 * The name is appended only when it says something the branch does not: the
+		 * usual `repo-feat-x` directory sitting on branch `feat-x` would otherwise
+		 * read as stutter. (The ROW needs no such rule — it shows the name instead
+		 * of the branch, so there is nothing to stutter against.)
+		 */
+
+		/**
+		 * True when the worktree name is already implied by the branch name, so
+		 * showing both is pure repetition. Compared on a normalized form —
+		 * case-folded, with `/` and `_` folded to `-` — because directory and
+		 * branch conventions differ without changing the meaning (`feat/x` in a
+		 * `repo-feat-x` directory).
+		 */
+		function worktreeNameIsRedundant(name, branch) {
+			if (typeof name !== "string" || name === "" || typeof branch !== "string") return true;
+			const normalize = (value) => value.toLowerCase().replace(/[/_]/g, "-");
+			const normalizedName = normalize(name);
+			const normalizedBranch = normalize(branch);
+			return normalizedName === normalizedBranch
+				|| normalizedName.endsWith("-" + normalizedBranch)
+				|| normalizedBranch.endsWith("-" + normalizedName);
+		}
+
+		/** ` name` for a worktree whose name the branch does not already say, else "". */
+		function formatWorktreeToken(info) {
+			if (info.isWorktree !== true) return "";
+			const name = typeof info.worktreeName === "string" ? info.worktreeName : "";
+			return worktreeNameIsRedundant(name, info.branch) ? "" : " " + name;
+		}
+
 		const META_STYLE = {
 			color: "var(--dsw-alias-label-tertiary, #9ea7ad)",
 			fontSize: "12px",
@@ -163,66 +293,122 @@ window.__ModuleLoader__.load({
 		};
 
 		/**
-		 * Row badge — three-state dot + branch (sync/dirty detail lives on
-		 * the input chip):
-		 *   the_paragliding_app  | 🟢 main
-		 * Dot color via badgeDot(): green clean+synced, yellow dirty or
-		 * out-of-sync, red conflict or dirty-and-behind.
-		 * Always renders the workspace name (so the row keeps its identity);
-		 * appends the muted `| emoji branch` part only for git workspaces.
+		 * Status mark, SHARED BY BOTH SURFACES: the same 12px 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 WorkspaceGitBadge({ label, cwd }) {
-			const info = useGitStatus(cwd, false);
-			const children = [react_jsx_runtime.jsx("span", { style: { minWidth: 0, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }, children: label })];
-			if (cwd !== void 0 && info !== void 0 && info.git === true) {
-				children.push(
-					react_jsx_runtime.jsx("span", { style: { ...META_STYLE, margin: "0 7px" }, children: "|" }),
-					react_jsx_runtime.jsx("span", { style: { ...META_STYLE, marginRight: "4px" }, children: badgeDot(info) }),
-					react_jsx_runtime.jsx("span", { style: META_STYLE, children: info.branch })
-				);
+		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],
+				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.jsx("span", { style: { display: "flex", alignItems: "center", minWidth: 0 }, children });
+			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 })
+				]
+			});
 		}
 
-		//#region composer chip (fallback + companion surface: conversation.composer.dock)
-		/** Client root ctx, captured at apply() for the chip's service lookups. */
-		let clientCtx = null;
+		/**
+		 * A linked worktree's directory name, or null when there is nothing to
+		 * show. A main checkout shows NO text: the row surveys status and identity,
+		 * and the branch lives on the input chip — which is why the branch is never
+		 * rendered here. The name is the one thing the row's own label (the
+		 * worktree directory by default) cannot be trusted to say once a workspace
+		 * has been renamed.
+		 */
+		function rowName(info) {
+			if (info.isWorktree !== true) return null;
+			const name = typeof info.worktreeName === "string" ? info.worktreeName : "";
+			return name === "" ? null : name;
+		}
 
 		/**
-		 * Resolve the workspace cwd attached to a session: projects the
-		 * workspaces service's snapshot store (items carry path + sessionIds)
-		 * and re-resolves on change. Returns undefined while unknown.
+		 * Row badge — workspace name on the left, the status mark floated right:
+		 *   the_paragliding_app                       ●
+		 *   worktree_thing                  hotfix-tree 🌳
+		 * Fill colour via badgeStatus(): green clean+synced, amber dirty or
+		 * out-of-sync, red conflict or dirty-and-behind. Shape via the node half's
+		 * isWorktree: circle = main checkout, tree = linked worktree.
+		 * Always renders the workspace name (so the row keeps its identity) and
+		 * appends the right-hand mark only for git workspaces. No branch, and no
+		 * `|` separator.
+		 *
+		 * Targets the row's `workspaceId`. The seam also passes `cwd`, which is
+		 * deliberately ignored: the node half resolves the directory itself, so
+		 * the client never has to name one. A row with no workspaceId (the
+		 * ungrouped bucket) has no workspace to report on, so it renders
+		 * name-only.
 		 */
-		function useSessionWorkspaceCwd(sessionId) {
-			const workspaces = clientCtx === null ? null : clientCtx.get("workspaces");
-			const resolve = () => {
-				if (sessionId === void 0 || workspaces === void 0) return void 0;
-				const item = workspaces.list.getSnapshot().items.find((w) => w.sessionIds !== void 0 && w.sessionIds.includes(sessionId));
-				return item === void 0 ? void 0 : item.path;
-			};
-			const [cwd, setCwd] = react.useState(resolve);
-			react.useEffect(() => {
-				if (sessionId === void 0 || workspaces === void 0) return;
-				setCwd(resolve());
-				return workspaces.list.subscribe(() => {
-					setCwd(resolve());
-				});
-			}, [sessionId, workspaces]);
-			return cwd;
+		function WorkspaceGitBadge({ label, workspaceId }) {
+			// no detail=1: the row needs status and identity only, and the extra
+			// log / stash calls have no consumer yet
+			const info = useGitStatus(workspaceId === void 0 ? void 0 : { kind: "workspace", id: workspaceId });
+			const children = [react_jsx_runtime.jsx("span", { style: { minWidth: 0, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }, children: label })];
+			if (workspaceId !== void 0 && info !== void 0 && info.git === true) {
+				// marginLeft:auto floats the mark to the right edge, so the status
+				// shape holds a fixed right-hand column and a worktree's name grows
+				// leftwards from it instead of shoving the shape around.
+				const meta = [];
+				const name = rowName(info);
+				if (name !== null) meta.push(react_jsx_runtime.jsx("span", { key: "name", style: META_STYLE, children: name }));
+				meta.push(react_jsx_runtime.jsx(StatusMark, { key: "mark", info }));
+				children.push(react_jsx_runtime.jsx("span", { style: { display: "inline-flex", alignItems: "center", gap: "6px", flex: "none", marginLeft: "auto", paddingLeft: "8px" }, children: meta }));
+			}
+			return react_jsx_runtime.jsx("span", { style: { display: "flex", alignItems: "center", minWidth: 0, width: "100%" }, children });
 		}
 
+		//#region composer chip (upstream additive surface: conversation.input.left)
 		/**
-		 * Chip line docked at the composer: git state of the workspace the
-		 * CURRENT conversation is attached to. Works on unpatched installs
-		 * (conversation.composer.dock is an upstream additive slot), and stays
-		 * useful next to the sidebar rows on patched/upstream-seam installs
-		 * because it is context-anchored ("where am I") rather than surveying.
+		 * 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.
 		 */
 		function ComposerGitChip({ sessionId }) {
-			const cwd = useSessionWorkspaceCwd(sessionId);
-			const info = useGitStatus(cwd, true);
-			if (cwd === void 0 || info === void 0 || info.git !== true) return null;
-			const text = badgeDot(info) + " " + info.branch + formatGitSuffix(info);
+			// no detail=1: nothing renders lastCommits / stashCount yet, and asking
+			// for them would add a log -3 plus a stash list to every refresh
+			const info = useGitStatus(sessionId === void 0 ? void 0 : { kind: "session", id: sessionId });
+			if (info === void 0 || info.git !== true) return null;
+			// 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
+			const text = info.branch + formatWorktreeToken(info) + formatOperationToken(info) + formatGitSuffix(info);
 			return react_jsx_runtime.jsx("span", {
 				style: {
 					display: "inline-flex",
@@ -235,28 +421,46 @@ window.__ModuleLoader__.load({
 					whiteSpace: "nowrap",
 					cursor: "default"
 				},
-				children: text
+				children: [
+					react_jsx_runtime.jsx(StatusMark, { key: "mark", info }),
+					react_jsx_runtime.jsx("span", { key: "text", children: text })
+				]
 			});
 		}
 		//#endregion
 
-		const inject = ["slots", "workspaces"];
+		// `workspaces` is no longer required: both surfaces target an id and the
+		// node half resolves the workspace, so the client never needs a service
+		// lookup. Fewer declared services also means fewer ways to fail to load.
+		const inject = ["slots"];
 
 		/**
 		 * Register the badge into both seams. The seam owner hands each entry the
-		 * row owner share as props; the badge destructures { workspaceId, cwd,
-		 * label } from it.
+		 * row owner share as props; the badge destructures { workspaceId, label }
+		 * and deliberately ignores the cwd it is also given.
 		 */
 		function apply(ctx) {
-			clientCtx = ctx;
 			// 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 row seams never get declared, so those two
-			// registrations simply never render anything.
-			ctx.slots.inject("sidebar.workspaces.row", () => ctx.slots.register({
-				name: "sidebar.workspaces.row",
-				id: "git-badge"
-			}, WorkspaceGitBadge));
+			// unpatched install the row 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.row", () => {
+				if (!rowsReported) {
+					rowsReported = true;
+					console.info("[dsh-git-badge] surfaces: sidebar rows = on (seam present).");
+				}
+				return ctx.slots.register({
+					name: "sidebar.workspaces.row",
+					id: "git-badge"
+				}, WorkspaceGitBadge);
+			});
 			// Input-row chip: upstream additive slot rendered in the input bar's
 			// leading cluster, right after the access picker — the git state sits
 			// with the controls that govern the conversation. Present on every
@@ -269,7 +473,7 @@ window.__ModuleLoader__.load({
 				inject: (sessionId) => ({ sessionId })
 			}, ComposerGitChip));
 			const seamDeclared = ctx.slots.spec("sidebar.workspaces.row") !== void 0;
-			console.info("[dsh-git-badge] surfaces: input chip = on; sidebar rows = " + (seamDeclared ? "on (seam present)" : "off (seam absent — sidebar badges need the sidebar.workspaces.row seam)") + ".");
+			console.info("[dsh-git-badge] surfaces: input chip = on; sidebar rows = " + (seamDeclared ? "on (seam present)." : "awaiting the sidebar.workspaces.row seam — the line above reports it if it appears."));
 		}
 
 		exports.apply = apply;