dsh-git-badge 0.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kevin McIsaac
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,22 @@
+# dsh-git-badge
+
+Git status badges for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness):
+
+- **Input-row chip** — `🟢 main` next to the access picker, showing the git state of the workspace the current conversation is attached to. Works on every install.
+- **Sidebar row badges** — full Claude-Code-statusline-style badges (`| 🟡 main ↑0 ↓2 ✎3`) on workspace rows. Requires the `sidebar.workspaces.row` seam; without it the plugin degrades to chip-only and logs what's active to the browser console.
+
+Event-driven freshness: working trees are watched and updates push over SSE — badges flip within ~1s of any commit, stage, or edit. One `git status --porcelain=v2` call per sample; the API only answers registered workspace paths.
+
+## Install
+
+```bash
+dsh plugin --profile web add dsh-git-badge
+```
+
+Restart the web process, refresh the browser. Requires Node ≥ 20 and `git` on PATH.
+
+Seam details: [github.com/Kevin-McIsaac/dsh-workspace-git-badge](https://github.com/Kevin-McIsaac/dsh-workspace-git-badge) (SEAM.md / PR.md).
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,4 @@
+# dsh-git-badge bundle patch: mount the node half into the host plugin tree.
+- insert:
+    - id: git-badge
+      name: 'dsh-git-badge'

package/lib/client.js

@@ -0,0 +1,253 @@
+/**
+ * dsh-git-badge — client half.
+ *
+ * Surfaces:
+ *  - sidebar.workspaces.row (seam): full row badge — emoji, branch, sync, ✎files
+ *  - conversation.input.left (upstream): compact chip — emoji + branch only
+ * The hover card is intentionally untouched.
+ */
+window.__ModuleLoader__.load({
+	id: "dsh-git-badge",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let react_jsx_runtime = require("react/jsx-runtime");
+		let react = require("react");
+
+		/** Module-level git-status cache. Entries are invalidated by SSE events, never by age. */
+		const GIT_CACHE = new Map();
+		/** 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. */
+		const FALLBACK_POLL_MS = 60000;
+
+		//#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");
+				eventSource.onmessage = (message) => {
+					let path;
+					try {
+						path = JSON.parse(message.data).path;
+					} 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);
+					}
+					for (const fn of [...eventListeners]) {
+						try {
+							fn(path);
+						} catch {
+							/* one bad subscriber must not starve the rest */
+						}
+					}
+				};
+			}
+			return () => {
+				eventListeners.delete(onChange);
+				eventRefs -= 1;
+				if (eventRefs === 0 && eventSource !== null) {
+					eventSource.close();
+					eventSource = null;
+				}
+			};
+		}
+		//#endregion
+
+		/**
+		 * 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.
+		 */
+		function useGitStatus(cwd) {
+			const cacheKey = cwd;
+			const hit = cacheKey === void 0 ? void 0 : GIT_CACHE.get(cacheKey);
+			const [info, setInfo] = react.useState(hit !== void 0 ? hit.data : void 0);
+			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);
+				}
+				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;
+		}
+
+		/**
+		 * Shared sync/dirty suffix for all surfaces. 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),
+		 *    so every number is positionally attributable
+		 *  - clean workspaces stay quiet: arrows only when nonzero, no ✎ at 0
+		 *  - no upstream: arrows omitted entirely
+		 */
+		function formatGitSuffix(info) {
+			const parts = [];
+			const hasUpstream = info.ahead !== void 0 || info.behind !== void 0;
+			const files = (info.changedFiles || 0) + (info.untrackedFiles || 0);
+			if (hasUpstream && (files > 0 || info.ahead > 0 || info.behind > 0)) {
+				parts.push("\u2191" + (info.ahead || 0));
+				parts.push("\u2193" + (info.behind || 0));
+			}
+			if (files > 0) parts.push("\u270E" + files);
+			return parts.length > 0 ? " " + parts.join(" ") : "";
+		}
+
+		const META_STYLE = {
+			color: "var(--dsw-alias-label-tertiary, #9ea7ad)",
+			fontSize: "12px",
+			lineHeight: "20px",
+			flex: "none",
+			whiteSpace: "nowrap"
+		};
+
+		/**
+		 * Row badge, Claude Code statusline style:
+		 *   the_paragliding_app  | 🟢 main ↑1 ↓2
+		 * Always renders the workspace name (so the row keeps its identity);
+		 * appends the muted `| emoji branch sync` part only for git workspaces.
+		 */
+		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: info.dirty ? "🟡" : "🟢" }),
+					react_jsx_runtime.jsx("span", { style: META_STYLE, children: info.branch + formatGitSuffix(info) })
+				);
+			}
+			return react_jsx_runtime.jsx("span", { style: { display: "flex", alignItems: "center", minWidth: 0 }, children });
+		}
+
+		//#region composer chip (fallback + companion surface: conversation.composer.dock)
+		/** Client root ctx, captured at apply() for the chip's service lookups. */
+		let clientCtx = null;
+
+		/**
+		 * 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.
+		 */
+		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;
+		}
+
+		/**
+		 * 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.
+		 */
+		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 = (info.dirty ? "\uD83D\uDFE1 " : "\uD83D\uDFE2 ") + info.branch + formatGitSuffix(info);
+			return react_jsx_runtime.jsx("span", {
+				style: {
+					display: "inline-flex",
+					alignItems: "center",
+					flex: "none",
+					gap: "4px",
+					color: "var(--dsw-alias-label-secondary, #5b6570)",
+					fontSize: "12px",
+					lineHeight: "24px",
+					whiteSpace: "nowrap",
+					cursor: "default"
+				},
+				children: text
+			});
+		}
+		//#endregion
+
+		const inject = ["slots", "workspaces"];
+
+		/**
+		 * 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.
+		 */
+		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));
+			// 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
+			// install. (Alternative surface if ever needed:
+			// conversation.input.dock = the row below the input, shared with the
+			// usage-stats entry.)
+			ctx.slots.inject("conversation.input.left", () => ctx.slots.register({
+				name: "conversation.input.left",
+				id: "git-badge-chip",
+				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)") + ".");
+		}
+
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	}
+});

package/lib/index.js

@@ -0,0 +1,295 @@
+/**
+ * dsh-git-badge — node half.
+ *
+ * Hardened git-status service behind two routes:
+ *
+ *   GET /api/git-badge?path=<workspace path>[&detail=1]
+ *     - path allowlist: only directories registered as DSH workspaces
+ *       (WorkspaceRegistry records) are ever queried — no filesystem probing
+ *       of arbitrary paths.
+ *     - one git invocation per sample: `git --no-optional-locks status
+ *       --porcelain=v2 --branch` yields branch, ahead/behind, and the
+ *       changed / untracked counts in a single call (`--no-optional-locks`
+ *       guarantees the read never contends with the user's own git
+ *       operations on the index).
+ *     - `detail=1` adds one `log -1` for the hover card; row refresh never
+ *       pays for it.
+ *
+ *   GET /api/git-badge/events   (text/event-stream)
+ *     - pushes `{ path }` dirty notifications the moment a workspace's git
+ *       state can have changed. Freshness is EVENT-DRIVEN: each registered
+ *       workspace root is watched recursively (.git included), so a commit /
+ *       checkout / stage / worktree edit pushes one SSE message and every
+ *       mounted row refetches immediately. There is no fixed polling
+ *       interval anywhere in the pipeline.
+ *
+ * When upstream lands a workspace-metadata service, this half is deleted and
+ * the client half re-points at it — the seam contract does not change.
+ */
+import { execFile } from "node:child_process";
+import { realpath } from "node:fs/promises";
+import { watch, existsSync } from "node:fs";
+import { join } from "node:path";
+
+const inject = ["webServer", "workspaceRegistry"];
+const name = "dsh-git-badge";
+
+/**
+ * Run git in dir. Resolves { stdout } on success; on failure { stdout: null }
+ * plus exactly one of: timeout (execFile timeout kill), missing (no git
+ * binary), or exitCode (git ran and rejected — e.g. "not a repository").
+ * The exitCode/timeout distinction separates a definitive answer (non-repo)
+ * from a transient one (degraded).
+ */
+function runGit(dir, args) {
+	return new Promise((resolve) => {
+		execFile("git", args, { cwd: dir, timeout: 3000 }, (error, stdout) => {
+			if (error === void 0 || error === null) resolve({ stdout: String(stdout) });
+			else if (error.killed) resolve({ stdout: null, timeout: true });
+			else if (error.code === "ENOENT") resolve({ stdout: null, missing: true });
+			else resolve({ stdout: null, exitCode: error.code });
+		});
+	});
+}
+
+/** Marker response for a git invocation that failed or timed out (transient). */
+const GIT_DEGRADED = { git: false, error: "git unavailable (timeout or failure)" };
+
+/**
+ * Parse `git status --porcelain=v2 --branch` output.
+ * Headers: `# branch.head <name>` (or `(detached)`), `# branch.upstream
+ * <name>`, `# branch.ab +ahead -behind`. Records per path: `1`/`2` carry the
+ * two-column XY status (X = index/staged, Y = worktree), `u` unmerged,
+ * `?` untracked.
+ */
+function parseStatusV2(out) {
+	let branch = "HEAD (detached)";
+	let upstream;
+	let ahead;
+	let behind;
+	let staged = 0;
+	let unstaged = 0;
+	let unmerged = 0;
+	let untracked = 0;
+	for (const line of out.split("\n")) {
+		if (line.startsWith("# branch.head ")) branch = line.slice(14).trim();
+		else if (line.startsWith("# branch.upstream ")) upstream = line.slice(18).trim();
+		else if (line.startsWith("# branch.ab ")) {
+			const [, plus, minus] = line.slice(12).trim().split(" ");
+			const a = Number.parseInt((plus ?? "").slice(1), 10);
+			const b = Number.parseInt((minus ?? "").slice(1), 10);
+			if (Number.isFinite(a)) ahead = a;
+			if (Number.isFinite(b)) behind = b;
+		} else if (line.startsWith("1 ") || line.startsWith("2 ")) {
+			// XY columns: X = index (staged), Y = worktree (unstaged)
+			if (line[2] !== ".") staged += 1;
+			if (line[3] !== ".") unstaged += 1;
+		} else if (line.startsWith("u ")) unmerged += 1;
+		else if (line.startsWith("? ")) untracked += 1;
+	}
+	return { branch, upstream, ahead, behind, staged, unstaged, unmerged, untracked };
+}
+
+/**
+ * Git status for dir; { git: false } when dir is not a repository,
+ * GIT_DEGRADED on transient git failure.
+ *
+ * Subdirectory workspaces: status is computed from `--show-toplevel`, so a
+ * workspace pointing INSIDE a larger repository reports that repository's
+ * branch, dirty state, and ahead/behind counts (what git itself considers
+ * dirty), not the subdirectory in isolation. Intentional.
+ */
+async function gitStatus(dir, wantDetail) {
+	const top = await runGit(dir, ["rev-parse", "--show-toplevel"]);
+	if (top.stdout === null) {
+		// git ran and rejected ("not a repository") is a definitive answer;
+		// timeout / missing binary is transient
+		return top.exitCode !== void 0 ? { git: false } : GIT_DEGRADED;
+	}
+	const toplevel = top.stdout.trim();
+	if (toplevel === "") return { git: false };
+	const statusOut = await runGit(toplevel, ["--no-optional-locks", "status", "--porcelain=v2", "--branch"]);
+	if (statusOut.stdout === null) return GIT_DEGRADED;
+	const parsed = parseStatusV2(statusOut.stdout);
+	const dirtyFiles = parsed.staged + parsed.unstaged + parsed.unmerged + parsed.untracked;
+	const info = {
+		git: true,
+		branch: parsed.branch,
+		upstream: parsed.upstream,
+		dirty: dirtyFiles > 0,
+		changedFiles: parsed.staged + parsed.unstaged,
+		stagedFiles: parsed.staged,
+		unstagedFiles: parsed.unstaged,
+		unmergedFiles: parsed.unmerged,
+		untrackedFiles: parsed.untracked,
+		ahead: parsed.ahead,
+		behind: parsed.behind
+	};
+	if (wantDetail) {
+		// last 3 commits (subject + relative age) for the hover card
+		const logOut = await runGit(toplevel, ["log", "-3", "--format=%h%x09%s%x09%cr"]);
+		if (logOut.stdout !== null && logOut.stdout.trim() !== "") {
+			info.lastCommits = logOut.stdout.trim().split("\n").map((line) => {
+				const [hash, subject, when] = line.split("\t");
+				return { hash, subject: subject ?? "", when: when ?? "" };
+			}).filter((c) => c.hash !== void 0);
+		}
+		// stash count, only surfaced when nonzero
+		const stashOut = await runGit(toplevel, ["stash", "list"]);
+		if (stashOut.stdout !== null) {
+			const count = stashOut.stdout.split("\n").filter((l) => l.trim() !== "").length;
+			if (count > 0) info.stashCount = count;
+		}
+	}
+	return info;
+}
+
+//#region git-state watcher
+/**
+ * One recursive watcher per workspace `.git` directory. Any event under it
+ * (HEAD swap, index write, ref update) marks the workspace dirty; a 200ms
+ * debounce collapses burst events (a single `git commit` touches index,
+ * refs, COMMIT_EDITMSG, objects…) into one notification.
+ */
+const watchers = new Map();
+const changeListeners = new Set();
+const WATCH_RETRY_MS = 60000;
+const DEBOUNCE_MS = 200;
+
+function notifyChange(key) {
+	for (const fn of changeListeners) {
+		try {
+			fn(key);
+		} catch {
+			/* a dead SSE subscriber must never break the others */
+		}
+	}
+}
+
+function unwatchWorkspace(key) {
+	const record = watchers.get(key);
+	if (record === void 0) return;
+	watchers.delete(key);
+	if (record.watcher !== null) record.watcher.close();
+	if (record.timer !== void 0) clearTimeout(record.timer);
+}
+
+function watchWorkspace(root, key) {
+	const existing = watchers.get(key);
+	if (existing !== void 0) {
+		// live watcher, or a failed attempt still inside its retry backoff
+		if (existing.watcher !== null || Date.now() - existing.failedAt < WATCH_RETRY_MS) return;
+		watchers.delete(key);
+	}
+	// only git workspaces need a badge; a missing .git skips the watcher but
+	// retries on the normal backoff (cheap existsSync) so a later `git init`
+	// in the workspace is picked up
+	if (!existsSync(join(root, ".git"))) {
+		watchers.set(key, { watcher: null, failedAt: Date.now(), timer: void 0 });
+		return;
+	}
+	try {
+		// Watch the whole worktree, .git included: worktree edits (the most
+		// common dirty signal) and metadata ops (commit / checkout / stage)
+		// all surface here. The 200ms debounce collapses save bursts; if the
+		// tree is too large for the inotify budget the error handler drops
+		// back to the 60s client poll.
+		const watcher = watch(root, { recursive: true }, () => {
+			const record = watchers.get(key);
+			if (record === void 0) return;
+			clearTimeout(record.timer);
+			record.timer = setTimeout(() => notifyChange(key), DEBOUNCE_MS);
+		});
+		watcher.on("error", () => unwatchWorkspace(key));
+		watchers.set(key, { watcher, timer: void 0 });
+	} catch {
+		// watch refused (permissions, watch budget) — remember and back off
+		watchers.set(key, { watcher: null, failedAt: Date.now(), timer: void 0 });
+	}
+}
+
+/** Reconcile the watcher set with the current workspace registry. */
+function syncWatchers(ctx) {
+	const wanted = new Set();
+	for (const entity of ctx.workspaceRegistry.list()) {
+		const p = entity?.record?.path ?? entity?.path;
+		if (typeof p !== "string") continue;
+		wanted.add(p);
+		watchWorkspace(p, p);
+	}
+	for (const key of [...watchers.keys()]) if (!wanted.has(key)) unwatchWorkspace(key);
+}
+//#endregion
+
+/** Host plugin body — register the status route and the SSE change feed. */
+function apply(ctx) {
+	ctx.effect(() => ctx.webServer.register({
+		kind: "exact",
+		path: "/api/git-badge",
+		handler: async (req, res) => {
+			try {
+				const url = new URL(req.url, "http://localhost");
+				const raw = url.searchParams.get("path") ?? "";
+				if (raw === "") throw new Error("missing path");
+				// Allowlist: the requested path must be (or resolve to) a registered
+				// workspace directory. Anything else is refused without inspection.
+				const registered = new Set();
+				for (const entity of ctx.workspaceRegistry.list()) {
+					const p = entity?.record?.path ?? entity?.path;
+					if (typeof p === "string") registered.add(p);
+				}
+				const resolved = await realpath(raw).catch(() => null);
+				if (resolved === null || !registered.has(raw) && !registered.has(resolved)) {
+					res.writeHead(403, { "content-type": "application/json" });
+					res.end(JSON.stringify({ git: false, error: "path is not a registered workspace" }));
+					return;
+				}
+				const detail = url.searchParams.get("detail") === "1";
+				const body = JSON.stringify(await gitStatus(resolved, detail));
+				res.writeHead(200, { "content-type": "application/json" });
+				res.end(body);
+			} catch (error) {
+				res.writeHead(400, { "content-type": "application/json" });
+				res.end(JSON.stringify({ git: false, error: String(error?.message ?? error) }));
+			}
+		}
+	}));
+	ctx.effect(() => ctx.webServer.register({
+		kind: "exact",
+		path: "/api/git-badge/events",
+		handler: async (req, res) => {
+			// keep the watcher set aligned with the live registry on every connect
+			syncWatchers(ctx);
+			res.writeHead(200, {
+				"content-type": "text/event-stream",
+				"cache-control": "no-cache",
+				connection: "keep-alive"
+			});
+			// flush immediately: staged headers only hit the wire on first write,
+			// and the first real event may be minutes away
+			res.write(": connected\n\n");
+			const send = (key) => {
+				try {
+					res.write(`data: ${JSON.stringify({ path: key })}\n\n`);
+				} catch {
+					/* socket gone; the close handler cleans up */
+				}
+			};
+			changeListeners.add(send);
+			// comment-only heartbeat keeps proxies from idling the stream out
+			const heartbeat = setInterval(() => {
+				try {
+					res.write(": hb\n\n");
+				} catch {
+					/* ignore */
+				}
+			}, 25000);
+			req.on("close", () => {
+				changeListeners.delete(send);
+				clearInterval(heartbeat);
+			});
+		}
+	}));
+}
+
+export { apply, inject, name };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "dsh-git-badge",
+  "version": "0.5.0",
+  "description": "Git status badges for DeepSeek Harness: sidebar workspace rows (via the sidebar.workspaces.row seam) and an input-row chip showing the current conversation's workspace git state. Event-driven freshness over SSE.",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime"
+      ],
+      "platform": "web"
+    }
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "dsh-bundle",
+    "git",
+    "status",
+    "badge",
+    "sidebar"
+  ],
+  "author": "Kevin McIsaac",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Kevin-McIsaac/dsh-workspace-git-badge.git",
+    "directory": "plugin"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/client.js",
+    "cordis.patch.yml",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "@deepseek-ai/cordis": ">=4",
+    "@deepseek-ai/dsh-client-runtime": ">=0.1",
+    "react": ">=18"
+  }
+}