npm - @hayasaka7/haya-pet - Versions diffs - 0.1.0 - Mend

@hayasaka7/haya-pet 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (131) hide show

package/.gitattributes +34 -0
package/.github/workflows/release.yml +61 -0
package/LICENSE +21 -0
package/README.md +247 -0
package/apps/cli/src/haya-pet.js +395 -0
package/apps/cli/test/haya-pet.test.mjs +339 -0
package/apps/companion/README.md +83 -0
package/apps/companion/package.json +17 -0
package/apps/companion/src/main/display-manager.js +71 -0
package/apps/companion/src/main/index.js +349 -0
package/apps/companion/src/main/lock-file.js +52 -0
package/apps/companion/src/main/panel-placement.js +45 -0
package/apps/companion/src/main/pet-loader.js +2 -0
package/apps/companion/src/main/position-store.js +3 -0
package/apps/companion/src/main/preload.cjs +13 -0
package/apps/companion/src/main/state-file.js +2 -0
package/apps/companion/src/main/terminal-helper-client.js +79 -0
package/apps/companion/src/main/terminal-locator.js +44 -0
package/apps/companion/src/main/tray-menu.js +79 -0
package/apps/companion/src/main/window-options.js +66 -0
package/apps/companion/src/renderer/index.html +18 -0
package/apps/companion/src/renderer/interaction-controller.js +114 -0
package/apps/companion/src/renderer/pet-window.js +275 -0
package/apps/companion/src/renderer/session-bubbles.js +138 -0
package/apps/companion/src/renderer/styles.css +225 -0
package/apps/companion/src/renderer/task-talk-window.js +141 -0
package/apps/companion/test/display-manager.test.mjs +48 -0
package/apps/companion/test/interaction-controller.test.mjs +107 -0
package/apps/companion/test/panel-placement.test.mjs +60 -0
package/apps/companion/test/position-store.test.mjs +54 -0
package/apps/companion/test/state-file.test.mjs +52 -0
package/apps/companion/test/terminal-helper-client.test.mjs +68 -0
package/apps/companion/test/terminal-locator.test.mjs +35 -0
package/apps/companion/test/tray-menu.test.mjs +45 -0
package/apps/companion/test/window-options.test.mjs +62 -0
package/apps/pet-preview/index.html +42 -0
package/apps/pet-preview/src/preview-app.js +123 -0
package/apps/pet-preview/src/preview-state.js +70 -0
package/apps/pet-preview/src/preview.css +125 -0
package/apps/pet-preview/test/preview-state.test.mjs +62 -0
package/assets/fallback-pet/README.md +16 -0
package/assets/fallback-pet/pet.json +13 -0
package/docs/architecture.md +144 -0
package/docs/known-issues.md +49 -0
package/docs/publishing.md +48 -0
package/docs/screenshots/README.md +7 -0
package/docs/screenshots/folder-collapsed.png +0 -0
package/docs/screenshots/hero.png +0 -0
package/docs/screenshots/pet-overlay.png +0 -0
package/docs/screenshots/session-bubbles.png +0 -0
package/docs/screenshots/tray-menu.png +0 -0
package/docs/troubleshooting.md +36 -0
package/native/README.md +80 -0
package/native/linux-window-helper/README.md +29 -0
package/native/mac-window-helper/README.md +30 -0
package/native/win-window-helper/Program.cs +312 -0
package/native/win-window-helper/README.md +53 -0
package/native/win-window-helper/win-window-helper.csproj +12 -0
package/package.json +35 -0
package/packages/adapters/src/adapter-info.js +61 -0
package/packages/adapters/src/capabilities.js +39 -0
package/packages/adapters/src/heuristics.js +114 -0
package/packages/adapters/src/output-observer.js +164 -0
package/packages/adapters/src/routing.js +86 -0
package/packages/adapters/test/adapter-info.test.mjs +35 -0
package/packages/adapters/test/capabilities.test.mjs +44 -0
package/packages/adapters/test/heuristics.test.mjs +42 -0
package/packages/adapters/test/output-observer.test.mjs +142 -0
package/packages/adapters/test/routing.test.mjs +93 -0
package/packages/app-state/src/state-file.js +53 -0
package/packages/app-state/src/state.js +80 -0
package/packages/app-state/test/state.test.mjs +36 -0
package/packages/cli-core/src/companion-launcher.js +69 -0
package/packages/cli-core/src/pty-runner.js +96 -0
package/packages/cli-core/src/run-command.js +353 -0
package/packages/cli-core/src/strip-ansi.js +16 -0
package/packages/cli-core/test/companion-launcher.test.mjs +98 -0
package/packages/cli-core/test/run-command.test.mjs +177 -0
package/packages/cli-core/test/strip-ansi.test.mjs +27 -0
package/packages/daemon-core/src/daemon-runtime.js +49 -0
package/packages/daemon-core/src/ipc-server.js +180 -0
package/packages/daemon-core/src/ipc-transport.js +70 -0
package/packages/daemon-core/src/singleton.js +46 -0
package/packages/daemon-core/test/daemon-runtime.test.mjs +65 -0
package/packages/daemon-core/test/ipc-server.test.mjs +70 -0
package/packages/daemon-core/test/ipc-transport.test.mjs +72 -0
package/packages/daemon-core/test/singleton.test.mjs +32 -0
package/packages/pet-core/src/animation-state.js +84 -0
package/packages/pet-core/src/animator.js +26 -0
package/packages/pet-core/src/atlas.js +81 -0
package/packages/pet-core/src/discovery.js +90 -0
package/packages/pet-core/src/manifest.js +112 -0
package/packages/pet-core/src/validation.js +43 -0
package/packages/pet-core/test/animation-state.test.mjs +47 -0
package/packages/pet-core/test/animator.test.mjs +31 -0
package/packages/pet-core/test/atlas.test.mjs +81 -0
package/packages/pet-core/test/discovery.test.mjs +93 -0
package/packages/pet-core/test/manifest.test.mjs +93 -0
package/packages/pet-core/test/validation.test.mjs +69 -0
package/packages/platform-core/src/capabilities.js +49 -0
package/packages/platform-core/src/paths.js +75 -0
package/packages/platform-core/src/platform.js +15 -0
package/packages/platform-core/test/platform.test.mjs +84 -0
package/packages/protocol/src/messages.js +156 -0
package/packages/protocol/test/messages.test.mjs +112 -0
package/packages/session-core/src/bubble-linger.js +47 -0
package/packages/session-core/src/bubble-view.js +79 -0
package/packages/session-core/src/pet-state.js +56 -0
package/packages/session-core/src/priority.js +56 -0
package/packages/session-core/src/registry.js +144 -0
package/packages/session-core/src/summaries.js +54 -0
package/packages/session-core/test/bubble-linger.test.mjs +96 -0
package/packages/session-core/test/bubble-view.test.mjs +79 -0
package/packages/session-core/test/pet-state.test.mjs +118 -0
package/packages/session-core/test/priority.test.mjs +53 -0
package/packages/session-core/test/registry.test.mjs +161 -0
package/packages/session-core/test/summaries.test.mjs +38 -0
package/packages/task-core/src/approvals.js +91 -0
package/packages/task-core/src/controls.js +61 -0
package/packages/task-core/src/replies.js +80 -0
package/packages/task-core/src/task-events.js +101 -0
package/packages/task-core/src/task-status.js +93 -0
package/packages/task-core/src/task-store.js +74 -0
package/packages/task-core/test/approvals.test.mjs +61 -0
package/packages/task-core/test/controls.test.mjs +61 -0
package/packages/task-core/test/replies.test.mjs +51 -0
package/packages/task-core/test/task-events.test.mjs +67 -0
package/packages/task-core/test/task-status.test.mjs +49 -0
package/packages/task-core/test/task-store.test.mjs +65 -0
package/test/harness.mjs +22 -0
package/test/run-tests.mjs +47 -0

package/apps/companion/src/main/window-options.js ADDED Viewed

@@ -0,0 +1,66 @@
+// The pet sprite cell is 192×208. The overlay window itself spans the whole
+// work area (so the bubble panel can sit on whichever side of the pet has room),
+// and is kept click-through except over the pet + bubbles.
+export const PET_SIZE = Object.freeze({
+  width: 192,
+  height: 208
+});
+const DEFAULT_BOUNDS = PET_SIZE;
+export function buildPetWindowOptions({ capabilities, bounds = DEFAULT_BOUNDS } = {}) {
+  const overlaySupported = capabilities?.transparentOverlay === "required";
+  const overlayMode = overlaySupported ? "transparent-overlay" : "fallback-window";
+  return {
+    overlayMode,
+    browserWindow: overlaySupported
+      ? buildTransparentOverlayOptions(bounds)
+      : buildFallbackWindowOptions(bounds)
+  };
+}
+function buildTransparentOverlayOptions(bounds) {
+  return {
+    ...normalizeBounds(bounds),
+    transparent: true,
+    frame: false,
+    alwaysOnTop: true,
+    skipTaskbar: true,
+    resizable: false,
+    hasShadow: false,
+    focusable: false,
+    backgroundColor: "#00000000"
+  };
+}
+function buildFallbackWindowOptions(bounds) {
+  return {
+    ...normalizeBounds(bounds),
+    transparent: false,
+    frame: true,
+    alwaysOnTop: true,
+    skipTaskbar: false,
+    resizable: true,
+    hasShadow: true,
+    focusable: true,
+    backgroundColor: "#ffffff"
+  };
+}
+function normalizeBounds(bounds) {
+  const normalized = {
+    width: bounds.width ?? DEFAULT_BOUNDS.width,
+    height: bounds.height ?? DEFAULT_BOUNDS.height
+  };
+  if (Number.isFinite(bounds.x)) {
+    normalized.x = bounds.x;
+  }
+  if (Number.isFinite(bounds.y)) {
+    normalized.y = bounds.y;
+  }
+  return normalized;
+}

package/apps/companion/src/renderer/index.html ADDED Viewed

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta http-equiv="Content-Security-Policy" content="default-src 'self' file:; img-src 'self' file: data:; style-src 'self' 'unsafe-inline';" />
+    <title>Haya Pet</title>
+    <link rel="stylesheet" href="styles.css" />
+  </head>
+  <body>
+    <!-- Layer 1: the global pet overlay. -->
+    <canvas id="pet-canvas" class="interactive" width="192" height="208"></canvas>
+    <!-- Layer 2: ongoing-session progress bubbles + folder toggle. -->
+    <div id="bubbles" class="bubbles"></div>
+    <script type="module" src="pet-window.js"></script>
+  </body>
+</html>

package/apps/companion/src/renderer/interaction-controller.js ADDED Viewed

@@ -0,0 +1,114 @@
+const DEFAULT_DRAG_THRESHOLD = 6;
+const DEFAULT_CLICK_MAX_DURATION = 300;
+const DEFAULT_DOUBLE_CLICK_WINDOW = 350;
+// Distinguishes click / double-click / drag from raw pointer events.
+//
+// - Drag is reported synchronously from pointerMove/pointerUp so window movement
+//   stays responsive, and its direction is derived from the *incremental*
+//   movement (last point -> current point) so left/right flips the instant the
+//   user reverses, instead of waiting to cancel out the cumulative offset.
+// - Click is *deferred* by the double-click window and delivered via onAction;
+//   if a second click lands first, the pending single click is cancelled so a
+//   double click never also fires a wave. Timers are injectable for testing.
+export function createInteractionController(options = {}) {
+  const dragThreshold = options.dragThreshold ?? DEFAULT_DRAG_THRESHOLD;
+  const clickMaxDuration = options.clickMaxDuration ?? DEFAULT_CLICK_MAX_DURATION;
+  const doubleClickWindow = options.doubleClickWindow ?? DEFAULT_DOUBLE_CLICK_WINDOW;
+  const onAction = options.onAction ?? (() => {});
+  const setTimer = options.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+  const clearTimer = options.clearTimer ?? ((id) => clearTimeout(id));
+  let pointerStart;
+  let lastPoint;
+  let dragging = false;
+  let lastDirection;
+  let pendingClickTimer;
+  function cancelPendingClick() {
+    if (pendingClickTimer !== undefined) {
+      clearTimer(pendingClickTimer);
+      pendingClickTimer = undefined;
+    }
+  }
+  return {
+    pointerDown(point) {
+      pointerStart = point;
+      lastPoint = point;
+      dragging = false;
+      lastDirection = undefined;
+    },
+    pointerMove(point) {
+      if (!pointerStart) {
+        return undefined;
+      }
+      const totalDx = point.x - pointerStart.x;
+      const totalDy = point.y - pointerStart.y;
+      if (!dragging && distance(totalDx, totalDy) <= dragThreshold) {
+        return undefined;
+      }
+      dragging = true;
+      const incrementalDx = point.x - lastPoint.x;
+      lastPoint = point;
+      let direction = lastDirection;
+      if (incrementalDx < 0) {
+        direction = "left";
+      } else if (incrementalDx > 0) {
+        direction = "right";
+      } else if (!direction) {
+        direction = totalDx < 0 ? "left" : "right";
+      }
+      lastDirection = direction;
+      return {
+        type: "drag",
+        direction,
+        action: direction === "left" ? "running-left" : "running-right"
+      };
+    },
+    pointerUp(point) {
+      if (!pointerStart) {
+        return undefined;
+      }
+      const startedAt = pointerStart;
+      pointerStart = undefined;
+      if (dragging) {
+        dragging = false;
+        return { type: "drag-end" };
+      }
+      const duration = point.time - startedAt.time;
+      if (duration > clickMaxDuration) {
+        return undefined;
+      }
+      if (pendingClickTimer !== undefined) {
+        // Second click within the window -> double click; drop the pending single.
+        cancelPendingClick();
+        onAction({ type: "double-click", action: "jumping" });
+        return undefined;
+      }
+      pendingClickTimer = setTimer(() => {
+        pendingClickTimer = undefined;
+        onAction({ type: "click", action: "waving" });
+      }, doubleClickWindow);
+      return undefined;
+    }
+  };
+}
+function distance(x, y) {
+  return Math.sqrt(x * x + y * y);
+}

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

@@ -0,0 +1,275 @@
+// Layer 1 renderer: the global pet overlay. The animation, interaction, and
+// state-mapping logic all come from the unit-tested pure packages; this module
+// is the browser glue that draws frames and forwards pointer gestures.
+import { CELL_HEIGHT, CELL_WIDTH, getFrameRect } from "../../../../packages/pet-core/src/atlas.js";
+import { getActionDurationMs, getFrameAt } from "../../../../packages/pet-core/src/animator.js";
+import {
+  clearDragAction,
+  createAnimationState,
+  resolveCurrentAction,
+  setDragAction,
+  setStableAction,
+  triggerOneShot
+} from "../../../../packages/pet-core/src/animation-state.js";
+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 { createInteractionController } from "./interaction-controller.js";
+import { createBubbleList } from "./session-bubbles.js";
+const bridge = window.aiPet;
+const canvas = document.getElementById("pet-canvas");
+const ctx = canvas.getContext("2d");
+const panelEl = document.getElementById("bubbles");
+const controller = createInteractionController({
+  // Click is deferred so a double-click never also fires a wave. Clicking the
+  // pet folds/unfolds the session bubbles; double-click forces them open.
+  onAction: (event) => {
+    if (event.type === "click") {
+      playOneShot("waving");
+      bubbleList.toggle();
+    } else if (event.type === "double-click") {
+      playOneShot("jumping");
+      bubbleList.expand();
+    }
+  }
+});
+// Reposition the panel beside the pet after every (re)render, since its size
+// changes with the number of bubbles and the collapsed/expanded state.
+const bubbleList = createBubbleList(panelEl, { onRender: placePanel });
+let animationState = createAnimationState("idle");
+let manifest = { frameDurationMs: 120 };
+let spritesheet;
+let currentAction = "idle";
+let actionStart = 0;
+let dragOffset = { x: 0, y: 0 };
+let previousSessionStates = {};
+// The pet lives at this work-area-relative position inside the full-screen
+// overlay window; dragging moves it via CSS (the window never moves).
+let petLocal = { x: 0, y: 0 };
+// Linger bookkeeping so a finished session's bubble stays ~2s before vanishing.
+let lingerState = {};
+let lingerTimer;
+let lastBubblesPayload = [];
+function setupPet(config) {
+  if (config?.pet?.manifest) {
+    manifest = config.pet.manifest;
+  }
+  if (config?.petPosition) {
+    applyPetPosition(config.petPosition);
+  }
+  if (config?.pet?.spritesheetUrl) {
+    const image = new Image();
+    image.onload = () => {
+      spritesheet = image;
+    };
+    image.src = config.pet.spritesheetUrl;
+  }
+}
+function applyPetPosition(pos) {
+  petLocal = clampPetLocal(pos);
+  canvas.style.left = `${petLocal.x}px`;
+  canvas.style.top = `${petLocal.y}px`;
+  placePanel();
+}
+function clampPetLocal(pos) {
+  const maxX = Math.max(0, window.innerWidth - canvas.width);
+  const maxY = Math.max(0, window.innerHeight - canvas.height);
+  return {
+    x: Math.min(Math.max(Math.round(pos?.x ?? 0), 0), maxX),
+    y: Math.min(Math.max(Math.round(pos?.y ?? 0), 0), maxY)
+  };
+}
+// Anchors the folder button on whichever side of the pet has room, fully inside
+// the overlay (== the work area), so dragging never pushes it off-screen. The
+// button's box drives the placement; the (absolutely positioned) list then
+// opens toward the screen centre, so toggling it never moves the button.
+function placePanel() {
+  const rect = panelEl.getBoundingClientRect();
+  if (!rect.width || !rect.height) {
+    return; // nothing to place (no active sessions)
+  }
+  const workArea = { x: 0, y: 0, width: window.innerWidth, height: window.innerHeight };
+  const placement = resolvePanelPlacement({
+    pet: { x: petLocal.x, y: petLocal.y, width: canvas.width, height: canvas.height },
+    panel: { width: rect.width, height: rect.height },
+    workArea
+  });
+  panelEl.style.left = `${Math.round(placement.x)}px`;
+  panelEl.style.top = `${Math.round(placement.y)}px`;
+  const list = panelEl.querySelector(".bubble-list");
+  if (list) {
+    const margin = 12;
+    const openUp = placement.y > workArea.height / 2;
+    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.
+    const room = openUp ? placement.y - margin : workArea.height - (placement.y + rect.height) - margin;
+    list.style.maxHeight = `${Math.max(96, Math.round(room))}px`;
+  }
+}
+function frameLoop(now) {
+  const action = resolveCurrentAction(animationState, now);
+  if (action !== currentAction) {
+    currentAction = action;
+    actionStart = now;
+  }
+  const frameIndex = getFrameAt(action, now - actionStart, manifest);
+  draw(action, frameIndex);
+  requestAnimationFrame(frameLoop);
+}
+function draw(action, frameIndex) {
+  ctx.clearRect(0, 0, canvas.width, canvas.height);
+  if (spritesheet) {
+    const rect = getFrameRect(action, frameIndex);
+    ctx.drawImage(spritesheet, rect.x, rect.y, rect.width, rect.height, 0, 0, canvas.width, canvas.height);
+  } else {
+    drawPlaceholder(action, frameIndex);
+  }
+}
+// Development fallback so the pet still renders without a Codex spritesheet.
+function drawPlaceholder(action, frameIndex) {
+  ctx.fillStyle = "rgba(110, 168, 254, 0.85)";
+  ctx.beginPath();
+  ctx.roundRect ? ctx.roundRect(16, 16, CELL_WIDTH - 32, CELL_HEIGHT - 32, 16) : ctx.rect(16, 16, CELL_WIDTH - 32, CELL_HEIGHT - 32);
+  ctx.fill();
+  ctx.fillStyle = "#001233";
+  ctx.font = "14px system-ui";
+  ctx.textAlign = "center";
+  ctx.fillText(action, CELL_WIDTH / 2, CELL_HEIGHT / 2);
+  ctx.fillText(`frame ${frameIndex}`, CELL_WIDTH / 2, CELL_HEIGHT / 2 + 20);
+}
+function playOneShot(action) {
+  animationState = triggerOneShot(animationState, action, performance.now(), getActionDurationMs(action, manifest));
+}
+// --- Pointer interaction (click vs drag distinction lives in the controller) ---
+canvas.addEventListener("pointerdown", (event) => {
+  canvas.setPointerCapture(event.pointerId);
+  dragOffset = { x: event.offsetX, y: event.offsetY };
+  // Window-local (clientX/Y) coords throughout — the overlay covers the work area.
+  controller.pointerDown({ x: event.clientX, y: event.clientY, time: performance.now() });
+});
+canvas.addEventListener("pointermove", (event) => {
+  const result = controller.pointerMove({ x: event.clientX, y: event.clientY, time: performance.now() });
+  if (result?.type === "drag") {
+    animationState = setDragAction(animationState, result.direction);
+    applyPetPosition({ x: event.clientX - dragOffset.x, y: event.clientY - dragOffset.y });
+  }
+});
+canvas.addEventListener("pointerup", (event) => {
+  // Click / double-click are delivered asynchronously via onAction; only the
+  // synchronous drag-end is handled here.
+  const result = controller.pointerUp({ x: event.clientX, y: event.clientY, time: performance.now() });
+  if (result?.type === "drag-end") {
+    animationState = clearDragAction(animationState);
+    bridge?.savePetPosition?.(petLocal);
+  }
+});
+// Re-clamp and re-place when the work area changes (display/resolution change).
+window.addEventListener("resize", () => {
+  applyPetPosition(petLocal);
+});
+// --- Session wiring ---
+function applySessions(payload) {
+  const allBubbles = payload?.bubbles ?? [];
+  const { stableAction, oneShots, nextStates } = resolveCompanionPetState({
+    bubbles: allBubbles,
+    prioritySessionId: payload?.prioritySessionId,
+    previousStates: previousSessionStates
+  });
+  previousSessionStates = nextStates;
+  // The pet's body language is driven only by active work (handled inside the
+  // resolver); the panel shows every live session via renderBubbles().
+  lastBubblesPayload = allBubbles;
+  renderBubbles();
+  for (const action of oneShots) {
+    playOneShot(action);
+  }
+  animationState = setStableAction(animationState, stableAction);
+  refreshMouseIgnore(lastPointer.x, lastPointer.y);
+}
+// Applies the 2s linger: finished sessions keep their final status icon briefly,
+// then drop off. Re-runs itself when the linger window elapses so a bubble
+// disappears on schedule even if no new session event arrives.
+function renderBubbles() {
+  const { visible, lingerState: nextLinger, nextWakeMs } = resolveVisibleBubbles({
+    bubbles: lastBubblesPayload,
+    now: Date.now(),
+    lingerState
+  });
+  lingerState = nextLinger;
+  bubbleList.render(visible);
+  clearTimeout(lingerTimer);
+  if (nextWakeMs !== undefined) {
+    lingerTimer = setTimeout(renderBubbles, nextWakeMs);
+  }
+  refreshMouseIgnore(lastPointer.x, lastPointer.y);
+}
+// --- Click-through forwarding ---
+//
+// The overlay window covers a large area but should only intercept the mouse
+// over the pet and the bubble chips; everywhere else must pass through to the
+// desktop. The window is created ignoring mouse events (with forwarding), and
+// we flip it back on whenever the cursor is over an `.interactive` element.
+let mouseIgnored;
+let lastPointer = { x: -1, y: -1 };
+function refreshMouseIgnore(x, y) {
+  if (!Number.isFinite(x) || !Number.isFinite(y)) {
+    return;
+  }
+  const target = document.elementFromPoint(x, y);
+  const interactive = Boolean(target && target.closest(".interactive"));
+  const ignore = !interactive;
+  if (ignore !== mouseIgnored) {
+    mouseIgnored = ignore;
+    bridge?.setMouseIgnore?.(ignore);
+  }
+}
+window.addEventListener("mousemove", (event) => {
+  lastPointer = { x: event.clientX, y: event.clientY };
+  refreshMouseIgnore(event.clientX, event.clientY);
+});
+if (bridge) {
+  bridge.setMouseIgnore?.(true);
+  bridge.onConfig(setupPet);
+  bridge.onSessions(applySessions);
+  bridge.onPetPosition?.(applyPetPosition);
+  bridge.listSessions().then(applySessions).catch(() => {});
+}
+requestAnimationFrame(frameLoop);

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

@@ -0,0 +1,138 @@
+// Layer 2 renderer: Codex-style progress bubbles. Each ongoing AI session shows
+// a status icon, its title (client · project), and the newest activity line.
+// A folder button at the top toggles the whole stack open/closed.
+//
+// Consumes the bubble view models produced by packages/session-core/bubble-view.js
+// (already shaped + sorted by the main process), so this module is pure DOM glue.
+// Status kinds come from `bubble.statusKind`: working | done | attention | failed.
+const STATUS_GLYPH = Object.freeze({
+  working: "",   // animated spinner drawn via CSS
+  done: "✓",
+  attention: "!",
+  failed: "✕",
+  idle: ""
+});
+export function createBubbleList(container, { collapsed = false, onRender } = {}) {
+  let lastBubbles = [];
+  let isCollapsed = collapsed;
+  function toggle() {
+    isCollapsed = !isCollapsed;
+    paint();
+  }
+  function paint() {
+    container.innerHTML = "";
+    // Nothing running -> keep the overlay clean (just the pet, no folder button).
+    if (lastBubbles.length > 0) {
+      container.appendChild(renderFolderButton(lastBubbles, isCollapsed, toggle));
+      if (!isCollapsed) {
+        const list = document.createElement("div");
+        list.className = "bubble-list";
+        for (const bubble of lastBubbles) {
+          list.appendChild(renderBubble(bubble));
+        }
+        container.appendChild(list);
+      }
+    }
+    // Let the host reposition the panel now that its size is known.
+    onRender?.();
+  }
+  return {
+    render(bubbles = []) {
+      lastBubbles = Array.isArray(bubbles) ? bubbles : [];
+      paint();
+    },
+    expand() {
+      if (isCollapsed) {
+        toggle();
+      }
+    },
+    toggle,
+    isCollapsed: () => isCollapsed
+  };
+}
+function renderFolderButton(bubbles, collapsed, onToggle) {
+  const btn = document.createElement("button");
+  // "interactive" marks the only pointer-active regions so the rest of the
+  // overlay window can stay click-through (see pet-window.js).
+  btn.className = "folder-toggle interactive";
+  btn.type = "button";
+  btn.setAttribute("aria-expanded", String(!collapsed));
+  btn.title = collapsed ? "Show sessions" : "Hide sessions";
+  // A simple disclosure caret (rotates when open) — quieter than a folder glyph.
+  const caret = document.createElement("span");
+  caret.className = "caret";
+  const count = document.createElement("span");
+  count.className = "folder-count";
+  count.textContent = String(bubbles.length);
+  // A small dot summary of the most urgent kind, so the user can tell something
+  // needs attention without opening the folder.
+  const summary = document.createElement("span");
+  summary.className = "folder-summary";
+  summary.dataset.kind = mostUrgentKind(bubbles);
+  btn.append(caret, count, summary);
+  btn.addEventListener("click", onToggle);
+  return btn;
+}
+function renderBubble(bubble) {
+  const el = document.createElement("div");
+  el.className = "bubble interactive";
+  el.dataset.sessionId = bubble.sessionId;
+  el.dataset.kind = bubble.statusKind;
+  const icon = document.createElement("span");
+  icon.className = "status-icon";
+  icon.dataset.kind = bubble.statusKind;
+  icon.textContent = STATUS_GLYPH[bubble.statusKind] ?? "";
+  icon.title = bubble.statusLabel;
+  const body = document.createElement("div");
+  body.className = "body";
+  const title = document.createElement("div");
+  title.className = "title";
+  title.innerHTML = `<span class="client">${escapeHtml(bubble.clientName)}</span> ` +
+    `<span class="project">${escapeHtml(bubble.projectName)}</span>`;
+  const activity = document.createElement("div");
+  activity.className = "activity";
+  activity.textContent = bubble.summary;
+  activity.title = `${bubble.statusLabel} · ${bubble.elapsedLabel}`;
+  body.append(title, activity);
+  el.append(icon, body);
+  return el;
+}
+// Picks the kind that should win the collapsed-folder dot: a failure or a
+// request for attention always beats ongoing work, which beats done/idle.
+const KIND_RANK = Object.freeze({ failed: 0, attention: 1, working: 2, done: 3, idle: 4 });
+function mostUrgentKind(bubbles) {
+  let best = "idle";
+  for (const bubble of bubbles) {
+    if ((KIND_RANK[bubble.statusKind] ?? 9) < (KIND_RANK[best] ?? 9)) {
+      best = bubble.statusKind;
+    }
+  }
+  return best;
+}
+function escapeHtml(value) {
+  return String(value ?? "")
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}