@hayasaka7/haya-pet 0.3.6 → 0.3.8

package/CHANGELOG.md

@@ -7,6 +7,40 @@ All notable changes to HAYA Pet are documented here. This project adheres to
 > 0.2.0 npm publish; they are listed under 0.2.1, which is the first version that
 > ships them.
 
+## [0.3.8]
+
+### Fixed
+- **An interrupt or denial in one Claude Code session no longer leaks into a
+  concurrent, idle one.** The transcript watcher discovered its file by "newest
+  `.jsonl` by mtime in the project dir", so two Claude sessions in the same folder
+  (one project dir, one transcript each) could make an idle session's watcher lock
+  onto a *busy* session's transcript — then read its `[Request interrupted by
+  user]` marker (or a denial) and report the wrong pet as *interrupted*. Each
+  session's watcher now pins to its own transcript via the `transcript_path` Claude
+  includes in every hook payload (recorded as a per-session link by the `haya-pet
+  state` reporter) instead of guessing; until that link exists it idles rather than
+  locking onto another session's file. Codex shares the same discovery shape and is
+  tracked as a known issue.
+- **The pet no longer disappears when the display layout changes.** The overlay
+  window's bounds were set once at creation to span one display's work area and
+  never re-homed, so unplugging a monitor, changing resolution/DPI, docking or
+  undocking, or waking from sleep could strand it off-screen (or on a display that
+  no longer exists) — the pet vanished while the process kept running, and neither
+  **Show/Hide Pet** (which only flips visibility) nor **Reset Position** (which only
+  moved the sprite *inside* the window) brought it back. The companion now re-homes
+  the overlay onto a valid display on `screen` display add/remove/metrics-change and
+  on resume from sleep, and **Reset Position** / **Show Pet** / relaunch re-home the
+  window itself. Automatic re-homes preserve the preferred display, so the pet
+  returns there when the monitor comes back.
+
+## [0.3.7]
+
+### Changed
+- **The tray menu no longer shows state-only controls.** Hidden **Display Mode**
+  and **Attach Bubbles to Terminals** until those settings have real runtime
+  behavior. **Active Sessions** stays visible while session actions continue in a
+  separate workflow.
+
 ## [0.3.6]
 
 ### Fixed
@@ -38,6 +72,12 @@ All notable changes to HAYA Pet are documented here. This project adheres to
   watcher, so a resumed main rollout could be rejected before the guardian trunk
   was matched to it. The guardian watcher now uses the same fresh-mtime + wrapped
   cwd rule for resumed main sessions before following the guardian review trunk.
+- **Codex hook review is one-time again.** Codex stores approved hook hashes in
+  the generated `$CODEX_HOME/haya-pet.config.toml` profile under `[hooks.state]`.
+  The injector used to rewrite the whole managed profile on every launch, deleting
+  that trust state and forcing Codex to ask for hook review every time. The
+  injector now preserves Codex's hook trust tables while regenerating the HAYA
+  hook definitions.
 
 ### Added
 - **`HAYA_PET_DAEMON_DEBUG` diagnostic.** When set to a file path, the companion

package/README.md

@@ -136,7 +136,7 @@ success or failure briefly, then fades.
 | Global pet | Reacts to the highest-priority session and can be dragged anywhere. |
 | Session bubbles | One bubble per running AI session, ordered by connect time. |
 | Folder button | Folds the bubbles away when you want a cleaner desktop. |
-| Tray menu | Show/hide, display mode, installed pets, reset position, and quit. |
+| Tray menu | Show/hide, active sessions, installed pets, reset position, updates, and quit. |
 | Resize grip | Hover the pet, drag the corner, and keep the size you like. |
 
 ## Screenshots
@@ -144,7 +144,7 @@ success or failure briefly, then fades.
 | | |
 |---|---|
 | **The global pet** - reacting to the highest-priority session.<br>![Pet overlay](docs/screenshots/pet-overlay.png) | **Session bubbles** - one per active session, with status icons.<br>![Session bubbles](docs/screenshots/session-bubbles.png) |
-| **Folder collapsed** - bubbles tucked away beside the pet.<br>![Folder collapsed](docs/screenshots/folder-collapsed.png) | **Tray menu** - show/hide, pets, reset position, quit.<br>![Tray menu](docs/screenshots/tray-menu.png) |
+| **Folder collapsed** - bubbles tucked away beside the pet.<br>![Folder collapsed](docs/screenshots/folder-collapsed.png) | **Tray menu** - show/hide, sessions, pets, reset position, quit.<br>![Tray menu](docs/screenshots/tray-menu.png) |
 
 ## Supported Clients
 
@@ -217,7 +217,7 @@ non-observe mode keeps terminal input native.
 | Drag | Move the pet; position is saved. |
 | Drag corner grip | Resize from 0.5x to 2x; size is saved. |
 | Double-click grip | Reset to normal size. |
-| Tray icon | Open menu for display, sessions, pets, reset, and quit. |
+| Tray icon | Open menu for sessions, pets, reset, updates, and quit. |
 
 ## Commands
 

package/apps/cli/src/haya-pet.js

@@ -5,7 +5,8 @@ import { randomUUID } from "node:crypto";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { runGenericCommand as defaultRunGenericCommand } from "../../../packages/cli-core/src/run-command.js";
-import { parseStateArgs, runStateCommand } from "../../../packages/cli-core/src/run-state.js";
+import { parseStateArgs, runStateCommand, readHookTranscriptPathFromStdin } from "../../../packages/cli-core/src/run-state.js";
+import { removeSessionTranscriptLink } from "../../../packages/cli-core/src/session-transcript-link.js";
 import { injectClaudeHooks as defaultInjectClaudeHooks } from "../../../packages/cli-core/src/claude-hook-injection.js";
 import { injectCodexHooks as defaultInjectCodexHooks } from "../../../packages/cli-core/src/codex-hook-injection.js";
 import { watchClaudeTranscript as defaultWatchClaudeTranscript } from "../../../packages/cli-core/src/claude-transcript-watcher.js";
@@ -353,6 +354,12 @@ async function runRunCommand(parsed, dependencies) {
     childEnv = { ...env, HAYA_PET_SESSION_ID: sessionId };
     cleanup = injected.cleanup;
 
+    // The transcript watcher pins to THIS session's transcript via the
+    // session->transcript link the `haya-pet state` reporter writes from the hook
+    // payload. sessionDir is where that link lives; resolve it defensively so a
+    // missing home dir (tests) never breaks the run.
+    const sessionDir = resolveSessionDir(dependencies, env);
+
     // Claude fires NO hook when the user manually denies a permission, so the
     // pet would stay stuck on "waiting for approval". Tail the session transcript
     // (ground truth) and clear to idle the moment a denial is recorded — never on
@@ -361,6 +368,8 @@ async function runRunCommand(parsed, dependencies) {
       cwd,
       homeDir: dependencies.homeDir,
       startedAt: now(),
+      sessionId,
+      sessionDir,
       onDenial: (event) => {
         hookDebugLog(env, now, { source: "transcript", event: "denied", state: "idle", toolUseId: event?.toolUseId });
         messageSender
@@ -392,7 +401,10 @@ async function runRunCommand(parsed, dependencies) {
           .catch(() => {});
       }
     });
-    stopWatcher = watcher.stop;
+    stopWatcher = () => {
+      watcher.stop();
+      removeSessionTranscriptLink({ sessionDir, sessionId });
+    };
   }
 
   // Codex: no `--settings` equivalent, so inject a stable profile and add
@@ -624,6 +636,21 @@ function createConfigStateFile(dependencies) {
   return createStateFile({ statePath: paths.statePath });
 }
 
+// Where per-session transcript links live. Resolved defensively: if no home dir
+// is available (some tests), return undefined and the watcher falls back to its
+// legacy discovery instead of crashing the run.
+function resolveSessionDir(dependencies, env) {
+  try {
+    return getDefaultPaths({
+      platform: dependencies.platform,
+      env,
+      homeDir: dependencies.homeDir
+    }).sessionDir;
+  } catch {
+    return undefined;
+  }
+}
+
 // Best-effort: mirror the reporter's HAYA_PET_HOOK_DEBUG log so transcript-driven
 // events (which don't go through `haya-pet state`) show up in the same trace.
 function hookDebugLog(env, now, entry) {
@@ -917,7 +944,7 @@ async function noopSend() {}
 async function noopClose() {}
 
 if (isDirectRun(import.meta.url, process.argv[1])) {
-  main()
+  bootstrap()
     .catch((error) => {
       console.error(error.message);
       process.exitCode = 1;
@@ -930,6 +957,28 @@ if (isDirectRun(import.meta.url, process.argv[1])) {
     });
 }
 
+// Real-process entry. For a `haya-pet state` invocation — which is ALWAYS a client
+// hook child — read the hook payload from stdin once to learn this session's real
+// transcript path, and hand it to the reporter so it can record the
+// session->transcript link. Done here (not inside main/runStateCommand) so unit
+// tests, and every other command that needs stdin passed through to its child
+// (e.g. `run`), never touch stdin.
+async function bootstrap() {
+  const argv = process.argv.slice(2);
+  const dependencies = {};
+  if (argv[0] === "state") {
+    try {
+      const transcriptPath = await readHookTranscriptPathFromStdin();
+      if (transcriptPath) {
+        dependencies.transcriptPath = transcriptPath;
+      }
+    } catch {
+      // a missing/garbled payload just means no binding this time — never fatal
+    }
+  }
+  return main(argv, dependencies);
+}
+
 function isDirectRun(moduleUrl, scriptPath) {
   if (!scriptPath) {
     return false;

package/apps/companion/src/main/display-manager.js

@@ -22,6 +22,41 @@ export function resolveSavedPosition(savedPosition, displays, size = DEFAULT_SIZ
   };
 }
 
+// Resolve where the overlay window should sit RIGHT NOW: which display's work
+// area it spans, plus where the pet sprite sits inside it (work-area-relative).
+// Shared by initial placement and by re-homing after a display change (monitor
+// unplugged, resolution/DPI change, dock/undock, sleep→resume). Re-homing is what
+// stops the overlay from being stranded off-screen on a display that no longer
+// exists — the bug where the pet "vanishes" but the process is alive and neither
+// Show/Hide nor Reset (which only move the sprite inside the window) recover it.
+export function resolveOverlayPlacement({ savedPosition, displays, petSize = DEFAULT_SIZE } = {}) {
+  const saved = resolveSavedPosition(savedPosition, displays, petSize);
+  // saved.displayId always names a display that currently exists (resolveSavedPosition
+  // falls back to primary/first when the saved one is gone), so this re-homes a
+  // stranded position onto a valid display.
+  const display = findDisplayForSavedPosition({ displayId: saved.displayId }, displays);
+  const workArea = display.workArea ?? display.bounds;
+  const petLocal = clampLocalToWorkArea(
+    { x: saved.x - workArea.x, y: saved.y - workArea.y },
+    workArea,
+    petSize
+  );
+
+  return { workArea, displayId: display.id, petLocal };
+}
+
+// Keep a pet's work-area-relative position inside the work area for a given pet
+// size. Pure mirror of the companion's in-window clamp, so placement resolution
+// can be unit-tested without Electron.
+export function clampLocalToWorkArea(local, workArea, petSize = DEFAULT_SIZE) {
+  const maxX = Math.max(0, (workArea?.width ?? petSize.width) - petSize.width);
+  const maxY = Math.max(0, (workArea?.height ?? petSize.height) - petSize.height);
+  return {
+    x: clamp(local?.x ?? 0, 0, maxX),
+    y: clamp(local?.y ?? 0, 0, maxY)
+  };
+}
+
 export function clampWindowBounds(bounds, display) {
   const workArea = display.workArea ?? display.bounds;
   const width = bounds.width ?? DEFAULT_SIZE.width;

package/apps/companion/src/main/index.js

@@ -1,4 +1,4 @@
-import { app, BrowserWindow, ipcMain, Menu, nativeImage, screen, shell, Tray } from "electron";
+import { app, BrowserWindow, ipcMain, Menu, nativeImage, powerMonitor, screen, shell, Tray } from "electron";
 import { fileURLToPath } from "node:url";
 import { appendFileSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -14,7 +14,7 @@ import { getPlatformCapabilities } from "../../../../packages/platform-core/src/
 import { buildBubbleViews } from "../../../../packages/session-core/src/bubble-view.js";
 import { clampScale } from "../../../../packages/pet-core/src/pet-scale.js";
 import { buildPetWindowOptions, PET_SIZE } from "./window-options.js";
-import { resolveSavedPosition } from "./display-manager.js";
+import { clampLocalToWorkArea, resolveOverlayPlacement } from "./display-manager.js";
 import { getPetScale, setPetScale, setSelectedPet, updateGlobalPetPosition } from "./position-store.js";
 import { buildTrayMenu, buildTrayTooltip } from "./tray-menu.js";
 import { createStateFile } from "./state-file.js";
@@ -151,6 +151,7 @@ async function bootstrap() {
   createPetWindow();
   createTray();
   registerRendererHandlers();
+  registerDisplayWatchers();
   // Best-effort and cached in state.json (shared with the CLI's check, so at
   // most one registry request per day between them); never blocks startup.
   void detectUpdate();
@@ -171,16 +172,9 @@ async function bootstrap() {
 }
 
 function createPetWindow() {
-  const displays = listDisplays();
-  // Resolve the pet's saved on-screen position (pet-sized), which also tells us
-  // which display it belongs on. The window then spans that display's work area.
-  const saved = resolveSavedPosition(positionState.globalPet, displays);
-  const display = displays.find((d) => d.id === saved.displayId)
-    ?? displays.find((d) => d.primary)
-    ?? displays[0];
-  currentWorkArea = display.workArea ?? display.bounds;
-  currentDisplayId = display.id;
-  petLocal = clampPetLocal({ x: saved.x - currentWorkArea.x, y: saved.y - currentWorkArea.y });
+  // Resolve which display the pet belongs on and where it sits inside that
+  // display's work area; the window then spans that work area.
+  applyOverlayPlacement(resolveCurrentPlacement());
 
   const { browserWindow } = buildPetWindowOptions({ capabilities, bounds: currentWorkArea });
 
@@ -214,13 +208,69 @@ function scaledPetSize() {
 }
 
 function clampPetLocal(local) {
+  return clampLocalToWorkArea(local ?? petLocal, currentWorkArea, scaledPetSize());
+}
+
+// Resolve where the overlay should sit right now, given the saved position and the
+// CURRENT set of displays. Used at startup and on every re-home.
+function resolveCurrentPlacement() {
+  return resolveOverlayPlacement({
+    savedPosition: positionState.globalPet,
+    displays: listDisplays(),
+    petSize: scaledPetSize()
+  });
+}
+
+// Adopt a resolved placement into the module's window/pet state (does NOT move the
+// BrowserWindow — callers decide whether to create or setBounds).
+function applyOverlayPlacement(placement) {
+  currentWorkArea = placement.workArea;
+  currentDisplayId = placement.displayId;
+  petLocal = placement.petLocal;
+}
+
+// Re-home the overlay onto a currently-valid display and re-assert its bounds.
+// A display change (monitor unplugged, resolution/DPI change, dock/undock,
+// sleep→resume) can strand the window off-screen on a display that no longer
+// exists: the pet "vanishes" while the process is alive, and neither Show/Hide
+// nor Reset (which only move the sprite INSIDE the window) bring it back. This is
+// the one operation that puts the window itself back on screen.
+function rehomeOverlay({ recenter = false, persist = true } = {}) {
+  if (!petWindow || petWindow.isDestroyed()) {
+    return;
+  }
+
+  applyOverlayPlacement(resolveCurrentPlacement());
+  if (recenter) {
+    petLocal = cornerPetLocal();
+  }
+
+  try {
+    petWindow.setBounds(currentWorkArea);
+  } catch (error) {
+    // Setting bounds must never crash the overlay; the next display event retries.
+    console.error("overlay re-home failed:", error.message);
+  }
+  if (!petWindow.isVisible()) {
+    petWindow.show();
+  }
+  sendPetPosition();
+  // Automatic re-homes (display change / resume) deliberately do NOT persist, so
+  // the user's preferred display is preserved and the pet returns there once that
+  // display comes back. User-initiated re-homes (reset/show) persist as usual.
+  if (persist) {
+    persistPetPosition();
+  }
+}
+
+// Bottom-right corner of the current work area (the Reset target).
+function cornerPetLocal() {
+  const margin = 24;
   const size = scaledPetSize();
-  const maxX = Math.max(0, (currentWorkArea?.width ?? size.width) - size.width);
-  const maxY = Math.max(0, (currentWorkArea?.height ?? size.height) - size.height);
-  return {
-    x: Math.min(Math.max(local.x ?? 0, 0), maxX),
-    y: Math.min(Math.max(local.y ?? 0, 0), maxY)
-  };
+  return clampPetLocal({
+    x: (currentWorkArea?.width ?? size.width) - size.width - margin,
+    y: (currentWorkArea?.height ?? size.height) - size.height - margin
+  });
 }
 
 function createTray() {
@@ -348,6 +398,22 @@ function handleTrayClick(item) {
   }
 }
 
+// The overlay window is positioned once at creation; without these it would never
+// react to the display layout changing under it. Re-home on any display add/remove/
+// metrics change, and on resume from sleep (which commonly fires a metrics change
+// and, on Windows, can blank a transparent surface — re-asserting bounds repaints).
+function registerDisplayWatchers() {
+  const onDisplayChange = () => rehomeOverlay({ persist: false });
+  screen.on("display-metrics-changed", onDisplayChange);
+  screen.on("display-added", onDisplayChange);
+  screen.on("display-removed", onDisplayChange);
+  try {
+    powerMonitor.on("resume", onDisplayChange);
+  } catch {
+    // powerMonitor is unavailable on some platforms/headless; never fatal.
+  }
+}
+
 function registerRendererHandlers() {
   ipcMain.handle("haya-pet:list-sessions", () => buildSessionPayload());
 
@@ -441,24 +507,27 @@ function togglePet() {
   if (!petWindow) {
     return;
   }
-  petWindow.isVisible() ? petWindow.hide() : petWindow.show();
+  if (petWindow.isVisible()) {
+    petWindow.hide();
+  } else {
+    // Re-home on show: a stranded (off-screen) window still reports isVisible()
+    // === true, so the user's first click hides it and this second click must put
+    // it back on a valid display, not just show it at the same bad bounds.
+    rehomeOverlay();
+  }
   refreshTrayMenu();
 }
 
 function focusPet() {
-  petWindow?.show();
+  // Relaunching `haya-pet` (second-instance) is also a "bring it back" gesture, so
+  // re-home rather than show at possibly-stale bounds.
+  rehomeOverlay();
 }
 
 function resetPosition() {
-  // Drop the pet back to the bottom-right corner of its work area.
-  const margin = 24;
-  const size = scaledPetSize();
-  petLocal = clampPetLocal({
-    x: (currentWorkArea?.width ?? size.width) - size.width - margin,
-    y: (currentWorkArea?.height ?? size.height) - size.height - margin
-  });
-  sendPetPosition();
-  persistPetPosition();
+  // Re-home onto a valid display FIRST (a stale display layout is exactly when
+  // users reach for Reset), then drop the pet to the bottom-right corner.
+  rehomeOverlay({ recenter: true });
 }
 
 function setDisplayMode(displayMode) {

package/apps/companion/src/main/tray-menu.js

@@ -2,13 +2,6 @@
 // converts these descriptors into a native Menu; keeping it pure makes the
 // recovery controls testable.
 
-const DISPLAY_MODES = Object.freeze([
-  { value: "global", label: "Global" },
-  { value: "cluster", label: "Cluster" },
-  { value: "per-terminal", label: "Per Terminal" },
-  { value: "hybrid", label: "Hybrid" }
-]);
-
 export function buildTrayTooltip() {
   return "HAYA Pet";
 }
@@ -22,17 +15,6 @@ export function buildTrayMenu(state = {}) {
       id: "toggle_pet",
       label: state.petVisible ? "Hide Pet" : "Show Pet"
     },
-    {
-      id: "display_mode",
-      label: "Display Mode",
-      submenu: DISPLAY_MODES.map((mode) => ({
-        id: `display_mode:${mode.value}`,
-        label: mode.label,
-        value: mode.value,
-        type: "radio",
-        checked: state.displayMode === mode.value
-      }))
-    },
     {
       id: "sessions",
       label: "Active Sessions",
@@ -43,17 +25,9 @@ export function buildTrayMenu(state = {}) {
       label: "Installed Pets",
       submenu: buildPetItems(pets, state.selectedPetId)
     },
-    {
-      id: "attach_bubbles",
-      label: "Attach Bubbles to Terminals",
-      type: "checkbox",
-      checked: Boolean(state.attachBubblesToTerminals)
-    },
     { id: "reset_position", label: "Reset Position" },
-    // Parked until a real settings window exists: every current setting already
-    // has a home (tray toggles, `haya-pet hooks`, drag/grip gestures), so the
-    // item would be a dead button. Re-enable once settings outgrow the tray
-    // (e.g. bubble text size, linger duration) and a handler is wired up.
+    // Parked until a real settings window exists; partially implemented knobs
+    // stay hidden instead of showing dead or state-only controls.
     // { id: "settings", label: "Open Settings" },
     // Only present when the daily npm update check found a newer version;
     // clicking it opens the package page (the app never runs npm itself).

package/apps/companion/test/display-manager.test.mjs

@@ -1,6 +1,11 @@
 import assert from "node:assert/strict";
 import { test } from "../../../test/harness.mjs";
-import { clampWindowBounds, resolveSavedPosition } from "../src/main/display-manager.js";
+import {
+  clampLocalToWorkArea,
+  clampWindowBounds,
+  resolveOverlayPlacement,
+  resolveSavedPosition
+} from "../src/main/display-manager.js";
 
 const displays = [
   {
@@ -46,3 +51,48 @@ test("uses primary display when no saved position exists", () => {
     { x: 416, y: 144, width: 384, height: 416, displayId: "primary", scaleFactor: 1.25 }
   );
 });
+
+test("resolveOverlayPlacement spans the saved display and places the sprite inside it", () => {
+  assert.deepEqual(
+    resolveOverlayPlacement({
+      savedPosition: { x: 900, y: 120, width: 192, height: 208, displayId: "secondary" },
+      displays,
+      petSize: { width: 192, height: 208 }
+    }),
+    {
+      workArea: { x: 820, y: 20, width: 1160, height: 840 },
+      displayId: "secondary",
+      petLocal: { x: 80, y: 100 } // 900-820, 120-20
+    }
+  );
+});
+
+test("resolveOverlayPlacement re-homes a stranded position onto a valid display", () => {
+  // The pet was last on a display that is now gone (monitor unplugged). It must
+  // come back on the primary display, fully inside its work area — this is the
+  // recovery the disappear-and-can't-restore bug needed.
+  assert.deepEqual(
+    resolveOverlayPlacement({
+      savedPosition: { x: 4000, y: 4000, width: 192, height: 208, displayId: "gone" },
+      displays,
+      petSize: { width: 192, height: 208 }
+    }),
+    {
+      workArea: { x: 0, y: 0, width: 800, height: 560 },
+      displayId: "primary",
+      petLocal: { x: 608, y: 352 } // clamped to primary work area (800-192, 560-208)
+    }
+  );
+});
+
+test("clampLocalToWorkArea keeps the sprite within the work area for its size", () => {
+  const workArea = { x: 0, y: 0, width: 800, height: 560 };
+  assert.deepEqual(
+    clampLocalToWorkArea({ x: 5000, y: 5000 }, workArea, { width: 192, height: 208 }),
+    { x: 608, y: 352 }
+  );
+  assert.deepEqual(
+    clampLocalToWorkArea({ x: -50, y: -50 }, workArea, { width: 192, height: 208 }),
+    { x: 0, y: 0 }
+  );
+});

package/apps/companion/test/tray-menu.test.mjs

@@ -13,9 +13,11 @@ const baseState = {
 test("includes the documented recovery controls", () => {
   const menu = buildTrayMenu(baseState);
   const ids = menu.map((item) => item.id);
-  for (const id of ["toggle_pet", "display_mode", "sessions", "pets", "attach_bubbles", "reset_position", "quit"]) {
+  for (const id of ["toggle_pet", "sessions", "pets", "reset_position", "quit"]) {
     assert.ok(ids.includes(id), `missing ${id}`);
   }
+  assert.ok(!ids.includes("display_mode"), "display mode should stay hidden until implemented");
+  assert.ok(!ids.includes("attach_bubbles"), "attach bubbles should stay hidden until implemented");
   // "Open Settings" is parked until a settings window exists (every current
   // setting already has a tray/CLI/gesture home) — it must not be shown dead.
   assert.ok(!ids.includes("settings"), "settings item should stay hidden until implemented");
@@ -26,14 +28,6 @@ test("toggles the pet label based on visibility", () => {
   assert.equal(buildTrayMenu({ ...baseState, petVisible: false }).find((i) => i.id === "toggle_pet").label, "Show Pet");
 });
 
-test("checks the current display mode in the submenu", () => {
-  const submenu = buildTrayMenu(baseState).find((i) => i.id === "display_mode").submenu;
-  const hybrid = submenu.find((i) => i.value === "hybrid");
-  const global = submenu.find((i) => i.value === "global");
-  assert.equal(hybrid.checked, true);
-  assert.equal(global.checked, false);
-});
-
 test("lists active sessions or shows an empty placeholder", () => {
   const withSessions = buildTrayMenu(baseState).find((i) => i.id === "sessions").submenu;
   assert.equal(withSessions[0].label, "Codex · netdisk-server");
@@ -42,11 +36,6 @@ test("lists active sessions or shows an empty placeholder", () => {
   assert.equal(empty[0].enabled, false);
 });
 
-test("reflects the attach-bubbles checkbox state", () => {
-  assert.equal(buildTrayMenu(baseState).find((i) => i.id === "attach_bubbles").checked, true);
-  assert.equal(buildTrayMenu({ ...baseState, attachBubblesToTerminals: false }).find((i) => i.id === "attach_bubbles").checked, false);
-});
-
 test("shows the update item only when a newer version is known", () => {
   const withoutUpdate = buildTrayMenu(baseState);
   assert.ok(!withoutUpdate.some((i) => i.id === "update"), "no update item by default");