@hayasaka7/haya-pet 0.2.5 → 0.2.7

package/CHANGELOG.md

@@ -7,6 +7,57 @@ 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.2.7]
+
+### Fixed
+- **Codex `/quit` no longer hangs after its goodbye.** The `haya-pet state`
+  hook reporter could hang forever on a never-settling IPC await (pipe connect,
+  write drain, or close) — and Codex awaits each hook child with a default
+  **600 s** timeout, so a hung turn-end `state idle` reporter both froze the
+  pet on "working" and made `/quit` sit on its token-usage goodbye for up to
+  10 minutes (Ctrl+C worked because it kills Codex without the wait, orphaning
+  the reporter — observed live). The reporter now races its whole IPC
+  interaction against a 2 s deadline and always exits; the wrapper's own
+  companion connection gets the same guard (5 s) so a wedged companion can
+  never hold the terminal after the wrapped CLI exits.
+
+### Added
+- **Update notice.** HAYA Pet now checks npm (at most once a day, cached in
+  `state.json`, shared between the CLI and the overlay) for a newer published
+  version. The CLI prints a one-line notice after a wrapped command exits (and
+  after `haya-pet start`), and the tray gains an **Update Available (x.y.z)**
+  item that opens the package page — the app never runs npm itself. The check
+  is best-effort (3 s timeout, silent on any failure, never blocks a run),
+  skipped when stdout isn't a terminal, and can be disabled with
+  `HAYA_PET_NO_UPDATE_CHECK=1`.
+
+### Changed
+- **The bubble panel shows at most three sessions at once.** Beyond the existing
+  height budget (the room between the folder button and the screen edge), the
+  list now also caps its viewport at the bottom of the third bubble — more
+  sessions are reached by scrolling, so a busy machine no longer grows a
+  screen-tall stack. The list surface itself (gaps between bubbles and the
+  scrollbar) is now pointer-active so wheel scrolling and scrollbar dragging
+  work anywhere on the open panel, and the scrollbar is a slim dark-theme thumb
+  instead of the stock bar.
+
+## [0.2.6]
+
+### Fixed
+- **Codex "Approve for me" no longer shows a false *waiting for approval*.**
+  With `approvals_reviewer = auto_review` (the TUI's "Approve for me"; legacy
+  config alias `guardian_subagent`), Codex routes approval requests to a
+  guardian subagent and never prompts the user — but its `PermissionRequest`
+  hook still fires when the request is created, so the pet sat on *waiting for
+  approval* for the entire auto-review (and the approved command's run). A new
+  guardian-review watcher tails the guardian's own session rollout (the only
+  persisted trace of the review) and reports event-backed states instead:
+  *reviewing* while the guardian assesses, *running tools* on an `allow`
+  verdict, *thinking* on a `deny` (the rejection goes back to the model — no
+  human decision is pending). When the reviewer is the user (`approvals_reviewer
+  = "user"`, "Ask for approval"), nothing changes: *waiting for approval* still
+  shows until the user decides.
+
 ## [0.2.4]
 
 ### Fixed

package/README.md

@@ -187,10 +187,14 @@ Why opt in? Both clients show a one-time trust prompt when hooks are added. HAYA
 Pet lets you decide when to approve that instead of surprising you in the middle
 of work.
 
-Codex support is useful but still partial. Hooks report `thinking` and `idle`,
-while a transcript watcher reports tool/file activity. Waiting-for-approval
-support depends on an upstream Codex hook gap:
-[openai/codex#16732](https://github.com/openai/codex/issues/16732).
+Codex live status combines three sources: hooks report `thinking`/`idle` and
+approval requests, a transcript watcher reports tool/file activity, and a
+guardian-review watcher tracks Codex's **"Approve for me"** auto-reviewer — the
+pet shows *reviewing* while the guardian assesses a request and only shows
+*waiting for approval* when Codex actually asks you ("Ask for approval" mode).
+Per-tool `PreToolUse` hooks still depend on an upstream Codex gap
+([openai/codex#16732](https://github.com/openai/codex/issues/16732)); the
+transcript watcher covers that in the meantime.
 
 For any client, you can ask HAYA Pet to infer rough activity from terminal
 output:
@@ -244,6 +248,21 @@ exit code. Disable auto-start with `HAYA_PET_NO_AUTOSTART=1`.
 | Electron | Installed as a runtime dependency. |
 | node-pty | Optional; used only for `--observe`. |
 
+## Updates
+
+HAYA Pet checks npm for a newer published version at most once a day (cached in
+`state.json`). When one exists, the CLI prints a one-line notice after your
+wrapped command exits, and the tray shows **Update Available (x.y.z)** — clicking
+it opens the package page. Updating is always your action:
+
+```bash
+npm install -g @hayasaka7/haya-pet
+```
+
+The check is best-effort (3s timeout, silent on failure, never blocks a run),
+skipped when output is piped, and fully disabled with
+`HAYA_PET_NO_UPDATE_CHECK=1`.
+
 ## Troubleshooting
 
 | Symptom | Fix |
@@ -261,7 +280,10 @@ repairing a broken Electron install.
 
 HAYA Pet is local-only by default. It does not upload prompts, files,
 screenshots, or session logs. The overlay stores only local state needed for
-pet selection, position, size, and short derived status summaries.
+pet selection, position, size, and short derived status summaries. The single
+outbound request it ever makes is the daily npm version check (a standard
+HTTPS request to `registry.npmjs.org` that sends no session data); disable it
+with `HAYA_PET_NO_UPDATE_CHECK=1`.
 
 ## Documentation
 

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

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
-import { realpathSync, appendFileSync } from "node:fs";
+import { realpathSync, appendFileSync, readFileSync } from "node:fs";
 import { spawn } from "node:child_process";
 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";
@@ -9,12 +10,18 @@ import { injectClaudeHooks as defaultInjectClaudeHooks } from "../../../packages
 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";
 import { watchCodexTranscript as defaultWatchCodexTranscript } from "../../../packages/cli-core/src/codex-transcript-watcher.js";
+import { watchCodexGuardianReviews as defaultWatchCodexGuardianReviews } from "../../../packages/cli-core/src/codex-guardian-watcher.js";
 import { ensureCompanionConnection } from "../../../packages/cli-core/src/companion-launcher.js";
 import { createIpcClient as defaultCreateIpcClient } from "../../../packages/daemon-core/src/ipc-server.js";
 import { getDefaultPaths } from "../../../packages/platform-core/src/paths.js";
 import { discoverPets as defaultDiscoverPets } from "../../../packages/pet-core/src/discovery.js";
 import { createStateFile as defaultCreateStateFile } from "../../../packages/app-state/src/state-file.js";
 import { getSelectedPetId, setSelectedPet, getHooksEnabled, setHooksEnabled } from "../../../packages/app-state/src/state.js";
+import { checkForUpdate, UPDATE_COMMAND } from "../../../packages/app-state/src/update-check.js";
+import { raceDeadline } from "../../../packages/cli-core/src/deadline.js";
+
+// Ceiling for wrapper→companion IPC awaits (see createMessageSender).
+const SENDER_DEADLINE_MS = 5000;
 import { getAdapterInfo } from "../../../packages/adapters/src/adapter-info.js";
 
 const CLIENT_DISPLAY_NAMES = Object.freeze({
@@ -104,6 +111,13 @@ export async function runStopCommand(_parsed, dependencies = {}) {
 // Explicitly start the companion overlay (so users never need `npm start`).
 export async function runStartCommand(_parsed, dependencies = {}) {
   const print = dependencies.print ?? defaultPrint;
+  const updateCheck = startUpdateCheck(dependencies);
+  const result = await startCompanionAndReport(dependencies, print);
+  await reportUpdateNotice(updateCheck, print);
+  return result;
+}
+
+async function startCompanionAndReport(dependencies, print) {
   const { client, started, error, timedOut } = await connectCompanion(dependencies, true);
 
   if (client) {
@@ -122,17 +136,67 @@ export async function runStartCommand(_parsed, dependencies = {}) {
   return { command: "start", ok: false, started: false };
 }
 
+// Kick off the (cached, best-effort) npm update check without blocking the
+// actual work; callers await the promise only when they are about to print.
+// Nothing here may ever break the run — even resolving the state path can
+// throw (no HOME/USERPROFILE), which simply means "no check".
+function startUpdateCheck(dependencies) {
+  try {
+    const check = dependencies.checkForUpdate ?? defaultCheckForUpdate;
+    return check({
+      currentVersion: dependencies.currentVersion ?? readOwnVersion(),
+      stateFile: createConfigStateFile(dependencies),
+      env: dependencies.env ?? process.env,
+      now: dependencies.now ?? Date.now
+    });
+  } catch {
+    return Promise.resolve(undefined);
+  }
+}
+
+// Default update check runs only on an interactive terminal: piped/CI output
+// should not be nagged (and nothing non-interactive should touch the network).
+function defaultCheckForUpdate(options) {
+  if (!process.stdout.isTTY) {
+    return Promise.resolve(undefined);
+  }
+  return checkForUpdate(options);
+}
+
+async function reportUpdateNotice(updateCheck, print) {
+  const update = await updateCheck;
+  if (update) {
+    print(
+      `haya-pet: update available — ${update.currentVersion} → ${update.latestVersion}. Run: ${UPDATE_COMMAND}`
+    );
+  }
+}
+
+function readOwnVersion() {
+  try {
+    const packagePath = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "package.json");
+    return JSON.parse(readFileSync(packagePath, "utf8")).version;
+  } catch {
+    return undefined;
+  }
+}
+
 async function runRunCommand(parsed, dependencies) {
   const runGenericCommand = dependencies.runGenericCommand ?? defaultRunGenericCommand;
   const injectClaudeHooks = dependencies.injectClaudeHooks ?? defaultInjectClaudeHooks;
   const injectCodexHooks = dependencies.injectCodexHooks ?? defaultInjectCodexHooks;
   const watchClaudeTranscript = dependencies.watchClaudeTranscript ?? defaultWatchClaudeTranscript;
   const watchCodexTranscript = dependencies.watchCodexTranscript ?? defaultWatchCodexTranscript;
+  const watchCodexGuardianReviews =
+    dependencies.watchCodexGuardianReviews ?? defaultWatchCodexGuardianReviews;
   const print = dependencies.print ?? defaultPrint;
   const env = dependencies.env ?? process.env;
   const now = dependencies.now ?? Date.now;
   const cwd = dependencies.cwd ?? process.cwd();
   const messageSender = await createMessageSender(dependencies);
+  // Concurrent with the wrapped command; the result is printed after it exits
+  // (interactive TUIs clear the screen, so a pre-launch notice would be lost).
+  const updateCheck = startUpdateCheck(dependencies);
 
   const sessionId = dependencies.sessionId ?? `sess_${randomUUID()}`;
   let childArgs = parsed.childArgs;
@@ -251,11 +315,55 @@ async function runRunCommand(parsed, dependencies) {
         watcher.stop();
         previousStopWatcher();
       };
+
+      // With "Approve for me" (approvals_reviewer=auto_review, legacy alias
+      // guardian_subagent), Codex routes approval requests to a guardian
+      // subagent and never shows the human approval UI — yet the
+      // PermissionRequest hook still fires at request creation, which used to
+      // pin the pet on a false "waiting for approval" for the whole review.
+      // The guardian's own rollout is the only observable record of the
+      // review, so tail it: a review turn starting proves the agent is
+      // reviewing; an "allow" verdict proves the action proceeds; a "deny"
+      // verdict goes back to the model, which keeps working. An unreadable
+      // verdict reports nothing — a pending cue is never cleared on a guess.
+      const guardianWatcher = watchCodexGuardianReviews({
+        homeDir: dependencies.homeDir,
+        sessionsRoot: dependencies.codexSessionsRoot,
+        startedAt: now(),
+        onReviewEvent: (event) => {
+          hookDebugLog(env, now, {
+            source: "codex_guardian",
+            event: event.type,
+            outcome: event.outcome
+          });
+
+          const report = resolveGuardianStateReport(event);
+          if (!report) {
+            return;
+          }
+          messageSender
+            .send({
+              type: "state",
+              sessionId,
+              state: report.state,
+              summary: report.summary,
+              confidence: 0.85,
+              source: "client_log",
+              updatedAt: now()
+            })
+            .catch(() => {});
+        }
+      });
+      const stopWithoutGuardian = stopWatcher;
+      stopWatcher = () => {
+        guardianWatcher.stop();
+        stopWithoutGuardian();
+      };
     }
   }
 
   try {
-    return await runGenericCommand({
+    const result = await runGenericCommand({
       command: parsed.childCommand,
       args: childArgs,
       cwd,
@@ -269,6 +377,8 @@ async function runRunCommand(parsed, dependencies) {
       stdio: dependencies.stdio,
       send: messageSender.send
     });
+    await reportUpdateNotice(updateCheck, print);
+    return result;
   } finally {
     stopWatcher();
     cleanup();
@@ -276,6 +386,23 @@ async function runRunCommand(parsed, dependencies) {
   }
 }
 
+// Map a guardian review event to the pet state it proves. waiting_approval is
+// deliberately NOT among these: with the guardian reviewing, the user is not
+// being asked anything, and after a deny the request is resolved (the model
+// receives the rejection and continues) — there is no pending human decision.
+function resolveGuardianStateReport(event) {
+  if (event.type === "review_started") {
+    return { state: "reviewing", summary: "agent reviewing approval" };
+  }
+  if (event.type === "review_finished" && event.outcome === "allow") {
+    return { state: "running_tool", summary: "reviewer approved" };
+  }
+  if (event.type === "review_finished" && event.outcome === "deny") {
+    return { state: "thinking", summary: "reviewer denied" };
+  }
+  return undefined;
+}
+
 // Resolve whether live-status hooks should be injected for this run (any
 // hook-capable client). Precedence: HAYA_PET_NO_HOOKS forces off, HAYA_PET_HOOKS
 // forces on (per-run overrides), otherwise the persisted `haya-pet hooks on/off`
@@ -545,9 +672,14 @@ async function createMessageSender(dependencies) {
     process.stderr.write("haya-pet: started the companion overlay.\n");
   }
 
+  // Deadline every IPC await: if the companion wedges, a hanging send/close
+  // would keep THIS process alive after the wrapped CLI exits — leaving the
+  // user's terminal without a prompt. Losing a status message to the deadline
+  // is fine (the registry stales-out dead sessions); losing the terminal isn't.
+  const deadlineMs = dependencies.senderDeadlineMs ?? SENDER_DEADLINE_MS;
   return {
-    send: (message) => client.send(message),
-    close: () => client.close()
+    send: (message) => raceDeadline(client.send(message), deadlineMs),
+    close: () => raceDeadline(client.close(), deadlineMs)
   };
 }
 

package/apps/cli/test/haya-pet.test.mjs

@@ -275,6 +275,74 @@ test("HAYA_PET_NO_AUTOSTART disables auto-starting the companion", async () => {
   assert.equal(launched, 0);
 });
 
+test("run prints an update notice only after the wrapped command exits", async () => {
+  const order = [];
+
+  await runAiPet(["run", "--client", "generic", "--", "node", "-v"], {
+    env: { USERPROFILE: "C:\\Users\\A" },
+    heartbeatIntervalMs: 10,
+    send: async () => {},
+    print: (line) => order.push(line),
+    checkForUpdate: async () => ({ currentVersion: "0.2.7", latestVersion: "9.9.9" }),
+    runGenericCommand: async (options) => {
+      order.push("child-finished");
+      return { sessionId: options.sessionId, pid: 1, exitCode: 0 };
+    }
+  });
+
+  const noticeIndex = order.findIndex((entry) => entry.includes("update available"));
+  assert.ok(noticeIndex !== -1, "notice printed");
+  assert.ok(order[noticeIndex].includes("0.2.7 → 9.9.9"), "notice names both versions");
+  assert.ok(order[noticeIndex].includes("npm install -g @hayasaka7/haya-pet"), "notice gives the command");
+  assert.ok(noticeIndex > order.indexOf("child-finished"), "notice comes after the child exits");
+});
+
+test("run prints no update notice when the check finds nothing", async () => {
+  const lines = [];
+
+  await runAiPet(["run", "--client", "generic", "--", "node", "-v"], {
+    env: { USERPROFILE: "C:\\Users\\A" },
+    heartbeatIntervalMs: 10,
+    send: async () => {},
+    print: (line) => lines.push(line),
+    checkForUpdate: async () => undefined,
+    runGenericCommand: async (options) => ({ sessionId: options.sessionId, pid: 1, exitCode: 0 })
+  });
+
+  assert.ok(!lines.some((line) => line.includes("update available")));
+});
+
+test("start prints an update notice after its status line", async () => {
+  const lines = [];
+
+  await runAiPet(["start"], {
+    env: { USERPROFILE: "C:\\Users\\A" },
+    createIpcClient: async () => ({ send: async () => {}, close: async () => {} }),
+    launchCompanion: async () => {},
+    print: (line) => lines.push(line),
+    checkForUpdate: async () => ({ currentVersion: "0.2.7", latestVersion: "9.9.9" })
+  });
+
+  const noticeIndex = lines.findIndex((line) => line.includes("update available"));
+  assert.ok(noticeIndex !== -1, "notice printed");
+  assert.ok(noticeIndex > lines.findIndex((line) => line.includes("already running")));
+});
+
+test("run returns even when the companion connection hangs on close", async () => {
+  const result = await runAiPet(["run", "--client", "generic", "--", "node", "-v"], {
+    env: { USERPROFILE: "C:\\Users\\A" },
+    heartbeatIntervalMs: 10,
+    senderDeadlineMs: 20,
+    createIpcClient: async () => ({
+      send: async () => {},
+      close: () => new Promise(() => {})
+    }),
+    runGenericCommand: async (options) => ({ sessionId: options.sessionId, pid: 1, exitCode: 0 })
+  });
+
+  assert.equal(result.exitCode, 0);
+});
+
 test("parses the start command and reports when already running", async () => {
   assert.deepEqual(parseAiPetArgs(["start"]), { command: "start" });
 
@@ -483,6 +551,47 @@ test("codex hooks also start a transcript watcher for tool activity", async () =
   assert.ok(sent.every((message) => message.updatedAt === undefined || message.updatedAt === 42));
 });
 
+test("codex hooks also start a guardian-review watcher that reports review states", async () => {
+  const sent = [];
+  let fireReviewEvent;
+  let stopped = false;
+
+  await runAiPet(["run", "--client", "codex", "--", "codex"], {
+    cwd: process.cwd(),
+    env: { USERPROFILE: "C:\\Users\\A" },
+    now: () => 42,
+    heartbeatIntervalMs: 10,
+    send: async (message) => sent.push(message),
+    createStateFile: hooksStateFile(true),
+    injectCodexHooks: () => ({ profileName: "haya-pet", cleanup: () => {} }),
+    watchCodexTranscript: () => ({ stop: () => {} }),
+    watchCodexGuardianReviews: ({ onReviewEvent }) => {
+      fireReviewEvent = onReviewEvent;
+      return { stop: () => { stopped = true; } };
+    },
+    runGenericCommand: async (options) => {
+      fireReviewEvent({ type: "review_started" });
+      fireReviewEvent({ type: "review_finished", outcome: "allow" });
+      fireReviewEvent({ type: "review_started" });
+      fireReviewEvent({ type: "review_finished", outcome: "deny" });
+      // An unreadable verdict must not change the state (leave the cue as-is).
+      fireReviewEvent({ type: "review_finished", outcome: undefined });
+      return { sessionId: options.sessionId, pid: 1, exitCode: 0 };
+    }
+  });
+
+  assert.ok(stopped, "guardian watcher is stopped after the wrapped command exits");
+  const reviewStates = sent
+    .filter((message) => message.type === "state" && message.source === "client_log")
+    .map((message) => [message.state, message.summary]);
+  assert.deepEqual(reviewStates, [
+    ["reviewing", "agent reviewing approval"],
+    ["running_tool", "reviewer approved"],
+    ["reviewing", "agent reviewing approval"],
+    ["thinking", "reviewer denied"]
+  ]);
+});
+
 test("codex hooks are skipped (with a notice) when the user passes their own -p", async () => {
   const calls = [];
   let injected = 0;

package/apps/companion/src/main/bubble-list-viewport.js

@@ -0,0 +1,26 @@
+// Caps the bubble list's visible height. Two budgets apply, and the tighter one
+// wins: the HEIGHT budget (the pixel room between the folder button and the
+// screen edge on the side the list opens toward) and a COUNT budget — at most
+// MAX_VISIBLE_BUBBLES bubbles are visible at once, so a long session list stays
+// a compact panel and the rest is reached by scrolling (.bubble-list has
+// overflow-y: auto). The floor keeps the list usable even when the button sits
+// against a screen edge.
+const DEFAULT_MAX_VISIBLE_BUBBLES = 3;
+const DEFAULT_MIN_HEIGHT = 96;
+
+// `bubbleBottoms` are the layout bottoms (offsetTop + offsetHeight) of each
+// bubble in list order; the count cap is the bottom of the last bubble allowed
+// to be visible, so exactly that many show before scrolling.
+export function resolveBubbleListMaxHeight({
+  room,
+  bubbleBottoms = [],
+  maxVisible = DEFAULT_MAX_VISIBLE_BUBBLES,
+  minHeight = DEFAULT_MIN_HEIGHT
+} = {}) {
+  const heightBudget = Number.isFinite(room) ? Math.round(room) : 0;
+
+  const capBottom = bubbleBottoms.length > maxVisible ? bubbleBottoms[maxVisible - 1] : undefined;
+  const countBudget = Number.isFinite(capBottom) ? Math.round(capBottom) : Infinity;
+
+  return Math.max(minHeight, Math.min(heightBudget, countBudget));
+}

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

@@ -1,5 +1,6 @@
-import { app, BrowserWindow, ipcMain, Menu, nativeImage, screen, Tray } from "electron";
+import { app, BrowserWindow, ipcMain, Menu, nativeImage, screen, shell, Tray } from "electron";
 import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { createDaemonRuntime } from "../../../../packages/daemon-core/src/daemon-runtime.js";
 import { createIpcServer } from "../../../../packages/daemon-core/src/ipc-server.js";
@@ -18,6 +19,7 @@ import { getPetScale, setPetScale, setSelectedPet, updateGlobalPetPosition } fro
 import { buildTrayMenu, buildTrayTooltip } from "./tray-menu.js";
 import { createStateFile } from "./state-file.js";
 import { discoverPets } from "./pet-loader.js";
+import { checkForUpdate, UPDATE_PAGE_URL } from "../../../../packages/app-state/src/update-check.js";
 
 const STALE_SWEEP_INTERVAL_MS = 10_000;
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -47,6 +49,9 @@ let petLocal = { x: 0, y: 0 };
 // User-chosen pet scale (resize grip); the pet occupies PET_SIZE × petScale.
 let petScale = 1;
 let approvalWatch;
+// Set once the daily npm update check finds a newer version; surfaces as a
+// tray item (see tray-menu.js).
+let updateAvailable;
 
 // Electron singleton: a second launch forwards to the running instance.
 if (!app.requestSingleInstanceLock()) {
@@ -116,6 +121,9 @@ async function bootstrap() {
   createPetWindow();
   createTray();
   registerRendererHandlers();
+  // 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();
 
   const sweep = setInterval(() => {
     runtime.markStaleSessions(Date.now());
@@ -219,7 +227,8 @@ function refreshTrayMenu() {
     attachBubblesToTerminals: positionState.settings.attachBubblesToTerminals,
     selectedPetId: positionState.globalPet.selectedPetId,
     sessions,
-    pets: pets.map((pet) => ({ id: pet.manifest.id, name: pet.manifest.name }))
+    pets: pets.map((pet) => ({ id: pet.manifest.id, name: pet.manifest.name })),
+    updateAvailable
   }).map(toElectronMenuItem);
 
   tray.setContextMenu(Menu.buildFromTemplate(template));
@@ -246,6 +255,42 @@ function toElectronMenuItem(item) {
   return electronItem;
 }
 
+// Daily npm update check (shared cache with the CLI in state.json). On a hit,
+// the tray gains an "Update Available (x.y.z)" item; checkForUpdate itself
+// never throws, so this can run unawaited from bootstrap.
+async function detectUpdate() {
+  const update = await checkForUpdate({
+    currentVersion: readPackageVersion(),
+    // Every companion write flows through the in-memory positionState (load →
+    // mutate → save). Mirror that here: read the live copy, and on save merge
+    // only the cache key into whatever positionState is by then — a direct
+    // stateFile.save of the load-time snapshot could clobber a pet move made
+    // while the registry fetch was in flight.
+    stateFile: {
+      load: async () => positionState,
+      save: async (next) => {
+        positionState = { ...positionState, updateCheck: next.updateCheck };
+        return stateFile.save(positionState);
+      }
+    }
+  });
+  if (update) {
+    updateAvailable = update;
+    refreshTrayMenu();
+  }
+}
+
+// The published version lives in the ROOT package.json (the companion workspace
+// has its own, unpublished version number).
+function readPackageVersion() {
+  try {
+    const packagePath = join(__dirname, "..", "..", "..", "..", "package.json");
+    return JSON.parse(readFileSync(packagePath, "utf8")).version;
+  } catch {
+    return undefined;
+  }
+}
+
 function handleTrayClick(item) {
   switch (item.id) {
     case "toggle_pet":
@@ -257,6 +302,11 @@ function handleTrayClick(item) {
     case "quit":
       app.quit();
       break;
+    case "update":
+      // Open the package page rather than running npm ourselves — installing
+      // is the user's call (and may need their node manager / sudo setup).
+      shell.openExternal(UPDATE_PAGE_URL);
+      break;
     default:
       if (item.id?.startsWith("display_mode:")) {
         setDisplayMode(item.value);

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

@@ -55,6 +55,11 @@ export function buildTrayMenu(state = {}) {
     // 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.
     // { 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).
+    ...(state.updateAvailable?.latestVersion
+      ? [{ id: "update", label: `Update Available (${state.updateAvailable.latestVersion})` }]
+      : []),
     { id: "separator", type: "separator" },
     { id: "quit", label: "Quit" }
   ];

package/apps/companion/src/renderer/pet-window.js

@@ -16,6 +16,7 @@ import {
 import { resolveCompanionPetState } from "../../../../packages/session-core/src/pet-state.js";
 import { resolveVisibleBubbles } from "../../../../packages/session-core/src/bubble-linger.js";
 import { resolvePanelPlacement } from "../main/panel-placement.js";
+import { resolveBubbleListMaxHeight } from "../main/bubble-list-viewport.js";
 import { createInteractionController } from "./interaction-controller.js";
 import { createBubbleList } from "./session-bubbles.js";
 
@@ -137,9 +138,11 @@ function placePanel() {
     const alignRight = placement.x + rect.width / 2 > workArea.width / 2;
     list.dataset.openDirection = openUp ? "up" : "down";
     list.dataset.openAlign = alignRight ? "right" : "left";
-    // Cap the height to the room actually available on the chosen side.
+    // Cap the height to the room actually available on the chosen side AND to
+    // three visible bubbles — more sessions are reached by scrolling the list.
     const room = openUp ? placement.y - margin : workArea.height - (placement.y + rect.height) - margin;
-    list.style.maxHeight = `${Math.max(96, Math.round(room))}px`;
+    const bubbleBottoms = Array.from(list.children, (child) => child.offsetTop + child.offsetHeight);
+    list.style.maxHeight = `${resolveBubbleListMaxHeight({ room, bubbleBottoms })}px`;
   }
 }
 

package/apps/companion/src/renderer/session-bubbles.js

@@ -32,7 +32,11 @@ export function createBubbleList(container, { collapsed = false, onRender } = {}
 
       if (!isCollapsed) {
         const list = document.createElement("div");
-        list.className = "bubble-list";
+        // The list itself must be pointer-active (not just the bubbles): with
+        // more than three sessions it scrolls, and the scrollbar + the gaps
+        // between bubbles belong to the list element — if it stayed
+        // click-through, wheel/drag there would fall through to the desktop.
+        list.className = "bubble-list interactive";
         for (const bubble of lastBubbles) {
           list.appendChild(renderBubble(bubble));
         }

package/apps/companion/src/renderer/styles.css

@@ -149,6 +149,25 @@ body {
   pointer-events: auto;
 }
 
+/* Scrolling is by design (at most three bubbles are visible at once), so give
+   the list a slim thumb that fits the dark pills instead of the stock bar. */
+.bubble-list::-webkit-scrollbar {
+  width: 6px;
+}
+
+.bubble-list::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.bubble-list::-webkit-scrollbar-thumb {
+  background: rgba(255, 255, 255, 0.25);
+  border-radius: 3px;
+}
+
+.bubble-list::-webkit-scrollbar-thumb:hover {
+  background: rgba(255, 255, 255, 0.4);
+}
+
 .bubble-list[data-open-direction="down"] { top: calc(100% + 6px); }
 .bubble-list[data-open-direction="up"] { bottom: calc(100% + 6px); }
 .bubble-list[data-open-align="left"] { left: 0; right: auto; }