dsh-git-badge 0.17.0 → 0.17.1

package/seam/apply.js

@@ -13,13 +13,12 @@
  *     npx dsh-git-badge apply        # then restart the dsh web process
  *
  * HOW PATCHING WORKS — anchors, not hashes. The patch is defined once in
- * anchors.js as [name, old, new] triples. `apply` locates each `old` block in
- * the INSTALLED client.js (each must occur exactly once) and replaces it in
- * place. A DSH update that changes anything else in the file no longer matters;
- * only a change that moves one of the anchors does, and the failure names the
- * anchor that moved instead of reporting an opaque hash mismatch.
+ * anchors.js as [name, old, new] triples; the mechanics (locating the install,
+ * inspecting its state, writing the patch and its backup) live once in
+ * patch.js, shared with the postinstall hook. This file is the CLI: it decides
+ * what to print and which exit codes to take, per the states inspect() names.
  *
- * Safety:
+ * Safety (enforced in patch.js + anchors.js, surfaced here):
  *   - anchor assertion: every anchor must match exactly once; anything else is
  *     drift and NOTHING is written
  *   - own-artifact detection: every artifact carries the dsh-git-badge:seam-patch
@@ -31,154 +30,42 @@
  *     installed build is the one the anchors were verified against, but apply
  *     proceeds on any build whose anchors resolve
  *
- * Environment:
+ * Environment (read by patch.js):
  *   DSH_INSTALL    the DSH package root. Default: `<global npm root>/@deepseek-ai/dsh`.
  *   SEAM_DATA_DIR  where revert backups are written. Default:
  *                  `$DSH_HOME/git-badge-seam` (else `~/.dsh/git-badge-seam`) —
  *                  a stable, user-level store shared by every way this tool
- *                  can run. See the note at the definition below.
+ *                  can run. See seam/store.js for the restart marker.
  *
  * Usage: apply.js apply | apply.js revert | apply.js status
  */
-import { execSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import {
-	MARKER,
-	applyPatch,
-	appliedSignature,
-	firstFailure,
-	isCurrentRev,
-	isOurs,
-	seamPresent,
-} from "./anchors.js";
-
+import { copyFileSync, existsSync, readFileSync } from "node:fs";
+import { MARKER } from "./anchors.js";
+import { backupState, doPatch, doRestore, installPaths, inspect, KNOWN_GOOD_HASH, sha256 } from "./patch.js";
 import { installSkill } from "./skill.js";
-import { dataDir, writeRestartMarker } from "./store.js";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-/**
- * The stable backup store — shared with the postinstall hook and any future
- * invocation path, so an apply→revert round trip works across npx cache
- * entries. SEAM_DATA_DIR overrides (the test suite does, to stay hermetic).
- * See seam/store.js for the full rationale and the restart marker.
- */
-const DATA_DIR = dataDir();
-
-// sha256 of the upstream build the anchors were last verified against. ADVISORY:
-// status prints it for orientation; apply does NOT require it.
-const KNOWN_GOOD_HASH = "383b9ef779366c13d818500b6488896328b189f156addbaa480c835e902edd5f";
-
-/** Locate the installed DSH package root; null when it cannot be found. */
-function dshRoot() {
-	if (process.env.DSH_INSTALL) return process.env.DSH_INSTALL;
-	try {
-		return join(execSync("npm root -g", { encoding: "utf8" }).trim(), "@deepseek-ai", "dsh");
-	} catch {
-		return null;
-	}
-}
+import { writeRestartMarker } from "./store.js";
 
-const DSH = dshRoot();
-if (!DSH) {
+const paths = installPaths();
+if (paths === null) {
 	console.error("ERROR: cannot locate the DSH package. Set DSH_INSTALL to its root");
 	console.error("(e.g. the directory containing node_modules/@deepseek-ai/dsh).");
 	process.exit(1);
 }
-const PKG = join(DSH, "node_modules", "@deepseek-ai", "dsh-client-ui-workspace");
-const CLIENT = join(PKG, "lib", "client.js");
-const INDEX = join(PKG, "lib", "index.js");
-const STUB_INDEX = join(HERE, "stub-index.js"); // no-op host half; copied over index.js on apply
-const BACKUP_CLIENT = join(DATA_DIR, "backup-client.js");
-const BACKUP_INDEX = join(DATA_DIR, "backup-index.js");
-
-const sha256 = (text) => createHash("sha256").update(text, "utf8").digest("hex");
-
-/** Inspect the installed client.js. Returns the same key:value report apply.sh printed. */
-function inspect() {
-	const report = {};
-	let text;
-	try {
-		text = readClient();
-	} catch (error) {
-		if (error.code === "ENOENT") {
-			report.state = "missing";
-			return report;
-		}
-		report.state = "unreadable";
-		report.error = String(error.message ?? error);
-		return report;
-	}
-	report.hash = sha256(text);
-	report.known_good_match = report.hash === KNOWN_GOOD_HASH ? "yes" : "no";
-	report.backup = existsSync(BACKUP_CLIENT) ? "yes" : "no";
-	report.marker = isOurs(text) ? "yes" : "no";
-	report.rev_current = isCurrentRev(text) ? "yes" : "no";
-	report.seam_strings = seamPresent(text) ? "yes" : "no";
-
-	const fail = firstFailure(text);
-	if (fail === null) report.anchors = "all-resolve";
-	else {
-		report.anchors = "drift";
-		report.anchor_fail = `${fail.name}:${fail.count}`;
-	}
-
-	if (isOurs(text)) {
-		// A PATCHED file no longer contains the `old` anchor forms — that is the
-		// point — so it is verified by its applied signature instead.
-		report.applied_signature = appliedSignature(text) ? "yes" : "no";
-		if (!isCurrentRev(text)) report.state = "ours-stale";
-		else if (appliedSignature(text)) report.state = "ours-current";
-		else report.state = "ours-corrupt";
-	} else if (seamPresent(text)) report.state = "upstream-landed";
-	else if (fail === null) report.state = "patchable";
-	else report.state = "drift";
-	return report;
-}
-
-function readClient() {
-	return readText(CLIENT);
-}
-
-function readText(path) {
-	return readFileSync(path, "utf8");
-}
-
-/** Backup the bytes AS FOUND, patch client.js in place, install the no-op host half. */
-function doPatch() {
-	mkdirSync(DATA_DIR, { recursive: true });
-	copyFileSync(CLIENT, BACKUP_CLIENT);
-	copyFileSync(INDEX, BACKUP_INDEX);
-	const patched = applyPatch(readClient());
-	writeText(CLIENT, patched);
-	copyFileSync(STUB_INDEX, INDEX);
-	console.log("patched lib/client.js in place (anchors applied); host half stubbed.");
-	// dshmarket cannot see this host-file change; the plugin surfaces the
-	// restart itself (marker → status response → chip button).
-	writeRestartMarker("apply");
-}
-
-function writeText(path, text) {
-	writeFileSync(path, text, "utf8");
-}
+const CLIENT = paths.client;
 
 const VERDICT_EXIT_1 = new Set(["drift", "unreadable", "missing", "ours-corrupt"]);
 
-// keep the /gh skill in step with the package on every patcher run
-if (["apply", "revert", "status"].includes(process.argv[2])) {
-	console.log(`[dsh-git-badge] gh skill: ${installSkill()}`);
-}
-
 const verb = process.argv[2];
 if (!verb || !["apply", "revert", "status"].includes(verb)) {
 	console.error("usage: apply.js apply|revert|status");
 	process.exit(1);
 }
 
+// keep the /gh skill in step with the package on every patcher run
+console.log(`[dsh-git-badge] gh skill: ${installSkill()}`);
+
 if (verb === "status") {
-	const r = inspect();
+	const r = inspect(paths);
 	console.log(`installed:  ${CLIENT}`);
 	console.log(`hash:       ${r.hash ?? r.error ?? "-"}`);
 	if (r.known_good_match === "yes") console.log("pinned:     KNOWN-GOOD MATCH — the build the anchors were verified against");
@@ -217,7 +104,7 @@ if (verb === "status") {
 }
 
 if (verb === "apply") {
-	const r = inspect();
+	const r = inspect(paths);
 	for (const [k, v] of Object.entries(r)) {
 		if (k !== "state") console.log(`  ${k}=${v}`);
 	}
@@ -227,7 +114,8 @@ if (verb === "apply") {
 			console.log("verdict:    PATCHED (rev current) — nothing to do.");
 			break;
 		case "patchable":
-			doPatch();
+			doPatch(paths, "apply");
+			console.log("patched lib/client.js in place (anchors applied); host half stubbed.");
 			console.log("verdict:    PATCHED.");
 			break;
 		case "ours-stale": {
@@ -235,29 +123,22 @@ if (verb === "apply") {
 			// found them pre-patch). Validate THAT before touching the installed
 			// file: restoring a backup whose anchors no longer resolve would
 			// overwrite the installed build with an unpatchable older one.
-			if (!existsSync(BACKUP_CLIENT)) {
+			if (!existsSync(paths.backupClient)) {
 				console.error("REFUSING: installed file is an older artifact of ours but no backup");
 				console.error("exists, so the original bytes are unknown. Reinstall the package or");
 				console.error("restore the backup by hand, then re-run apply.");
 				process.exit(1);
 			}
-			const backupText = readText(BACKUP_CLIENT);
-			const bstate = isOurs(backupText)
-				? "ours"
-				: seamPresent(backupText)
-					? "upstream-landed"
-					: firstFailure(backupText) === null
-						? "patchable"
-						: "drift";
+			const bstate = backupState(paths);
 			if (bstate !== "patchable") {
 				console.error(`REFUSING: the backup (bytes as found before patching) is '${bstate}',`);
 				console.error("not patchable — the anchors no longer match the backed-up upstream.");
 				console.error("Nothing was changed. Reinstall the DSH package, then re-run apply.");
 				process.exit(1);
 			}
-			writeText(CLIENT, backupText);
-			copyFileSync(BACKUP_INDEX, INDEX);
-			doPatch();
+			doRestore(paths);
+			doPatch(paths, "apply");
+			console.log("patched lib/client.js in place (anchors applied); host half stubbed.");
 			console.log("verdict:    UPGRADED — older artifact replaced with the current patch.");
 			break;
 		}
@@ -287,16 +168,15 @@ if (verb === "apply") {
 	console.log(`now install the plugin:  dsh plugin --profile web add dsh-git-badge`);
 } else {
 	// revert
-	if (existsSync(BACKUP_CLIENT)) {
-		const r = inspect();
+	if (existsSync(paths.backupClient)) {
+		const r = inspect(paths);
 		const installedHash = r.hash;
-		const backupHash = sha256(readText(BACKUP_CLIENT));
+		const backupHash = sha256(readFileSync(paths.backupClient, "utf8"));
 		if (installedHash === backupHash) {
 			// Idempotent re-run: the installed bytes already ARE the backup.
 			console.log("already reverted — installed client.js matches the backup; nothing to do.");
 		} else if (r.state === "ours-current" || r.state === "ours-stale" || r.state === "ours-corrupt") {
-			writeText(CLIENT, readText(BACKUP_CLIENT));
-			copyFileSync(BACKUP_INDEX, INDEX);
+			doRestore(paths);
 			console.log("reverted client.js/index.js to the bytes as found before patching.");
 			// A revert also changes bytes the running bundles were composed from.
 			writeRestartMarker("revert");
@@ -306,14 +186,14 @@ if (verb === "apply") {
 			console.error(`artifact (state: ${r.state}), so upstream replaced it since the patch was`);
 			console.error("applied. Restoring the backup would DOWNGRADE the package.");
 			console.error("Nothing was changed. If the downgrade is really what you want, restore");
-			console.error(`${BACKUP_CLIENT} by hand.`);
+			console.error(`${paths.backupClient} by hand.`);
 			process.exit(1);
 		}
 	} else {
-		const r = inspect();
+		const r = inspect(paths);
 		if (r.state === "ours-current" || r.state === "ours-stale" || r.state === "ours-corrupt") {
 			console.error("REFUSING: the installed file is patched but no backup exists in");
-			console.error(`${DATA_DIR}, so the original bytes are unknown here. Options:`);
+			console.error("the seam data dir, so the original bytes are unknown here. Options:");
 			console.error("  1. If you applied from a clone of the plugin's repository, run its");
 			console.error("     wrapper instead — it keeps its own backup:");
 			console.error("       <clone>/seam/apply.sh revert");
@@ -324,6 +204,6 @@ if (verb === "apply") {
 		console.log("no backup present and nothing of ours installed; client.js left untouched.");
 	}
 	// restore the no-op host half if no backup of the original exists
-	if (!existsSync(BACKUP_INDEX)) copyFileSync(STUB_INDEX, INDEX);
+	if (!existsSync(paths.backupIndex)) copyFileSync(paths.stub, paths.index);
 	console.log("remember to remove the plugin:  dsh plugin --profile web remove dsh-git-badge");
 }

package/seam/checkout.js

@@ -21,6 +21,7 @@
  */
 import { execFileSync } from "node:child_process";
 import { basename, resolve } from "node:path";
+import { parseWorktreeList } from "../lib/index.js";
 import { clearSessionCheckout, writeSessionCheckout } from "./store.js";
 
 function usage(message) {
@@ -28,13 +29,10 @@ function usage(message) {
 	console.error("usage: dsh-git-badge-checkout <path> | --clear");
 }
 
-/** Worktree paths git lists for the repo containing `dir`. */
+/** Worktree paths git lists for the repo containing `dir` — the node half's parser. */
 function worktreePaths(dir) {
 	const out = execFileSync("git", ["-C", dir, "worktree", "list", "--porcelain"], { encoding: "utf8" });
-	return out
-		.split("\n")
-		.filter((line) => line.startsWith("worktree "))
-		.map((line) => resolve(line.slice("worktree ".length).trim()));
+	return parseWorktreeList(out).map((entry) => resolve(entry.path));
 }
 
 function branchOf(dir) {

package/seam/patch.js

@@ -0,0 +1,142 @@
+/**
+ * The seam-patch engine — the ONE copy of the mechanics both patch entry
+ * points share: seam/apply.js (the shipped CLI) and seam/postinstall.js (the
+ * install hook). Locating the install, inspecting its state, and writing the
+ * patch each used to exist twice, once per entry point, with the guardrails
+ * duplicated between them; now the entry points only decide what to SAY and
+ * which exits to take. This module returns facts and never prints.
+ *
+ * The patch itself is defined once in anchors.js; see its header for the
+ * anchor-not-hash design and the safety rails (own-artifact detection, backup
+ * of the bytes as found, downgrade-guarded revert).
+ */
+import { execSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { appliedSignature, applyPatch, firstFailure, isCurrentRev, isOurs, seamPresent } from "./anchors.js";
+import { dataDir, writeRestartMarker } from "./store.js";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+
+// sha256 of the upstream build the anchors were last verified against. ADVISORY:
+// status prints it for orientation; apply does NOT require it.
+export const KNOWN_GOOD_HASH = "383b9ef779366c13d818500b6488896328b189f156addbaa480c835e902edd5f";
+
+/** Locate the installed DSH package root; null when it cannot be found. */
+export function dshRoot() {
+	if (process.env.DSH_INSTALL) return process.env.DSH_INSTALL;
+	try {
+		return join(execSync("npm root -g", { encoding: "utf8" }).trim(), "@deepseek-ai", "dsh");
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * The files one patch acts on, resolved against `root` (default: the located
+ * DSH install). Null when there is no root — the entry points print their own
+ * "cannot locate" advice. Backup paths resolve per call, so SEAM_DATA_DIR (and
+ * DSH_INSTALL) are honoured whenever the process environment says so.
+ */
+export function installPaths(root = dshRoot()) {
+	if (!root) return null;
+	const pkg = join(root, "node_modules", "@deepseek-ai", "dsh-client-ui-workspace");
+	const store = dataDir();
+	return {
+		root,
+		client: join(pkg, "lib", "client.js"),
+		index: join(pkg, "lib", "index.js"),
+		stub: join(HERE, "stub-index.js"),
+		backupClient: join(store, "backup-client.js"),
+		backupIndex: join(store, "backup-index.js")
+	};
+}
+
+export const sha256 = (text) => createHash("sha256").update(text, "utf8").digest("hex");
+
+const readText = (path) => readFileSync(path, "utf8");
+
+/**
+ * Inspect the installed client.js. Returns the key:value report the CLI's
+ * `status` prints, with `state` one of: missing | unreadable | ours-current |
+ * ours-stale | ours-corrupt | upstream-landed | patchable | drift.
+ */
+export function inspect(paths = installPaths()) {
+	const report = {};
+	let text;
+	try {
+		text = readText(paths.client);
+	} catch (error) {
+		if (error.code === "ENOENT") {
+			report.state = "missing";
+			return report;
+		}
+		report.state = "unreadable";
+		report.error = String(error.message ?? error);
+		return report;
+	}
+	report.hash = sha256(text);
+	report.known_good_match = report.hash === KNOWN_GOOD_HASH ? "yes" : "no";
+	report.backup = existsSync(paths.backupClient) ? "yes" : "no";
+	report.marker = isOurs(text) ? "yes" : "no";
+	report.rev_current = isCurrentRev(text) ? "yes" : "no";
+	report.seam_strings = seamPresent(text) ? "yes" : "no";
+
+	const fail = firstFailure(text);
+	if (fail === null) report.anchors = "all-resolve";
+	else {
+		report.anchors = "drift";
+		report.anchor_fail = `${fail.name}:${fail.count}`;
+	}
+
+	if (isOurs(text)) {
+		// A PATCHED file no longer contains the `old` anchor forms — that is the
+		// point — so it is verified by its applied signature instead.
+		report.applied_signature = appliedSignature(text) ? "yes" : "no";
+		if (!isCurrentRev(text)) report.state = "ours-stale";
+		else if (appliedSignature(text)) report.state = "ours-current";
+		else report.state = "ours-corrupt";
+	} else if (seamPresent(text)) report.state = "upstream-landed";
+	else if (fail === null) report.state = "patchable";
+	else report.state = "drift";
+	return report;
+}
+
+/**
+ * The backup's own patchability — the upgrade path validates it BEFORE
+ * restoring, so re-patching can never overwrite the installed build with an
+ * unpatchable older one. Returns "ours" | "upstream-landed" | "patchable" | "drift".
+ */
+export function backupState(paths) {
+	const text = readText(paths.backupClient);
+	return isOurs(text)
+		? "ours"
+		: seamPresent(text)
+			? "upstream-landed"
+			: firstFailure(text) === null
+				? "patchable"
+				: "drift";
+}
+
+/**
+ * Backup the bytes AS FOUND, patch client.js in place, install the no-op host
+ * half, and record the restart marker (`reason` names the actor: apply |
+ * postinstall | revert). Callers gate on inspect() first — this writes
+ * unconditionally.
+ */
+export function doPatch(paths, reason = "apply") {
+	mkdirSync(dataDir(), { recursive: true });
+	copyFileSync(paths.client, paths.backupClient);
+	copyFileSync(paths.index, paths.backupIndex);
+	writeFileSync(paths.client, applyPatch(readText(paths.client)));
+	copyFileSync(paths.stub, paths.index);
+	writeRestartMarker(reason);
+}
+
+/** Restore the backup over the installed files. The caller has already gated. */
+export function doRestore(paths) {
+	writeFileSync(paths.client, readText(paths.backupClient));
+	copyFileSync(paths.backupIndex, paths.index);
+}

package/seam/postinstall.js

@@ -10,6 +10,11 @@
  * applied right here; otherwise the plugin's boot log and the chip tooltip name
  * the same one manual command.
  *
+ * The mechanics live once in patch.js, shared with the apply CLI — the state
+ * gate below reads the same inspect() report the CLI acts on, so the hook and
+ * the tool cannot disagree about what a file's state is. This file only decides
+ * what to print for each state at install time.
+ *
  * GUARDRAILS — this script may never break an install:
  *   - it runs ONLY when the installed DSH client.js is pristine upstream AND
  *     every anchor resolves exactly once (`patchable`); any other state —
@@ -21,68 +26,51 @@
  * client bundle at boot, and an install script restarting the host that is
  * installing it is not safe to automate.
  */
-import { execSync } from "node:child_process";
-import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { applyPatch, firstFailure, isOurs, seamPresent } from "./anchors.js";
+import { existsSync, readFileSync } from "node:fs";
+import { firstFailure } from "./anchors.js";
+import { doPatch, installPaths, inspect } from "./patch.js";
 import { installSkill } from "./skill.js";
-import { dataDir, writeRestartMarker } from "./store.js";
 
-const HERE = dirname(fileURLToPath(import.meta.url));
 const HINT = "Sidebar session-row badges need one manual step: `npx dsh-git-badge apply`, then restart dsh web.";
 
-function dshClientPath() {
-	try {
-		const root = process.env.DSH_INSTALL || join(execSync("npm root -g", { encoding: "utf8" }).trim(), "@deepseek-ai", "dsh");
-		return join(root, "node_modules", "@deepseek-ai", "dsh-client-ui-workspace", "lib", "client.js");
-	} catch {
-		return null;
-	}
-}
-
 function main() {
 	// The skill does not depend on the DSH install — install it before any
 	// client-shaped early return, so a market install always gets /gh.
 	console.log(`[dsh-git-badge] gh skill: ${installSkill()} — /gh in the input's commands menu.`);
-	const client = dshClientPath();
-	if (client === null || !existsSync(client)) {
+	const paths = installPaths();
+	if (paths === null || !existsSync(paths.client)) {
 		console.log(`[dsh-git-badge] DSH install not found; skipping seam setup. ${HINT}`);
 		return;
 	}
-	// the index stub is copied with the client on apply (see apply.js)
-	const index = join(dirname(client), "index.js");
-	const text = readFileSync(client, "utf8");
-
-	// Already ours (any rev): nothing to do here; apply.js upgrade rules govern.
-	if (isOurs(text)) {
-		console.log("[dsh-git-badge] seam already applied — sidebar session-row badges active after restart.");
-		return;
-	}
-	// Upstream landed the seam: the patch is retired.
-	if (seamPresent(text)) {
-		console.log("[dsh-git-badge] DSH declares the seam itself — no patch needed.");
-		return;
-	}
-	// Pristine, but the anchors no longer resolve: a DSH update moved anchored
-	// code. Never patch half of anything — print, and let a patched anchors.js
-	// do it.
-	const fail = firstFailure(text);
-	if (fail !== null) {
-		console.log(`[dsh-git-badge] DSH build drifted from the patch anchors (${fail.name}); skipping. ${HINT}`);
-		return;
+	const state = inspect(paths).state;
+	switch (state) {
+		// Already ours (any rev): nothing to do here; apply.js upgrade rules govern.
+		case "ours-current":
+		case "ours-stale":
+		case "ours-corrupt":
+			console.log("[dsh-git-badge] seam already applied — sidebar session-row badges active after restart.");
+			return;
+		// Upstream landed the seam: the patch is retired.
+		case "upstream-landed":
+			console.log("[dsh-git-badge] DSH declares the seam itself — no patch needed.");
+			return;
+		// Pristine, but the anchors no longer resolve: a DSH update moved anchored
+		// code. Never patch half of anything — print, and let a patched anchors.js
+		// do it.
+		case "drift": {
+			const fail = firstFailure(readFileSync(paths.client, "utf8"));
+			console.log(`[dsh-git-badge] DSH build drifted from the patch anchors (${fail?.name}); skipping. ${HINT}`);
+			return;
+		}
+		case "patchable":
+			// The one state we act on: pristine upstream, anchors resolve.
+			doPatch(paths, "postinstall");
+			console.log("[dsh-git-badge] seam applied — RESTART dsh web to get sidebar session-row badges.");
+			return;
+		default:
+			// missing / unreadable / ours-corrupt: nothing this hook can do safely.
+			console.log(`[dsh-git-badge] DSH install state '${state}'; skipping seam setup. ${HINT}`);
 	}
-	// The one state we act on: pristine upstream, anchors resolve.
-	mkdirSync(dataDir(), { recursive: true });
-	copyFileSync(client, join(dataDir(), "backup-client.js"));
-	copyFileSync(index, join(dataDir(), "backup-index.js"));
-	writeFileSync(client, applyPatch(text));
-	copyFileSync(join(HERE, "stub-index.js"), index);
-	console.log("[dsh-git-badge] seam applied — RESTART dsh web to get sidebar session-row badges.");
-	// Tell the running UI: dshmarket cannot see this host-file change, so the
-	// plugin offers the Restart button itself (marker → status response → chip).
-	// Read/cleared by the plugin halves — see seam/store.js.
-	writeRestartMarker("postinstall");
 }
 
 try {

package/seam/store.js

@@ -85,11 +85,15 @@ function sessionCheckoutsPath() {
 	return join(dataDir(), "session-checkouts.json");
 }
 
-/** Every registration, `{ sessionId: { path, at } }`. Never throws. */
-export function readSessionCheckouts() {
+/** Every registration, `{ sessionId: { path, at } }`. Never throws.
+ *
+ * `file` overrides the store path — the test seam lib/index.js uses (its
+ * `config.sessionCheckoutsFile`) — so the file's shape is parsed in ONE place.
+ */
+export function readSessionCheckouts(file = sessionCheckoutsPath()) {
 	try {
-		if (!existsSync(sessionCheckoutsPath())) return {};
-		const raw = JSON.parse(readFileSync(sessionCheckoutsPath(), "utf8"));
+		if (!existsSync(file)) return {};
+		const raw = JSON.parse(readFileSync(file, "utf8"));
 		return raw !== null && typeof raw === "object" && typeof raw.sessions === "object" && raw.sessions !== null
 			? raw.sessions
 			: {};