gentle-shell-bridge 0.3.0 → 0.3.1

package/test/card-styles.test.ts

@@ -1,324 +0,0 @@
-/**
- * The card-style registry, its process-global snapshot, and the bridge-owned selection (S1, S2, S12).
- *
- * A style is a registration like a provider or a section: one id, replace-in-place, an exact
- * disposer, and a fresh ordered snapshot. The selection is the bridge's own state, `native` by
- * default, and it must be resolvable to "no such style" WITHOUT throwing even after the style that
- * owned it was disposed (S12) — the transformer degrades from that answer, it never guesses.
- */
-
-import assert from "node:assert/strict";
-import {
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import test from "node:test";
-
-import { publishBridgeApi } from "../src/api.ts";
-import {
-  registerCardStyle,
-  resetBusForTests,
-  resetCardStylesForTests,
-  resetSectionsForTests,
-  snapshotCardStyles,
-} from "../src/bus.ts";
-import { CARD_STYLE_NATIVE } from "../src/card-style-line.ts";
-import {
-  CARD_STYLE_STORE_ID,
-  getCardStyleSelection,
-  resolveCardStyleSelection,
-  setCardStyleSelection,
-} from "../src/card-styles.ts";
-import { resetStoreStateForTests } from "../src/store.ts";
-import type { CardStyleRegistration } from "../src/types.ts";
-
-let configHome: string;
-let previousConfigHome: string | undefined;
-
-test.before(() => {
-  configHome = mkdtempSync(join(tmpdir(), "gsb-card-styles-"));
-  previousConfigHome = process.env.GENTLE_PI_CONFIG_HOME;
-  process.env.GENTLE_PI_CONFIG_HOME = configHome;
-});
-
-test.after(() => {
-  if (previousConfigHome === undefined) delete process.env.GENTLE_PI_CONFIG_HOME;
-  else process.env.GENTLE_PI_CONFIG_HOME = previousConfigHome;
-  rmSync(configHome, { recursive: true, force: true });
-});
-
-test.beforeEach(() => {
-  // The selection is a real file: every test starts from nothing on disk.
-  rmSync(join(configHome, "gentle-shell-bridge"), { recursive: true, force: true });
-  resetBusForTests();
-  resetSectionsForTests();
-  resetCardStylesForTests();
-  resetStoreStateForTests();
-});
-
-const frame = () => ({
-  top: (ctx: { width: number }) => "─".repeat(ctx.width),
-  line: (ctx: { text: string }) => ctx.text,
-  bottom: (ctx: { width: number }) => "─".repeat(ctx.width),
-});
-
-const style = (id: string, extra: Partial<CardStyleRegistration> = {}): CardStyleRegistration => ({
-  id,
-  label: id,
-  frame: frame(),
-  ...extra,
-});
-
-const ids = (): string[] => snapshotCardStyles().map((registered) => registered.id);
-
-// ---------------------------------------------------------------------------------------------
-// The registry
-// ---------------------------------------------------------------------------------------------
-
-test("a registered style appears in the snapshot in registration order", () => {
-  registerCardStyle(style("loon.cute"));
-  registerCardStyle(style("loon.mono"));
-
-  assert.deepEqual(ids(), ["loon.cute", "loon.mono"]);
-});
-
-test("a style may declare an order: ordered styles first, ascending, then the rest by registration", () => {
-  registerCardStyle(style("late"));
-  registerCardStyle(style("second", { order: 2 }));
-  registerCardStyle(style("first", { order: 1 }));
-  registerCardStyle(style("third", { order: 3 }));
-
-  assert.deepEqual(ids(), ["first", "second", "third", "late"]);
-});
-
-test("the same id replaces in place: one entry, its position and neighbours kept", () => {
-  registerCardStyle(style("a"));
-  registerCardStyle(style("b", { label: "old" }));
-  registerCardStyle(style("c"));
-
-  const replacement = style("b", { label: "new" });
-  registerCardStyle(replacement);
-
-  assert.deepEqual(ids(), ["a", "b", "c"]);
-  assert.equal(snapshotCardStyles()[1], replacement, "the later registration is the live one");
-});
-
-test("the disposer removes exactly its own registration, once", () => {
-  registerCardStyle(style("a"));
-  const disposeB = registerCardStyle(style("b"));
-  registerCardStyle(style("c"));
-
-  disposeB();
-  disposeB();
-
-  assert.deepEqual(ids(), ["a", "c"]);
-});
-
-test("after a same-id replacement the replaced registration's disposer is a no-op", () => {
-  const disposeOld = registerCardStyle(style("a"));
-  const replacement = style("a", { label: "new" });
-  registerCardStyle(replacement);
-
-  disposeOld();
-
-  assert.equal(snapshotCardStyles().length, 1);
-  assert.equal(snapshotCardStyles()[0], replacement);
-});
-
-test("the snapshot is a fresh copy, so a caller cannot mutate the registry", () => {
-  registerCardStyle(style("a"));
-
-  const snapshot = snapshotCardStyles() as CardStyleRegistration[];
-  snapshot.push(style("b"));
-  snapshot.length = 0;
-
-  assert.deepEqual(ids(), ["a"]);
-});
-
-test("an id that cannot be a plain object key is rejected before anything is stored", () => {
-  const rejected: unknown[] = ["", "   ", "__proto__", "constructor", "prototype", 42, null, undefined, "nu\0l"];
-
-  for (const id of rejected) {
-    assert.throws(
-      () => registerCardStyle(style(id as string)),
-      /invalid card style id/u,
-      `must reject ${JSON.stringify(id)}`,
-    );
-  }
-  assert.deepEqual(snapshotCardStyles(), [], "a rejected style never half-registers");
-});
-
-test("an id the bridge or the host already owns is rejected", () => {
-  for (const id of [CARD_STYLE_NATIVE, "neon", "float"]) {
-    assert.throws(() => registerCardStyle(style(id)), /invalid card style id/u, `must reject ${id}`);
-  }
-  assert.deepEqual(snapshotCardStyles(), []);
-});
-
-test("the three frame functions are required", () => {
-  for (const broken of [
-    { ...style("a"), frame: undefined },
-    { ...style("a"), frame: {} },
-    { ...style("a"), frame: { ...frame(), top: "nope" } },
-    { ...style("a"), frame: { ...frame(), line: undefined } },
-    { ...style("a"), frame: { ...frame(), bottom: 7 } },
-  ]) {
-    assert.throws(() => registerCardStyle(broken as CardStyleRegistration), /frame/u);
-  }
-  assert.deepEqual(snapshotCardStyles(), []);
-});
-
-test("a label is required, because it is what the user reads on the line", () => {
-  for (const label of ["", "  ", 42, undefined]) {
-    assert.throws(
-      () => registerCardStyle({ ...style("a"), label } as unknown as CardStyleRegistration),
-      /label/u,
-    );
-  }
-  assert.deepEqual(snapshotCardStyles(), []);
-});
-
-test("a label that another style already shows is rejected (S13)", () => {
-  registerCardStyle(style("loon.cute", { label: "cute" }));
-
-  assert.throws(
-    () => registerCardStyle(style("pix.cute", { label: "cute" })),
-    /invalid card style label "cute"/u,
-    "two values reading the same is ambiguous on the line",
-  );
-  assert.deepEqual(ids(), ["loon.cute"], "the rejected style never half-registered");
-});
-
-test("labels are compared case-sensitively, exactly as the host displays them (S13)", () => {
-  registerCardStyle(style("loon.cute", { label: "cute" }));
-
-  assert.doesNotThrow(
-    () => registerCardStyle(style("pix.cute", { label: "Cute" })),
-    "a different casing is a different string on the line, so it is allowed",
-  );
-  assert.deepEqual(ids(), ["loon.cute", "pix.cute"]);
-});
-
-test("a label equal to one of the host's own values is rejected (S13)", () => {
-  for (const label of ["neon", "float"]) {
-    assert.throws(
-      () => registerCardStyle(style("loon.shadow", { label })),
-      (error: unknown) =>
-        error instanceof Error &&
-        error.message.includes(`invalid card style label "${label}" for "loon.shadow"`),
-      `a value reading ${label} is indistinguishable from the host's`,
-    );
-  }
-  assert.deepEqual(snapshotCardStyles(), []);
-});
-
-test("re-registering the same id may keep its own label (S13)", () => {
-  registerCardStyle(style("loon.cute", { label: "cute" }));
-  const replacement = style("loon.cute", { label: "cute", order: 5 });
-
-  assert.doesNotThrow(() => registerCardStyle(replacement));
-
-  assert.equal(snapshotCardStyles()[0], replacement);
-});
-
-test("two loaded copies of the package share one registry and one order", async () => {
-  registerCardStyle(style("first", { order: 1 }));
-
-  const copyPath = new URL("../src/bus.ts?second-copy", import.meta.url).href;
-  const second = (await import(copyPath)) as typeof import("../src/bus.ts");
-  second.registerCardStyle(style("second", { order: 2 }));
-
-  assert.deepEqual(ids(), ["first", "second"], "the first copy sees the second copy's style");
-  assert.deepEqual(
-    second.snapshotCardStyles().map((registered: CardStyleRegistration) => registered.id),
-    ["first", "second"],
-    "and the second copy sees the same order",
-  );
-});
-
-// ---------------------------------------------------------------------------------------------
-// The bridge-owned selection
-// ---------------------------------------------------------------------------------------------
-
-test("the selection is native before anything is stored", () => {
-  assert.equal(getCardStyleSelection(), CARD_STYLE_NATIVE);
-  assert.deepEqual(resolveCardStyleSelection(), { kind: "native" });
-});
-
-test("a selection round-trips through the bridge's own file", () => {
-  registerCardStyle(style("loon.cute"));
-
-  setCardStyleSelection("loon.cute");
-
-  assert.equal(getCardStyleSelection(), "loon.cute");
-  const file = join(configHome, "gentle-shell-bridge", `${CARD_STYLE_STORE_ID}.json`);
-  assert.ok(existsSync(file), "the bridge owns the file, not the host");
-  const document = JSON.parse(readFileSync(file, "utf8")) as { schemaVersion: number; values: Record<string, unknown> };
-  assert.equal(document.schemaVersion, 1);
-  assert.equal(document.values.cardStyle, "loon.cute");
-  assert.deepEqual(readdirSync(join(configHome, "gentle-shell-bridge")), [`${CARD_STYLE_STORE_ID}.json`]);
-});
-
-test("a stored selection resolves to the registered style by identity", () => {
-  const registered = style("loon.cute", { label: "cute" });
-  registerCardStyle(registered);
-  setCardStyleSelection("loon.cute");
-
-  const resolved = resolveCardStyleSelection();
-  assert.equal(resolved.kind, "style");
-  assert.equal(resolved.kind === "style" ? resolved.style : undefined, registered);
-});
-
-test("a selection whose style is gone resolves to missing without throwing (S12)", () => {
-  const dispose = registerCardStyle(style("loon.cute"));
-  setCardStyleSelection("loon.cute");
-  dispose();
-
-  assert.deepEqual(resolveCardStyleSelection(), { kind: "missing", id: "loon.cute" });
-  assert.equal(getCardStyleSelection(), "loon.cute", "the stored value is not rewritten behind the user");
-});
-
-test("a selection nobody ever registered resolves to missing, not to native", () => {
-  setCardStyleSelection("loon.never");
-
-  assert.deepEqual(resolveCardStyleSelection(), { kind: "missing", id: "loon.never" });
-});
-
-test("a hand-edited file that is not a string falls back to native", () => {
-  const directory = join(configHome, "gentle-shell-bridge");
-  const file = join(directory, `${CARD_STYLE_STORE_ID}.json`);
-  rmSync(directory, { recursive: true, force: true });
-  mkdirSync(directory, { recursive: true });
-  writeFileSync(file, JSON.stringify({ schemaVersion: 1, values: { cardStyle: 7 } }), "utf8");
-
-  assert.equal(getCardStyleSelection(), CARD_STYLE_NATIVE);
-  assert.deepEqual(resolveCardStyleSelection(), { kind: "native" });
-});
-
-// ---------------------------------------------------------------------------------------------
-// The published surface
-// ---------------------------------------------------------------------------------------------
-
-test("registerCardStyle is on the API object plugins receive", () => {
-  const api = publishBridgeApi();
-  const register = api.registerCardStyle;
-
-  assert.equal(typeof register, "function", "the member is present, so a plugin may call it");
-  const dispose = register?.(style("loon.cute"));
-
-  assert.deepEqual(ids(), ["loon.cute"]);
-  dispose?.();
-  assert.deepEqual(snapshotCardStyles(), []);
-});
-
-test("registerCardStyle is exported from the package entry point", async () => {
-  const entry = await import("../src/index.ts");
-  assert.equal(entry.registerCardStyle, registerCardStyle);
-});

package/test/card-transcript-path.test.ts

@@ -1,178 +0,0 @@
-/**
- * T1: the path and the grammar, proven against the fixture (S4, S3).
- *
- * No feature code is exercised here — there is none yet (T3 owns the transformer). What is pinned
- * is the two facts the transformer will be written against:
- *
- * 1. **The walk.** From the captured `tui`, the component whose `render(width)` produces the
- *    conversation is reachable through `tui.layoutRoot` → its layout entries → the primary
- *    `ScrollView` → its child, and through the public `tui.children[0]` → the document → its third
- *    child. Both must land on the SAME object as the fixture's card component, and both must fail
- *    cleanly (no throw, no invented object) when the tree is not mounted or not fullscreen.
- * 2. **The grammar.** The fixture's lines are what `float` actually produces: opener/header/body/
- *    closer in that order, bars in column 1, the hint right-aligned in the dim role, and an
- *    empty-body card folded to three rows. `neon` must be visibly different, or detection would
- *    confuse the two.
- *
- * The real host is never imported: `test/fake-transcript.ts` documents where each shape comes from.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-  BASH_CARD,
-  CONVERSATION,
-  LAYOUT_NODE,
-  NEON_CARD,
-  PROSE_LINE,
-  READ_CARD,
-  createFakeTranscriptTui,
-  layoutNodeOf,
-  stripAnsi,
-  type FakeComponent,
-  type FakeDocument,
-  type FakeTui,
-} from "./fake-transcript.ts";
-
-/**
- * Candidate (a), as `src/card-styles.ts` documents it: `layoutRoot` is TS-`private` on Pi's
- * fullscreen renderer (`pi-tui/dist/tui-alt-screen.d.ts:44`), so the walk reads it through a
- * widened cast. Everything after that hop uses the PUBLIC layout protocol.
- */
-function conversationViaLayoutRoot(tui: FakeTui): FakeComponent | undefined {
-  const root = (tui as { layoutRoot?: unknown }).layoutRoot;
-  const rootNode = layoutNodeOf(root);
-  if (rootNode === undefined) return undefined;
-  const first = rootNode.entries?.[0]?.component;
-  if (first === null || typeof first !== "object") return undefined;
-  // A ScrollView is the component that owns a scrollbar and can set it (scroll-view.d.ts:24-40).
-  const scroll = first as { scrollbar?: unknown; setScrollbar?: unknown };
-  if (typeof scroll.setScrollbar !== "function" || !("scrollbar" in scroll)) return undefined;
-  return layoutNodeOf(first)?.component as FakeComponent | undefined;
-}
-
-/** Candidate (b): public `children[0]` is the document container, in either renderer mode. */
-function documentViaChildren(tui: FakeTui): FakeComponent | undefined {
-  const children = (tui as { children?: unknown }).children;
-  if (!Array.isArray(children) || children.length === 0) return undefined;
-  const document = children[0] as { children?: unknown };
-  if (document === null || typeof document !== "object") return undefined;
-  if (!Array.isArray(document.children)) return undefined;
-  // Candidate (c): the conversation cards are the document's third child (interactive-mode.js:407).
-  return document.children[2] as FakeComponent | undefined;
-}
-
-test("both documented walks reach the conversation component", () => {
-  const tui = createFakeTranscriptTui();
-
-  // The layout walk lands on the document container (the ScrollView's child).
-  assert.equal(conversationViaLayoutRoot(tui), tui.document, "layoutRoot → ScrollView → document");
-  // From there — and independently through `children[0]` — the card component is the third child.
-  assert.equal(documentViaChildren(tui), tui.chat, "children[0] → document → children[2]");
-  assert.equal(
-    (conversationViaLayoutRoot(tui) as unknown as FakeDocument).children[2],
-    documentViaChildren(tui),
-    "both walks agree on the object: the exact identity a wrapper must not duplicate",
-  );
-  assert.equal(tui.chat.render(40).length, CONVERSATION.length, "it renders the fake conversation");
-});
-
-test("the transcript renders the document at the content width, not the viewport width", () => {
-  const tui = createFakeTranscriptTui();
-  assert.ok(tui.transcript !== undefined);
-
-  const lines = tui.transcript.render(40);
-
-  assert.deepEqual(tui.chat.widths, [39], "the scrollbar column is taken out before the cards see it");
-  assert.equal(lines.length, CONVERSATION.length + 2, "header and resources rows precede the chat");
-  assert.equal(lines[2], `${PROSE_LINE} `, "and the scrollbar column is padded back on");
-});
-
-test("regular mode has no layout root, so that walk finds nothing and the other still works", () => {
-  const tui = createFakeTranscriptTui({ mode: "regular" });
-
-  assert.equal("layoutRoot" in tui, false, "TuiMainScreen has no layoutRoot field at all");
-  assert.equal(conversationViaLayoutRoot(tui), undefined);
-  assert.equal(documentViaChildren(tui), tui.chat, "children are mounted in both modes");
-});
-
-test("before mounting there is no transcript by any path, and no throw", () => {
-  const tui = createFakeTranscriptTui({ mounted: false });
-
-  assert.equal(conversationViaLayoutRoot(tui), undefined);
-  assert.equal(documentViaChildren(tui), undefined);
-  assert.deepEqual(tui.children, []);
-});
-
-test("float cards are padding, header, padding, body rows, padding — in that order", () => {
-  const rows = READ_CARD.map(stripAnsi);
-
-  assert.equal(rows.length, 5);
-  // Opener and closer are `cardBottom` with no content: the accent bar and spaces.
-  const padding = /^ ▎ +$/u;
-  assert.match(rows[0] ?? "", padding, "opener: margin, bar, spaces");
-  assert.match(rows[2] ?? "", padding, "separator between header and body");
-  assert.match(rows[4] ?? "", padding, "closer");
-  // Header: bar, one space, glyph + title, then the hint in the dim role.
-  // One margin column, bar, one space, glyph + title, fill, one space, hint, then the tail space,
-  // the two-column float `topRight` and the trailing margin: four spaces after the hint.
-  assert.match(rows[1] ?? "", /^ ▎ ✿ read +ctrl\+o {4}$/u, "title left, hint right-aligned");
-  // Body: bar, one space, the text, then the float right rail (a space inside the margin).
-  assert.match(rows[3] ?? "", /^ ▎ config\.ts +$/u);
-  assert.equal(rows.every((row) => [...row].length <= 40), true, "nothing exceeds the width");
-});
-
-test("the hint is the only dim segment on the header row; without one the row ends in spaces", () => {
-  assert.match(READ_CARD[1] ?? "", /\u001b\[2mctrl\+o\u001b\[39m/u, "hint painted HINT_ROLE=dim");
-  assert.match(READ_CARD[1] ?? "", /\u001b\[95m✿ read\u001b\[39m/u, "title painted the title role");
-
-  const withoutHint = stripAnsi(BASH_CARD[1] ?? "");
-  assert.match(withoutHint, /^ ▎ ✿ bash +$/u);
-  assert.equal(BASH_CARD[1]?.includes("\u001b[2m"), false, "no dim segment at all");
-});
-
-test("an empty body folds the card to three rows: padding, header, padding", () => {
-  assert.equal(BASH_CARD.length, 3);
-  assert.equal(stripAnsi(BASH_CARD[0] ?? ""), stripAnsi(READ_CARD[0] ?? ""), "opener is identical");
-  assert.equal(stripAnsi(BASH_CARD[2] ?? ""), stripAnsi(READ_CARD[4] ?? ""), "closer is identical");
-});
-
-test("neon is a different grammar: no margin, no bar, no background", () => {
-  const rows = NEON_CARD.map(stripAnsi);
-
-  assert.match(rows[0] ?? "", /^╭─ ✿ read ─+ ctrl\+o ╮$/u);
-  assert.match(rows[1] ?? "", /^│ config\.ts +│$/u);
-  assert.match(rows[2] ?? "", /^╰─+╯$/u);
-
-  for (const row of NEON_CARD) {
-    assert.equal(row.includes("▎"), false, "no float accent bar in an outlined card");
-    assert.equal(row.includes("\u001b[48;5;236m"), false, "and no tone background");
-  }
-  for (const row of [...READ_CARD, ...BASH_CARD]) {
-    assert.equal(row.startsWith(" "), true, "every float row starts with the one-column margin");
-    assert.equal(stripAnsi(row).includes("╭"), false, "and none of them carries outline chrome");
-  }
-});
-
-test("the conversation interleaves card rows with rows a repaint must leave alone", () => {
-  const lines = CONVERSATION.map(stripAnsi);
-  const index = lines.indexOf(PROSE_LINE);
-
-  assert.ok(index >= 0);
-  assert.equal(lines[index]?.startsWith(" ▎"), false, "prose is not card chrome");
-  assert.ok(lines.includes(""), "blank rows separate the cards");
-  assert.equal(lines.filter((line) => line.startsWith(" ▎ ✿ ")).length, 3, "three card headers");
-});
-
-test("the layout protocol is what makes the walk independent of concrete classes", () => {
-  const tui = createFakeTranscriptTui();
-  const node = layoutNodeOf(tui.layoutRoot);
-
-  assert.equal(node?.type, "vstack");
-  assert.equal(node?.entries?.length, 2, "transcript first, dock second (chat-viewport.js:22-25)");
-  const transcript = node?.entries?.[0]?.component as Record<symbol, unknown>;
-  assert.equal(typeof transcript[LAYOUT_NODE], "function");
-  assert.equal(layoutNodeOf(transcript)?.type, "scroll");
-  assert.equal(layoutNodeOf(transcript)?.component, tui.document);
-});

package/test/config.test.ts

@@ -1,93 +0,0 @@
-import assert from "node:assert/strict";
-import { homedir } from "node:os";
-import test from "node:test";
-
-import {
-  getBridgeConfigHome,
-  getConfigHome,
-  resolveBridgeConfigHome,
-  resolveConfigHome,
-} from "../src/config.ts";
-
-const HOME = "/home/tester";
-const CWD = "/work/repo";
-
-test("GENTLE_PI_CONFIG_HOME set is used verbatim", () => {
-  assert.equal(
-    resolveConfigHome({ env: { GENTLE_PI_CONFIG_HOME: "/srv/gentle" }, homeDir: HOME, cwd: CWD }),
-    "/srv/gentle",
-  );
-});
-
-test("unset GENTLE_PI_CONFIG_HOME falls back to <home>/.pi/gentle-ai", () => {
-  assert.equal(resolveConfigHome({ env: {}, homeDir: HOME, cwd: CWD }), `${HOME}/.pi/gentle-ai`);
-});
-
-test("empty GENTLE_PI_CONFIG_HOME falls back to the default", () => {
-  assert.equal(
-    resolveConfigHome({ env: { GENTLE_PI_CONFIG_HOME: "" }, homeDir: HOME, cwd: CWD }),
-    `${HOME}/.pi/gentle-ai`,
-  );
-});
-
-test('"~" and "~/..." are expanded against the supplied home directory', () => {
-  assert.equal(
-    resolveConfigHome({ env: { GENTLE_PI_CONFIG_HOME: "~" }, homeDir: HOME, cwd: CWD }),
-    HOME,
-  );
-  assert.equal(
-    resolveConfigHome({ env: { GENTLE_PI_CONFIG_HOME: "~/cfg/gentle" }, homeDir: HOME, cwd: CWD }),
-    `${HOME}/cfg/gentle`,
-  );
-});
-
-test('only a bare "~" or a leading "~/" is tilde-expanded', () => {
-  // "~name" is another user's home; we do not invent a lookup, so the value stays literal and
-  // then falls into the relative-path rule below.
-  assert.equal(
-    resolveConfigHome({ env: { GENTLE_PI_CONFIG_HOME: "~weird/cfg" }, homeDir: HOME, cwd: CWD }),
-    `${CWD}/~weird/cfg`,
-  );
-});
-
-test("a relative override is resolved to an absolute path against cwd", () => {
-  assert.equal(
-    resolveConfigHome({ env: { GENTLE_PI_CONFIG_HOME: "cfg/gentle" }, homeDir: HOME, cwd: CWD }),
-    `${CWD}/cfg/gentle`,
-  );
-});
-
-test("redundant separators and dot segments are normalized", () => {
-  assert.equal(
-    resolveConfigHome({
-      env: { GENTLE_PI_CONFIG_HOME: "/srv/./gentle//../gentle/" },
-      homeDir: HOME,
-      cwd: CWD,
-    }),
-    "/srv/gentle",
-  );
-});
-
-test("the bridge directory is <config home>/gentle-shell-bridge", () => {
-  assert.equal(resolveBridgeConfigHome("/srv/gentle"), "/srv/gentle/gentle-shell-bridge");
-  assert.equal(
-    resolveBridgeConfigHome("/srv/gentle/"),
-    "/srv/gentle/gentle-shell-bridge",
-    "a trailing separator must not produce a doubled separator",
-  );
-});
-
-test("getConfigHome reads the process environment; getBridgeConfigHome appends the bridge dir", () => {
-  const restore = process.env.GENTLE_PI_CONFIG_HOME;
-  try {
-    process.env.GENTLE_PI_CONFIG_HOME = "/srv/from-env";
-    assert.equal(getConfigHome(), "/srv/from-env");
-    assert.equal(getBridgeConfigHome(), "/srv/from-env/gentle-shell-bridge");
-    delete process.env.GENTLE_PI_CONFIG_HOME;
-    assert.equal(getConfigHome(), `${homedir()}/.pi/gentle-ai`);
-    assert.equal(getBridgeConfigHome(), `${homedir()}/.pi/gentle-ai/gentle-shell-bridge`);
-  } finally {
-    if (restore === undefined) delete process.env.GENTLE_PI_CONFIG_HOME;
-    else process.env.GENTLE_PI_CONFIG_HOME = restore;
-  }
-});