mulmoclaude 0.3.0 → 0.4.0

package/src/composables/useDynamicFavicon.ts

@@ -1,11 +1,21 @@
 // Dynamic favicon that changes color based on agent state (#470).
 //
-// Uses Canvas API to draw a rounded-square icon with the letter "M"
-// in the center. Color reflects the current state:
+// Renders the MulmoClaude mascot on a colored rounded square. The
+// background color reflects state, and the mascot floats on top:
 //   idle (gray) → running (blue, pulse) → done (green) → error (red)
 //   notification badge (orange dot) overlaid when unread count > 0.
+//
+// The logo PNG has an opaque white background, which would otherwise
+// hide the state color. On first load we pre-process the pixels,
+// punching out near-white pixels to transparency so the colored
+// backing shows through. The processed image is cached as an
+// offscreen canvas for the lifetime of the page.
+//
+// If the logo fails to load we fall back to the earlier "M"-letter
+// variant so the tab icon never disappears entirely.
 
 import { watch, type Ref, type ComputedRef } from "vue";
+import logoUrl from "../assets/mulmo_bw.png";
 
 export const FAVICON_STATES = {
   idle: "idle",
@@ -23,9 +33,88 @@ const STATE_COLORS: Record<FaviconState, string> = {
   error: "#EF4444", // red-500
 };
 
-const NOTIFICATION_DOT_COLOR = "#F97316"; // orange-500
+const NOTIFICATION_DOT_COLOR = "#DC2626"; // red-600 — stands out against the gray/blue/green state backgrounds
 const SIZE = 32;
 const RADIUS = 6;
+// How much of the inner rounded square the mascot fills. 2 px of
+// padding on each side keeps it off the rounded corners and leaves
+// room for the colored backing to peek around the outline.
+const MASCOT_INSET = 2;
+
+// Pixels whose RGB channels are all above this are treated as the
+// PNG's white backing and punched to transparent. The PNG uses a soft
+// pastel palette so the mascot itself never hits all three channels
+// this high.
+const WHITE_TO_ALPHA_THRESHOLD = 235;
+// Pixels in the [FEATHER_LOW, WHITE_TO_ALPHA_THRESHOLD] band get a
+// partial-alpha ramp so the mascot's anti-aliased outline blends with
+// the colored background instead of showing a hard seam.
+const FEATHER_LOW = 205;
+
+// ── Asset loading ──────────────────────────────────────────────
+
+let logoCanvas: HTMLCanvasElement | null = null;
+let logoLoadFailed = false;
+let logoLoadPromise: Promise<HTMLCanvasElement> | null = null;
+
+function loadLogo(): Promise<HTMLCanvasElement> {
+  if (logoCanvas) return Promise.resolve(logoCanvas);
+  if (logoLoadPromise) return logoLoadPromise;
+  logoLoadPromise = decodeAndPunchOutWhite();
+  return logoLoadPromise;
+}
+
+function decodeAndPunchOutWhite(): Promise<HTMLCanvasElement> {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onload = () => {
+      try {
+        logoCanvas = buildTransparentLogoCanvas(img);
+        resolve(logoCanvas);
+      } catch (err) {
+        logoLoadFailed = true;
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    };
+    img.onerror = (err) => {
+      logoLoadFailed = true;
+      reject(err instanceof Error ? err : new Error("favicon logo failed to load"));
+    };
+    img.src = logoUrl;
+  });
+}
+
+// Copy the decoded <img> into an offscreen canvas and scan every
+// pixel, replacing near-white with transparency. The PNG is opaque so
+// the background would otherwise cover the state color backing.
+function buildTransparentLogoCanvas(img: HTMLImageElement): HTMLCanvasElement {
+  const canvas = document.createElement("canvas");
+  canvas.width = img.naturalWidth;
+  canvas.height = img.naturalHeight;
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error("2d context unavailable");
+  ctx.drawImage(img, 0, 0);
+  const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+  const pixels = imageData.data;
+  for (let i = 0; i < pixels.length; i += 4) {
+    const red = pixels[i];
+    const green = pixels[i + 1];
+    const blue = pixels[i + 2];
+    const minChannel = Math.min(red, green, blue);
+    if (minChannel >= WHITE_TO_ALPHA_THRESHOLD) {
+      pixels[i + 3] = 0; // fully transparent
+    } else if (minChannel >= FEATHER_LOW) {
+      // Linear ramp across the feather band. At minChannel = FEATHER_LOW
+      // alpha stays 255; at threshold it drops to 0.
+      const ratio = (minChannel - FEATHER_LOW) / (WHITE_TO_ALPHA_THRESHOLD - FEATHER_LOW);
+      pixels[i + 3] = Math.round(255 * (1 - ratio));
+    }
+  }
+  ctx.putImageData(imageData, 0, 0);
+  return canvas;
+}
+
+// ── Drawing primitives ─────────────────────────────────────────
 
 function drawRoundedRect(ctx: CanvasRenderingContext2D, posX: number, posY: number, width: number, height: number, radius: number): void {
   ctx.beginPath();
@@ -41,54 +130,94 @@ function drawRoundedRect(ctx: CanvasRenderingContext2D, posX: number, posY: numb
   ctx.closePath();
 }
 
-function renderFavicon(state: FaviconState, hasNotification: boolean): string {
-  const canvas = document.createElement("canvas");
-  canvas.width = SIZE;
-  canvas.height = SIZE;
-  const ctx = canvas.getContext("2d");
-  if (!ctx) return "";
+// Aspect-preserving letterbox: scale the logo to fit the inner area
+// without distorting the mascot, then center the leftover space.
+function drawLogoCentered(ctx: CanvasRenderingContext2D, source: HTMLCanvasElement, inset: number): void {
+  const available = SIZE - inset * 2;
+  const aspect = source.width / source.height;
+  const drawW = aspect >= 1 ? available : available * aspect;
+  const drawH = aspect >= 1 ? available / aspect : available;
+  const drawX = inset + (available - drawW) / 2;
+  const drawY = inset + (available - drawH) / 2;
+  ctx.drawImage(source, drawX, drawY, drawW, drawH);
+}
 
-  // Background: rounded square
-  const color = STATE_COLORS[state];
-  drawRoundedRect(ctx, 1, 1, SIZE - 2, SIZE - 2, RADIUS);
-  ctx.fillStyle = color;
+function drawNotificationDot(ctx: CanvasRenderingContext2D): void {
+  const dotR = 5;
+  const dotX = SIZE - dotR - 1;
+  const dotY = dotR + 1;
+  ctx.beginPath();
+  ctx.arc(dotX, dotY, dotR, 0, Math.PI * 2);
+  ctx.fillStyle = NOTIFICATION_DOT_COLOR;
   ctx.fill();
+  ctx.strokeStyle = "white";
+  ctx.lineWidth = 1.5;
+  ctx.stroke();
+}
+
+// ── Composition ────────────────────────────────────────────────
 
-  // Subtle shadow/depth
-  ctx.strokeStyle = "rgba(0,0,0,0.15)";
-  ctx.lineWidth = 1;
+// Fallback for when the logo PNG fails to decode (or before the first
+// decode completes). Mirrors the earlier "M"-on-colored-square design
+// so the favicon always has a valid first paint.
+function renderFallbackFavicon(ctx: CanvasRenderingContext2D, state: FaviconState, hasNotification: boolean): void {
   drawRoundedRect(ctx, 1, 1, SIZE - 2, SIZE - 2, RADIUS);
-  ctx.stroke();
+  ctx.fillStyle = STATE_COLORS[state];
+  ctx.fill();
 
-  // "M" letter
   ctx.fillStyle = "white";
   ctx.font = "bold 20px -apple-system, BlinkMacSystemFont, sans-serif";
   ctx.textAlign = "center";
   ctx.textBaseline = "middle";
   ctx.fillText("M", SIZE / 2, SIZE / 2 + 1);
 
-  // Running state: subtle glow ring
+  if (hasNotification) drawNotificationDot(ctx);
+}
+
+function renderLogoFavicon(ctx: CanvasRenderingContext2D, logo: HTMLCanvasElement, state: FaviconState, hasNotification: boolean): void {
+  // Colored rounded-square backing — the dynamic cue.
+  drawRoundedRect(ctx, 0, 0, SIZE, SIZE, RADIUS);
+  ctx.fillStyle = STATE_COLORS[state];
+  ctx.fill();
+
+  // Clip subsequent draws to the rounded square so the mascot's
+  // anti-aliased edges don't spill past the corners.
+  ctx.save();
+  drawRoundedRect(ctx, 0, 0, SIZE, SIZE, RADIUS);
+  ctx.clip();
+  drawLogoCentered(ctx, logo, MASCOT_INSET);
+  ctx.restore();
+
+  // Running state: subtle inner glow ring reinforces the pulse cue
+  // without overpowering the colored backing.
   if (state === FAVICON_STATES.running) {
-    ctx.strokeStyle = "rgba(255,255,255,0.4)";
-    ctx.lineWidth = 2;
-    drawRoundedRect(ctx, 3, 3, SIZE - 6, SIZE - 6, RADIUS - 1);
+    ctx.strokeStyle = "rgba(255, 255, 255, 0.55)";
+    ctx.lineWidth = 1.5;
+    drawRoundedRect(ctx, 2.25, 2.25, SIZE - 4.5, SIZE - 4.5, Math.max(RADIUS - 1, 2));
     ctx.stroke();
   }
 
-  // Notification badge (orange dot, top-right)
-  if (hasNotification) {
-    const dotR = 5;
-    const dotX = SIZE - dotR - 1;
-    const dotY = dotR + 1;
-    ctx.beginPath();
-    ctx.arc(dotX, dotY, dotR, 0, Math.PI * 2);
-    ctx.fillStyle = NOTIFICATION_DOT_COLOR;
-    ctx.fill();
-    ctx.strokeStyle = "white";
-    ctx.lineWidth = 1.5;
-    ctx.stroke();
+  if (hasNotification) drawNotificationDot(ctx);
+}
+
+async function renderFavicon(state: FaviconState, hasNotification: boolean): Promise<string> {
+  const canvas = document.createElement("canvas");
+  canvas.width = SIZE;
+  canvas.height = SIZE;
+  const ctx = canvas.getContext("2d");
+  if (!ctx) return "";
+
+  if (!logoLoadFailed) {
+    try {
+      const logo = await loadLogo();
+      renderLogoFavicon(ctx, logo, state, hasNotification);
+      return canvas.toDataURL("image/png");
+    } catch {
+      // fall through — renderFallbackFavicon below handles it.
+    }
   }
 
+  renderFallbackFavicon(ctx, state, hasNotification);
   return canvas.toDataURL("image/png");
 }
 
@@ -106,10 +235,16 @@ function applyFavicon(dataUrl: string): void {
 }
 
 export function useDynamicFavicon(opts: { state: Ref<FaviconState> | ComputedRef<FaviconState>; hasNotification: Ref<boolean> | ComputedRef<boolean> }): void {
-  function update(): void {
-    const dataUrl = renderFavicon(opts.state.value, opts.hasNotification.value);
+  async function update(): Promise<void> {
+    const dataUrl = await renderFavicon(opts.state.value, opts.hasNotification.value);
     applyFavicon(dataUrl);
   }
 
-  watch([opts.state, opts.hasNotification], update, { immediate: true });
+  watch(
+    [opts.state, opts.hasNotification],
+    () => {
+      update().catch((err) => console.warn("[favicon] render failed", err));
+    },
+    { immediate: true },
+  );
 }

package/src/composables/useEventListeners.ts

@@ -1,13 +1,16 @@
 // Composable that wires the window-level event listeners used by
-// App.vue (click-outside handlers for 3 popups + global keydown for
-// navigation + view-mode shortcuts) and tears them down on unmount.
+// App.vue (global keydown for navigation + view-mode shortcuts) and
+// tears them down on unmount.
 //
 // Plugin → App.vue communication used to live here too via
 // `roles-updated` / `skill-run` CustomEvents on `window`. That now
 // flows through `useAppApi` (provide/inject) — see #227. Anything
 // remaining in this composable is genuinely a window-level concern
-// (keyboard / mouse events that don't have a single "owning"
-// component).
+// (keyboard events that don't have a single "owning" component).
+//
+// The click-outside handler for the history popup was dropped when
+// the popup became a real page at /history (see
+// plans/feat-history-url-route.md).
 //
 // Each listener is supplied as an option so the composable stays
 // independent of App.vue's local state; the caller passes the
@@ -20,8 +23,6 @@ export interface EventListenerHandlers {
   onKeyNavigation: (e: KeyboardEvent) => void;
   /** Global keydown for Cmd/Ctrl+1/2/3 view-mode shortcut. */
   onViewModeShortcut: (e: KeyboardEvent) => void;
-  /** mousedown click-outside handlers for each popup. */
-  onClickOutsideHistory: (e: MouseEvent) => void;
   /** Called in onUnmounted after all window listeners are removed. */
   onTeardown?: () => void;
 }
@@ -30,13 +31,11 @@ export function useEventListeners(handlers: EventListenerHandlers): void {
   onMounted(() => {
     window.addEventListener("keydown", handlers.onKeyNavigation);
     window.addEventListener("keydown", handlers.onViewModeShortcut);
-    window.addEventListener("mousedown", handlers.onClickOutsideHistory);
   });
 
   onUnmounted(() => {
     window.removeEventListener("keydown", handlers.onKeyNavigation);
     window.removeEventListener("keydown", handlers.onViewModeShortcut);
-    window.removeEventListener("mousedown", handlers.onClickOutsideHistory);
     handlers.onTeardown?.();
   });
 }

package/src/composables/useFaviconState.ts

@@ -10,8 +10,13 @@ export function useFaviconState(opts: {
   isRunning: ComputedRef<boolean>;
   currentSummary: ComputedRef<SessionSummary | undefined>;
   activeSession: ComputedRef<ActiveSession | undefined>;
+  // Number of sessions (across all tabs) with unread messages. We
+  // light the badge dot when any session is unread, even if it's not
+  // the currently-focused one, so background replies still surface in
+  // the tab bar.
+  sessionsUnreadCount: ComputedRef<number>;
 }) {
-  const { isRunning, currentSummary, activeSession } = opts;
+  const { isRunning, currentSummary, activeSession, sessionsUnreadCount } = opts;
 
   const faviconState = computed<FaviconState>(() => {
     if (isRunning.value) return FAVICON_STATES.running;
@@ -21,7 +26,13 @@ export function useFaviconState(opts: {
   });
 
   const { unreadCount: notificationUnreadCount } = useNotifications();
-  const hasNotificationBadge = computed(() => notificationUnreadCount.value > 0);
+  // Badge dot covers two independent signals:
+  //   1. Pub-sub notifications (scheduled tasks, etc.)
+  //   2. Any session with unread chat messages (including background
+  //      tabs the user isn't currently viewing).
+  // Either one flips the dot on — the dot doesn't distinguish source,
+  // just tells the user "there's something to look at".
+  const hasNotificationBadge = computed(() => notificationUnreadCount.value > 0 || sessionsUnreadCount.value > 0);
 
   useDynamicFavicon({
     state: faviconState,

package/src/composables/useFileSelection.ts

@@ -32,12 +32,27 @@ export function isValidFilePath(value: unknown): value is string {
   return !value.split("/").some((seg) => seg === "..");
 }
 
+/**
+ * Extract the logical file path from a route's `pathMatch` param.
+ * Vue Router hands the repeatable catch-all back as an array, a
+ * single string, or `undefined` depending on what matched — normalise
+ * to a `string | null` so the rest of the composable doesn't care.
+ */
+export function readPathMatch(raw: unknown): string | null {
+  if (Array.isArray(raw)) {
+    if (raw.length === 0) return null;
+    return raw.join("/");
+  }
+  if (typeof raw === "string" && raw.length > 0) return raw;
+  return null;
+}
+
 export function useFileSelection() {
   const route = useRoute();
   const router = useRouter();
 
-  const urlPath = route.query.path;
-  const selectedPath = ref<string | null>(isValidFilePath(urlPath) ? urlPath : null);
+  const pathFromRoute = readPathMatch(route.params.pathMatch);
+  const selectedPath = ref<string | null>(isValidFilePath(pathFromRoute) ? pathFromRoute : null);
   const content = ref<FileContent | null>(null);
   const contentLoading = ref(false);
   const contentError = ref<string | null>(null);
@@ -71,8 +86,12 @@ export function useFileSelection() {
   function selectFile(filePath: string): void {
     selectedPath.value = filePath;
     loadContent(filePath);
-    const { path: __path, ...restQuery } = route.query;
-    router.push({ query: { ...restQuery, path: filePath } }).catch((err: unknown) => {
+    // Pass segments as an array so Vue Router encodes each segment
+    // independently (spaces / multi-byte / `?#%` get UTF-8 percent-
+    // encoding), while slashes stay as path separators. Passing the
+    // joined string would urlencode `/` → `%2F` and collapse the
+    // visible path shape.
+    router.push({ name: "files", params: { pathMatch: filePath.split("/") }, query: route.query }).catch((err: unknown) => {
       if (!isNavigationFailure(err)) {
         // Frontend composable — server logger not available.
         // console.error is the standard pattern in Vue composables.
@@ -88,8 +107,7 @@ export function useFileSelection() {
     content.value = null;
     contentLoading.value = false;
     contentError.value = null;
-    const { path: __path, ...restQuery } = route.query;
-    router.replace({ query: restQuery }).catch((err: unknown) => {
+    router.replace({ name: "files", params: { pathMatch: [] }, query: route.query }).catch((err: unknown) => {
       if (!isNavigationFailure(err)) {
         console.error("[deselectFile] navigation failed:", err);
       }

package/src/composables/useLayoutMode.ts

@@ -0,0 +1,32 @@
+// Layout preference (single vs. stack) for the /chat page, persisted
+// in localStorage. Independent of which page the user is on — pages
+// like Files/Todos/Wiki live in the router, not here.
+//
+// One-time cleanup: deletes the legacy `canvas_view_mode` key that
+// conflated layout with page navigation. The value is intentionally
+// not migrated — users land on "single" on first load after the
+// split.
+
+import { ref, type Ref } from "vue";
+import { LAYOUT_MODES, LAYOUT_MODE_STORAGE_KEY, LEGACY_VIEW_MODE_STORAGE_KEY, parseStoredLayoutMode, type LayoutMode } from "../utils/canvas/layoutMode";
+
+export function useLayoutMode(): {
+  layoutMode: Ref<LayoutMode>;
+  setLayoutMode: (mode: LayoutMode) => void;
+  toggleLayoutMode: () => void;
+} {
+  localStorage.removeItem(LEGACY_VIEW_MODE_STORAGE_KEY);
+
+  const layoutMode = ref<LayoutMode>(parseStoredLayoutMode(localStorage.getItem(LAYOUT_MODE_STORAGE_KEY)));
+
+  function setLayoutMode(mode: LayoutMode): void {
+    layoutMode.value = mode;
+    localStorage.setItem(LAYOUT_MODE_STORAGE_KEY, mode);
+  }
+
+  function toggleLayoutMode(): void {
+    setLayoutMode(layoutMode.value === LAYOUT_MODES.stack ? LAYOUT_MODES.single : LAYOUT_MODES.stack);
+  }
+
+  return { layoutMode, setLayoutMode, toggleLayoutMode };
+}

package/src/composables/useSessionHistory.ts

@@ -1,10 +1,10 @@
-// Composable for the session-history dropdown in the header.
+// Composable for the session-history view at `/history`.
 //
-// Owns the `sessions` list (what the server knows about) and the
-// `showHistory` open/closed flag, plus the fetch + toggle helpers.
-// The dropdown lazy-loads the list only when opened, and callers
-// can invoke `fetchSessions()` directly after an end-of-run so the
-// sidebar title cache stays fresh.
+// Owns the `sessions` list (what the server knows about) plus the
+// fetch helper. The view's open/closed state is now URL-backed (see
+// plans/feat-history-url-route.md) — callers watch `route.name` and
+// invoke `fetchSessions()` on route enter rather than going through
+// an in-memory toggle flag.
 //
 // Since #205, `fetchSessions()` sends the server's last-issued
 // cursor back as `?since=<cursor>` so the server can reply with
@@ -26,15 +26,12 @@ interface SessionsResponse {
 
 export function useSessionHistory(): {
   sessions: Ref<SessionSummary[]>;
-  showHistory: Ref<boolean>;
   historyError: Ref<string | null>;
   fetchSessions: () => Promise<SessionSummary[]>;
-  toggleHistory: () => Promise<void>;
 } {
   const sessions = ref<SessionSummary[]>([]);
-  const showHistory = ref(false);
   // Surfaces the most recent fetch failure. Kept alongside the (stale)
-  // sessions list rather than wiping it — a dropdown that goes blank
+  // sessions list rather than wiping it — a panel that goes blank
   // the moment the network hiccups is worse UX than one that shows
   // "⚠ using cached list" with the last-known good entries.
   const historyError = ref<string | null>(null);
@@ -66,16 +63,9 @@ export function useSessionHistory(): {
     return sessions.value;
   }
 
-  async function toggleHistory(): Promise<void> {
-    showHistory.value = !showHistory.value;
-    if (showHistory.value) await fetchSessions();
-  }
-
   return {
     sessions,
-    showHistory,
     historyError,
     fetchSessions,
-    toggleHistory,
   };
 }

package/src/composables/useViewLayout.ts

@@ -1,44 +1,31 @@
-// View-layout state: tracks whether the app is in a "stack" layout
-// (full-width canvas) or "single" (sidebar + canvas), remembers the
-// last chat-oriented view mode, and derives displayedCurrentSessionId
-// (blank in plugin views so no tab appears "current").
-
-import { computed, ref, watch, type ComputedRef, type Ref } from "vue";
-import { CANVAS_VIEW, type CanvasViewMode } from "../utils/canvas/viewMode";
-
-const CHAT_VIEWS = [CANVAS_VIEW.single, CANVAS_VIEW.stack] as const;
-type ChatViewMode = (typeof CHAT_VIEWS)[number];
-
-function isChatView(mode: string): mode is ChatViewMode {
-  return (CHAT_VIEWS as readonly string[]).includes(mode);
-}
+// View-layout state. Derives two values that the template cares about:
+//
+//  - isStackLayout: true whenever the canvas column should be full-width
+//    (no sidebar). This is the case for /chat in stack mode AND for
+//    every non-chat page (/files, /todos, /wiki, etc.). Only /chat in
+//    single mode shows the left sidebar.
+//
+//  - displayedCurrentSessionId: blank on non-chat pages so no session
+//    tab appears "current" while the user is on Files, Todos, etc.
+//
+// Also flips activePane between "sidebar" and "main" so arrow-key
+// navigation follows whichever side of the layout is visible.
+
+import { computed, watch, type ComputedRef, type Ref } from "vue";
+import { LAYOUT_MODES, type LayoutMode } from "../utils/canvas/layoutMode";
 
 export function useViewLayout(opts: {
-  canvasViewMode: Ref<CanvasViewMode> | ComputedRef<CanvasViewMode>;
-  setCanvasViewMode: (mode: CanvasViewMode) => void;
+  layoutMode: Ref<LayoutMode> | ComputedRef<LayoutMode>;
+  isChatPage: Ref<boolean> | ComputedRef<boolean>;
   currentSessionId: Ref<string>;
   activePane: Ref<"sidebar" | "main">;
 }) {
-  const { canvasViewMode, setCanvasViewMode, currentSessionId, activePane } = opts;
-
-  const isStackLayout = computed(() => canvasViewMode.value !== CANVAS_VIEW.single);
-
-  const lastChatViewMode = ref<ChatViewMode>(isChatView(canvasViewMode.value) ? canvasViewMode.value : CANVAS_VIEW.stack);
-
-  watch(canvasViewMode, (mode) => {
-    if (isChatView(mode)) lastChatViewMode.value = mode;
-  });
+  const { layoutMode, isChatPage, currentSessionId, activePane } = opts;
 
-  function restoreChatViewForSession(): void {
-    if (!isChatView(canvasViewMode.value)) {
-      setCanvasViewMode(lastChatViewMode.value);
-    }
-  }
+  const isStackLayout = computed(() => !(isChatPage.value && layoutMode.value === LAYOUT_MODES.single));
 
-  const displayedCurrentSessionId = computed(() => (isChatView(canvasViewMode.value) ? currentSessionId.value : ""));
+  const displayedCurrentSessionId = computed(() => (isChatPage.value ? currentSessionId.value : ""));
 
-  // Keep arrow-key navigation tied to the canvas when the sidebar
-  // list doesn't exist (Stack layout has no ToolResultsPanel).
   watch(
     isStackLayout,
     (stack) => {
@@ -49,7 +36,6 @@ export function useViewLayout(opts: {
 
   return {
     isStackLayout,
-    restoreChatViewForSession,
     displayedCurrentSessionId,
   };
 }