dsh-git-badge 0.17.0 → 0.17.1

package/CHANGELOG.md

@@ -10,6 +10,31 @@ npm. 0.6.0 is the first release recorded here.
 
 ## [Unreleased]
 
+## [0.17.1] - 2026-09-17
+
+### Fixed
+
+- **The branch, file-count and PR hovers open on the FIRST hover.** Those three
+  surfaces were only wrapped in the shell's `Tooltip` once the lazy `detail=1`
+  payload arrived. That primitive is uncontrolled — it has no `open` prop and
+  opens from a `mouseenter` it attaches to its child — so a wrapper mounted after
+  the pointer had already arrived could never open for that visit: the first hover
+  did nothing, and worked only after leaving and returning (or after hovering the
+  status mark had already warmed the cache). All four surfaces are now wrapped
+  from the first render, and a label whose detail is still in flight degrades to
+  the base response instead of claiming an empty list — the count restates the
+  file breakdown, the PR token names the PR. The branch's hover child also stays a
+  `span`, so the compare link appearing underneath a resting pointer cannot
+  remount it. The status mark's own card was never affected.
+
+### Changed
+
+- **Internal simplification pass, no user-facing change** (#52): one
+  `singleFlight` now backs the status cache and its in-flight coalescing, one
+  patch engine (`seam/patch.js`) backs both `seam/apply.js` and
+  `seam/postinstall.js`, and the server returns one `nextActions` shape
+  (`{actions, next}`) for the row's action list.
+
 ## [0.17.0] - 2026-09-16
 
 ### Added
@@ -278,22 +303,18 @@ npm. 0.6.0 is the first release recorded here.
 
 ## [0.14.1] - 2026-09-15
 
+### Changed
+
 - **Skill alignment:** the `gh` skill gains an explicit handoff — one verb per
   invocation is its whole job; the multi-step PR lifecycle (review, merge,
   verify, cleanup) belongs to the `gh-pr` skill. The `gh-pr` skill states the
   mirror scope: one-shot verbs are `gh`'s, lifecycle is its own. The catalog
   stays global-only; repo conventions stay in `AGENTS.md`.
-
 - **The hover card is 33% wider** (360px → 480px) and its `action:` row now
   carries a trailing what-comment in git-comment convention — e.g.
   `action: /gh push  # push local commits to the remote` — so the row says
   what the invocation does, not just which invocation it is. The picker in the
   (+) menu shares the same descriptions.
-
-## [0.14.1] - 2026-09-15
-
-### Changed
-
 - **The chip's hover card top line is now an `action:` row** — the gh skill
   invocation the checkout justifies (e.g. `/gh push`), in the card's ordinary
   label/value layout, replacing the next-step line's why-plus-copy-chip. The
@@ -685,7 +706,20 @@ npm. 0.6.0 is the first release recorded here.
 - `detail=1` is annotated as having no consumer yet (the hover card remains
   pending). Its comment previously claimed `log -1` while the code ran `log -3`.
 
-[Unreleased]: https://github.com/Kevin-McIsaac/dsh-workspace-git-badge/compare/v0.8.0...HEAD
+[Unreleased]: https://github.com/Kevin-McIsaac/dsh-workspace-git-badge/compare/v0.17.0...HEAD
+[0.17.0]: https://github.com/Kevin-McIsaac/dsh-workspace-git-badge/releases/tag/v0.17.0
+[0.16.1]: https://github.com/Kevin-McIsaac/dsh-workspace-git-badge/releases/tag/v0.16.1
+[0.16.0]: https://github.com/Kevin-McIsaac/dsh-workspace-git-badge/releases/tag/v0.16.0
+[0.15.0]: https://github.com/Kevin-McIsaac/dsh-workspace-git-badge/releases/tag/v0.15.0
+[0.14.1]: https://github.com/Kevin-McIsaac/dsh-workspace-git-badge/releases/tag/v0.14.1
+[0.14.0]: https://github.com/Kevin-McIsaac/dsh-workspace-git-badge/releases/tag/v0.14.0
+[0.13.0]: https://github.com/Kevin-McIsaac/dsh-workspace-git-badge/releases/tag/v0.13.0
+[0.12.0]: https://github.com/Kevin-McIsaac/dsh-workspace-git-badge/releases/tag/v0.12.0
+[0.11.0]: https://github.com/Kevin-McIsaac/dsh-workspace-git-badge/releases/tag/v0.11.0
+[0.10.1]: https://github.com/Kevin-McIsaac/dsh-workspace-git-badge/releases/tag/v0.10.1
+[0.10.0]: https://github.com/Kevin-McIsaac/dsh-workspace-git-badge/releases/tag/v0.10.0
+[0.9.1]: https://github.com/Kevin-McIsaac/dsh-workspace-git-badge/releases/tag/v0.9.1
+[0.9.0]: https://github.com/Kevin-McIsaac/dsh-workspace-git-badge/releases/tag/v0.9.0
 [0.8.0]: https://github.com/Kevin-McIsaac/dsh-workspace-git-badge/releases/tag/v0.8.0
 [0.7.0]: https://github.com/Kevin-McIsaac/dsh-workspace-git-badge/releases/tag/v0.7.0
 [0.6.0]: https://github.com/Kevin-McIsaac/dsh-workspace-git-badge/releases/tag/v0.6.0

package/README.md

@@ -3,7 +3,7 @@
 Git status badges for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness):
 
 - **Input-row chip** — `● main ↑0 ↓2 ✎3` next to the access picker, showing the git state of the workspace the current conversation is attached to. Works on every install.
-- **Hover card** — rest a pointer on the chip for what won't fit: the file breakdown (`✎3` split into staged / unstaged / untracked), the last three commits, and the stash. Fetched only on hover, so the everyday badge pays nothing for it. Works on every install.
+- **Hover card** — rest a pointer on the chip for what won't fit: the file breakdown (`✎3` split into staged / unstaged / untracked), the last ten commits, and the stash. Fetched only on hover, so the everyday badge pays nothing for it. Works on every install.
 - **PR / CI token** — `● main ↑0 ↓2 PR#142 ✗` when the branch has a GitHub pull request, read through your own `gh` CLI (the plugin never handles a credential). The token **links to the PR** — it opens in a new tab, and underlines when you hover or focus it. Invisible when `gh` cannot answer: not installed, not logged in, no GitHub remote, offline or rate-limited all render the unchanged chip, and a token with no URL to link to stays plain text.
 - **Worktree-aware** — a conversation's directory is fixed when it is created, so a conversation that does its work in a linked `git worktree` would otherwise keep reporting the main checkout. The session registers its checkout (`npx dsh-git-badge-checkout <path>`, run by the git-worktree and `/gh checkout` paths), and the badge describes **that worktree** instead — its branch, counts, tree mark and PR/CI token (`🌳 chore/global-skills-tiering ↑0 ↓2 PR#391 ✓` rather than `● main`). The hover card names the tree in a `worktree` row and adds a `checkout` row with the conversation's own directory, so the main checkout's branch and dirty state stay one hover away. Registrations are advisory: git's own worktree list validates the path, entries expire after 24h, and a workspace-targeted row always reports the checkout the registry owns.
 - **Sidebar session-row action token** — each session row shows the ONE thing that conversation needs from you, or nothing at all: `merge`, `fix CI`, `review`, `resolve`, `pull`, `push`. It is triage rather than status: `merge` appears only when GitHub itself reports `mergeStateStatus: CLEAN`, and every waiting state (draft, blocked, behind, checks still running) stays silent. Hovering the row adds a line naming the checkout and the pull request the action refers to. The token floats to the right of the row, is set heavier than the timestamp beside it, and is coloured by how much it needs you — red for a conflict or a failing build, amber for a requested review, green for `merge`, quiet grey for routine sync. It appears only when the session is **idle** — while a turn is running the row stays quiet, because the checkout is still moving and a suggestion would describe a state that is about to change. Requires the `sidebar.workspaces.sessionRow` seam; without it the plugin degrades to chip-only and logs what's active to the browser console.

package/lib/client.js

@@ -56,8 +56,17 @@ window.__ModuleLoader__.load({
 		const Menu = primitives === null ? void 0 : primitives.Menu;
 		const rankByName = primitives === null ? void 0 : primitives.rankByName;
 
-		/** Module-level git-status cache. Entries are invalidated by SSE events, never by age. */
+		/**
+		 * Module-level git-status cache. Entries are invalidated by SSE events,
+		 * never by age — and BOUNDED, because a long-lived tab opens and closes
+		 * many sessions and nothing else removes an entry. When the cap is
+		 * exceeded the oldest-INSERTED key is evicted (Map order is insertion,
+		 * not use); an evicted surface simply refetches, which the in-flight map
+		 * collapses like any other request.
+		 */
 		const GIT_CACHE = new Map();
+		/** The cache's entry bound — each surface is one key, plus lazy detail keys. */
+		const GIT_CACHE_LIMIT = 64;
 		/** In-flight fetches per cacheKey: bursts collapse into one request. */
 		const GIT_INFLIGHT = new Map();
 		/** Slow safety-net poll: refreshes even if the SSE stream is silently dead. */
@@ -138,7 +147,7 @@ window.__ModuleLoader__.load({
 		 * `options.detail` / `options.pr` ask the node half for the chip's extras
 		 * (see targetQuery). `options.enabled: false` holds the fetch back
 		 * entirely — that is what makes the hover card's extra fields LAZY: the
-		 * chip renders without them and only starts paying for `log -3` plus a
+		 * chip renders without them and only starts paying for a `log -10` plus a
 		 * stash list once a pointer actually rests on it. The hook is still called
 		 * unconditionally (hooks may not be conditional); the GATE is inside.
 		 */
@@ -173,6 +182,9 @@ window.__ModuleLoader__.load({
 					if (data !== null && data.error !== void 0 && GIT_CACHE.has(cacheKey)) return;
 					if (data !== null && typeof data.workspace === "string") resolvedWorkspace = data.workspace;
 					GIT_CACHE.set(cacheKey, { at: Date.now(), data });
+					if (GIT_CACHE.size > GIT_CACHE_LIMIT) {
+						GIT_CACHE.delete(GIT_CACHE.keys().next().value);
+					}
 					if (alive) setState({ key: cacheKey, data });
 				};
 				const load = () => {
@@ -240,13 +252,10 @@ window.__ModuleLoader__.load({
 		 * `/gh pr` was offered on the default branch. The node half owns the
 		 * rules and the ranking now; the client adds presentation only — the risk
 		 * gate for `clean`, and the labels.
-		 *
-		 * Falls back to the single `next` for a payload from an older node half.
 		 */
 		function ghSkillActions(info) {
 			if (info === void 0 || info === null || info.git !== true) return [];
-			if (Array.isArray(info.actions)) return info.actions;
-			return info.next === void 0 || info.next === null ? [] : [info.next];
+			return Array.isArray(info.actions) ? info.actions : [];
 		}
 
 		/**
@@ -747,9 +756,15 @@ window.__ModuleLoader__.load({
 		 * columns line up in both by construction), and the card's own width
 		 * behaviour: full-width lines, nowrap, ellipsis.
 		 */
-		function PrCommitsList({ info }) {
+		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: [
@@ -783,12 +798,13 @@ window.__ModuleLoader__.load({
 		 * the one question the count poses ("what are these?"). One stacked
 		 * column with sub-headers: UNSTAGED (tracked, edited — valid regardless
 		 * of the collapsed untracked retry) then UNTRACKED. Reads the same lazy
-		 * detail payload the mark's card uses; no tooltip at all when neither
-		 * list has names (the count itself is absent on a clean tree, so an
-		 * empty list is rare — a mid-fetch hover shows it plain until the
-		 * response lands).
+		 * detail payload the mark's card uses. The wrapper is always mounted (see
+		 * withTooltip) and the label degrades while the names are in flight: the
+		 * COUNTS are already in the base response, so it restates the breakdown
+		 * rather than claiming an empty list. "no changed files" is reserved for a
+		 * landed payload that genuinely has no names.
 		 */
-		function CountNames({ info }) {
+		function CountNames({ info, pending = false }) {
 			const sections = [
 				{
 					label: "staged",
@@ -807,6 +823,11 @@ window.__ModuleLoader__.load({
 				}
 			].filter((section) => Array.isArray(section.names) && section.names.length > 0);
 			if (sections.length === 0) {
+				// `pending`: the names have not been fetched yet, but the COUNTS have —
+				// restate those rather than the false "no changed files".
+				if (pending) {
+					return react_jsx_runtime.jsx("span", { style: CARD_CONTAINER, children: formatFileBreakdown(info) });
+				}
 				return react_jsx_runtime.jsx("span", { style: CARD_CONTAINER, children: "no changed files" });
 			}
 			return react_jsx_runtime.jsxs("div", { style: CARD_CONTAINER, children:
@@ -1009,6 +1030,24 @@ window.__ModuleLoader__.load({
 		}
 
 		//#region composer chip (upstream additive surface: conversation.input.left)
+		/**
+		 * The ONE copy of the hover-card degrade rule: wrap a node in the shell's
+		 * Tooltip when the primitive exists, and render the node bare otherwise — a
+		 * missing card is a smaller failure than a missing badge. `label` is the
+		 * thunk the Tooltip calls only when it opens, so the card's element tree
+		 * stays out of closed tooltips.
+		 *
+		 * ALWAYS mount the wrapper — never conditionally, once its data arrives.
+		 * The primitive is uncontrolled (it has no `open` prop) and opens on the
+		 * CHILD's mouseenter, so a wrapper mounted after the pointer is already
+		 * inside can never open for that visit: the pointer has to leave and
+		 * return. Gate the LABEL's content instead.
+		 */
+		function withTooltip(node, label, maxWidth) {
+			if (Tooltip === void 0) return node;
+			return react_jsx_runtime.jsx(Tooltip, { side: "top", maxWidth, label, children: node });
+		}
+
 		/**
 		 * Chip line in the input row: git state of the workspace the CURRENT
 		 * conversation is attached to. It targets the session id and lets the node
@@ -1044,7 +1083,7 @@ window.__ModuleLoader__.load({
 			const target = sessionId === void 0 ? void 0 : { kind: "session", id: sessionId };
 			// the PR/CI token is always on the chip, so its fetch is not gated
 			const info = useGitStatus(target, { pr: true });
-			// The card's extras cost a `log -3` plus a stash list, so they are
+			// The card's extras cost a `log -10` plus a stash list, so they are
 			// fetched only once a pointer actually RESTS on the chip, then kept
 			// fresh by the same SSE path. Eagerly asking would add both invocations
 			// to every refresh — and a refresh fires on every file edit.
@@ -1069,31 +1108,25 @@ window.__ModuleLoader__.load({
 			// so the extras are paid for exactly when the card that can render them
 			// is about to open. Defined inside the component: it closes over the
 			// hovered state that gates the detail fetch.
-			const hoverableMark = (() => {
-				const mark = react_jsx_runtime.jsx("span", {
+			const hoverableMark = withTooltip(
+				react_jsx_runtime.jsx("span", {
 					onPointerEnter: () => setHovered(true),
 					style: { display: "inline-flex", alignItems: "center", flex: "none", cursor: "default" },
 					children: react_jsx_runtime.jsx(StatusMark, { info })
-				});
-				if (Tooltip === void 0) return mark;
-				return react_jsx_runtime.jsx(Tooltip, {
-					side: "top",
-					// matches the body cap: the tooltip must never be the clamp
-				maxWidth: 600,
-					// a function label keeps the card's element tree out of every render
-					// until the tooltip actually opens
-					label: () => react_jsx_runtime.jsx(HoverCard, { info, detail }),
-					children: mark
-				});
-			})();
+				}),
+				// a function label keeps the card's element tree out of every render
+				// until the tooltip actually opens
+				() => react_jsx_runtime.jsx(HoverCard, { info, detail }),
+				600 // matches the body cap: the tooltip must never be the clamp
+			);
 			// the mark is an element now rather than a leading glyph in the string, so
 			// the SAME StatusMark the sidebar row draws carries the status here too;
 			// the container's 4px gap supplies the space the emoji's own did
 			// The branch NAME is its own hover surface: the commits this branch adds
 			// (BranchCommitsList), sharing the mark's lazy detail fetch. The rest of
 			// the leading text (operation token) and the count keep their own
-			// surfaces. Degrades to plain text without the Tooltip primitive or
-			// when the branch adds nothing beyond upstream.
+			// surfaces. The wrapper is always mounted (see withTooltip); without the
+			// Tooltip primitive the name renders plain.
 			const branchHover = (() => {
 				// The branch name links to the compare view (base...branch) — the web
 				// page of exactly what the lineage tooltip lists. Vouched http(s)
@@ -1106,14 +1139,21 @@ window.__ModuleLoader__.load({
 				// count stays its own surface — it answers a different question.
 				const sync = formatSync(info);
 				const label = info.branch + sync;
-				const branch = isLink
+				// 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: () => { setHovered(true); setBranchLinkHover(true); },
+						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: {
@@ -1123,22 +1163,17 @@ window.__ModuleLoader__.load({
 						},
 						children: label
 					})
-					: react_jsx_runtime.jsx("span", {
-						onPointerEnter: () => setHovered(true),
-						style: { cursor: "default" },
-						children: label
-					});
-				if (Tooltip === void 0 || detail === void 0 || detail === null) {
-					// mid-fetch the branch shows plain; the lineage tooltip is
-					// unconditional once the payload lands
-					return branch;
-				}
-				return react_jsx_runtime.jsx(Tooltip, {
-					side: "top",
-					maxWidth: 480,
-					label: () => react_jsx_runtime.jsx(BranchLineage, { info: detail }),
-					children: branch
+					: label;
+				const branch = react_jsx_runtime.jsx("span", {
+					onPointerEnter: () => setHovered(true),
+					style: { cursor: isLink ? "pointer" : "default" },
+					children: inner
 				});
+				// ALWAYS wrapped. A wrapper mounted only once the lazy detail arrives
+				// cannot open for the visit that fetched it (see the child-stability
+				// note above); until the payload lands the lineage degrades to the base
+				// response, the way the mark's own card already does.
+				return withTooltip(branch, () => react_jsx_runtime.jsx(BranchLineage, { info: detail ?? info }), 480);
 			})();
 			const text = formatOperationToken(info);
 			// The ✎n count is its OWN hover surface: a names-only tooltip (see
@@ -1153,17 +1188,12 @@ window.__ModuleLoader__.load({
 					style: { cursor: "default" },
 					children: countText
 				});
-				const hasNames = (Array.isArray(detail?.untrackedNames) && detail.untrackedNames.length > 0)
-					|| (Array.isArray(detail?.unstagedNames) && detail.unstagedNames.length > 0);
-				if (Tooltip === void 0 || !hasNames) {
-					return count;
-				}
-				return react_jsx_runtime.jsx(Tooltip, {
-					side: "top",
-					maxWidth: 480,
-					label: () => react_jsx_runtime.jsx(CountNames, { info: detail }),
-					children: count
-				});
+				// 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);
@@ -1211,16 +1241,10 @@ window.__ModuleLoader__.load({
 						onBlur: () => setLinkHover(false),
 						children: prToken
 					});
-				if (Tooltip === void 0 || detail === void 0 || detail === null
-					|| !Array.isArray(detail.prCommits) || detail.prCommits.length === 0) {
-					return token;
-				}
-				return react_jsx_runtime.jsx(Tooltip, {
-					side: "top",
-					maxWidth: 480,
-					label: () => react_jsx_runtime.jsx(PrCommitsList, { info: detail }),
-					children: token
-				});
+				// always wrapped (see the branch): while the commits are in flight the
+				// label names the PR state the base response already carries
+				const pending = detail === void 0 || detail === null;
+				return withTooltip(token, () => react_jsx_runtime.jsx(PrCommitsList, { info: detail ?? info, pending }), 480);
 			})();
 			const chip = react_jsx_runtime.jsxs("span", {
 				style: {