@nextclaw/ui 0.20.1 → 0.20.3

package/src/shared/components/doc-browser/hooks/use-doc-browser-scroll-restoration.ts

@@ -1,126 +1,22 @@
-import { useCallback, useEffect, useRef, type RefObject } from 'react';
-import { PANEL_APP_SCROLL_RESTORATION_CONTRACT } from '@nextclaw/shared';
+import type { RefObject } from 'react';
 import type { DocBrowserTab } from '@/shared/components/doc-browser/doc-browser-context';
-
-type ScrollTarget =
-  | { kind: 'document' }
-  | { kind: 'element'; path: Array<{ index: number; tagName: string }> };
-
-type ScrollPosition = {
-  currentUrl: string;
-  target: ScrollTarget;
-  x: number;
-  y: number;
-};
+import { usePanelAppScrollRestoration } from '@/shared/hooks/use-panel-app-scroll-restoration';
 
 type UseDocBrowserScrollRestorationParams = {
   currentTab?: DocBrowserTab;
-  iframeRef: RefObject<HTMLIFrameElement | null>;
+  iframeRef: RefObject<HTMLIFrameElement>;
   isEnabled: boolean;
-  tabs: DocBrowserTab[];
 };
 
-function isScrollTarget(value: unknown): value is ScrollTarget {
-  if (!value || typeof value !== 'object') {
-    return false;
-  }
-  const candidate = value as Partial<ScrollTarget>;
-  if (candidate.kind === 'document') {
-    return true;
-  }
-  return candidate.kind === 'element'
-    && Array.isArray(candidate.path)
-    && candidate.path.length > 0
-    && candidate.path.length <= 30
-    && candidate.path.every((segment) => (
-      typeof segment?.index === 'number'
-      && Number.isInteger(segment.index)
-      && segment.index >= 0
-      && segment.index <= 1000
-      && typeof segment.tagName === 'string'
-      && segment.tagName.length > 0
-      && segment.tagName.length <= 32
-    ));
-}
-
-function isScrollMessage(value: unknown): value is {
-  target: ScrollTarget;
-  type: string;
-  version: number;
-  x: number;
-  y: number;
-} {
-  if (!value || typeof value !== 'object') {
-    return false;
-  }
-  const candidate = value as Partial<{
-    target: unknown;
-    type: string;
-    version: number;
-    x: number;
-    y: number;
-  }>;
-  return candidate.type === PANEL_APP_SCROLL_RESTORATION_CONTRACT.scrollMessageType
-    && candidate.version === PANEL_APP_SCROLL_RESTORATION_CONTRACT.version
-    && isScrollTarget(candidate.target)
-    && typeof candidate.x === 'number'
-    && Number.isFinite(candidate.x)
-    && candidate.x >= 0
-    && typeof candidate.y === 'number'
-    && Number.isFinite(candidate.y)
-    && candidate.y >= 0;
-}
-
 export function useDocBrowserScrollRestoration({
   currentTab,
   iframeRef,
   isEnabled,
-  tabs,
 }: UseDocBrowserScrollRestorationParams) {
-  const positionsRef = useRef(new Map<string, ScrollPosition>());
-
-  useEffect(() => {
-    const activeTabIds = new Set(tabs.map((tab) => tab.id));
-    for (const tabId of positionsRef.current.keys()) {
-      if (!activeTabIds.has(tabId)) {
-        positionsRef.current.delete(tabId);
-      }
-    }
-  }, [tabs]);
-
-  useEffect(() => {
-    if (!currentTab || !isEnabled) {
-      return;
-    }
-    const onMessage = (event: MessageEvent) => {
-      if (event.source !== iframeRef.current?.contentWindow || !isScrollMessage(event.data)) {
-        return;
-      }
-      positionsRef.current.set(currentTab.id, {
-        currentUrl: currentTab.currentUrl,
-        target: event.data.target,
-        x: event.data.x,
-        y: event.data.y,
-      });
-    };
-    window.addEventListener('message', onMessage);
-    return () => window.removeEventListener('message', onMessage);
-  }, [currentTab, iframeRef, isEnabled]);
-
-  return useCallback(() => {
-    if (!currentTab || !isEnabled) {
-      return;
-    }
-    const position = positionsRef.current.get(currentTab.id);
-    if (!position || position.currentUrl !== currentTab.currentUrl) {
-      return;
-    }
-    iframeRef.current?.contentWindow?.postMessage({
-      type: PANEL_APP_SCROLL_RESTORATION_CONTRACT.restoreScrollMessageType,
-      version: PANEL_APP_SCROLL_RESTORATION_CONTRACT.version,
-      target: position.target,
-      x: position.x,
-      y: position.y,
-    }, '*');
-  }, [currentTab, iframeRef, isEnabled]);
+  return usePanelAppScrollRestoration({
+    currentUrl: currentTab?.currentUrl ?? null,
+    iframeRef,
+    isEnabled,
+    restorationKey: currentTab ? `panel-app:doc-browser:${currentTab.id}` : null,
+  });
 }

package/src/shared/components/ui/actions/icon-action-button.tsx

@@ -75,14 +75,7 @@ const IconActionButton = React.forwardRef<HTMLButtonElement, IconActionButtonPro
     return (
       <TooltipProvider delayDuration={250}>
         <Tooltip disableHoverableContent>
-          <TooltipTrigger
-            asChild
-            onFocus={(event) => {
-              if (!event.currentTarget.matches(':focus-visible')) {
-                event.preventDefault();
-              }
-            }}
-          >
+          <TooltipTrigger asChild>
             {disabled ? <span className="inline-flex">{button}</span> : button}
           </TooltipTrigger>
           <TooltipContent side={tooltipSide} className="text-xs">{content}</TooltipContent>

package/src/shared/components/ui/tooltip.tsx

@@ -7,7 +7,22 @@ const TooltipProvider = TooltipPrimitive.Provider;
 
 const Tooltip = TooltipPrimitive.Root;
 
-const TooltipTrigger = TooltipPrimitive.Trigger;
+const TooltipTrigger = React.forwardRef<
+    React.ElementRef<typeof TooltipPrimitive.Trigger>,
+    React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Trigger>
+>(({ onFocus, ...props }, ref) => (
+    <TooltipPrimitive.Trigger
+        ref={ref}
+        onFocus={(event) => {
+            onFocus?.(event);
+            if (!event.defaultPrevented && !event.currentTarget.matches(':focus-visible')) {
+                event.preventDefault();
+            }
+        }}
+        {...props}
+    />
+));
+TooltipTrigger.displayName = TooltipPrimitive.Trigger.displayName;
 
 const TooltipContent = React.forwardRef<
     React.ElementRef<typeof TooltipPrimitive.Content>,

package/src/shared/hooks/use-config.ts

@@ -19,6 +19,7 @@ import {
   updateChannel,
   updateRuntime,
   updateProductAnalytics,
+  fetchProductAnalyticsStatus,
   updateSecrets,
   executeConfigAction
 } from '@/shared/lib/api';
@@ -43,6 +44,15 @@ export function useConfigMeta() {
   });
 }
 
+export function useProductAnalyticsStatus() {
+  return useQuery({
+    queryKey: ['product-analytics-status'],
+    queryFn: fetchProductAnalyticsStatus,
+    staleTime: 15_000,
+    refetchOnWindowFocus: true
+  });
+}
+
 export function useProviders() {
   return useQuery({
     queryKey: ['providers'],
@@ -108,6 +118,7 @@ export function useUpdateProductAnalytics() {
       queryClient.setQueryData<ConfigView>(['config'], (current) => current
         ? { ...current, productAnalytics }
         : current);
+      queryClient.invalidateQueries({ queryKey: ['product-analytics-status'] });
       toast.success(t('configSavedApplied'));
     },
     onError: (error: Error) => {

package/src/shared/hooks/use-panel-app-scroll-restoration.test.tsx

@@ -0,0 +1,66 @@
+import { fireEvent, render } from "@testing-library/react";
+import { useRef } from "react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { PANEL_APP_SCROLL_RESTORATION_CONTRACT } from "@nextclaw/shared";
+import { usePanelAppScrollRestoration } from "@/shared/hooks/use-panel-app-scroll-restoration";
+import { scrollRestorationManager } from "@/shared/lib/navigation-history";
+
+function PanelAppFrame({ currentUrl = "/app", restorationKey = "panel-app:test" }: {
+  currentUrl?: string;
+  restorationKey?: string;
+}) {
+  const iframeRef = useRef<HTMLIFrameElement>(null);
+  const restoreScroll = usePanelAppScrollRestoration({
+    currentUrl,
+    iframeRef,
+    isEnabled: true,
+    restorationKey,
+  });
+  return <iframe ref={iframeRef} data-testid="panel-app-frame" onLoad={restoreScroll} />;
+}
+
+describe("usePanelAppScrollRestoration", () => {
+  beforeEach(() => scrollRestorationManager.clear());
+
+  it("records only scroll messages from its iframe and restores them after load", () => {
+    const { getByTestId } = render(<PanelAppFrame />);
+    const iframe = getByTestId("panel-app-frame") as HTMLIFrameElement;
+    const postMessage = vi.spyOn(iframe.contentWindow!, "postMessage");
+    const target = { kind: "document" } as const;
+
+    window.dispatchEvent(new MessageEvent("message", {
+      data: {
+        type: PANEL_APP_SCROLL_RESTORATION_CONTRACT.scrollMessageType,
+        version: PANEL_APP_SCROLL_RESTORATION_CONTRACT.version,
+        target,
+        x: 8,
+        y: 64,
+      },
+      source: iframe.contentWindow,
+    }));
+    fireEvent.load(iframe);
+
+    expect(postMessage).toHaveBeenCalledWith({
+      type: PANEL_APP_SCROLL_RESTORATION_CONTRACT.restoreScrollMessageType,
+      version: PANEL_APP_SCROLL_RESTORATION_CONTRACT.version,
+      target,
+      x: 8,
+      y: 64,
+    }, "*");
+  });
+
+  it("does not restore a position from another resource URL", () => {
+    scrollRestorationManager.save("panel-app:test", {
+      x: 0,
+      y: 64,
+      payload: { currentUrl: "/old-app", target: { kind: "document" } },
+    });
+    const { getByTestId } = render(<PanelAppFrame currentUrl="/new-app" />);
+    const iframe = getByTestId("panel-app-frame") as HTMLIFrameElement;
+    const postMessage = vi.spyOn(iframe.contentWindow!, "postMessage");
+
+    fireEvent.load(iframe);
+
+    expect(postMessage).not.toHaveBeenCalled();
+  });
+});

package/src/shared/hooks/use-panel-app-scroll-restoration.ts

@@ -0,0 +1,107 @@
+import { useCallback, useEffect, type RefObject } from "react";
+import { PANEL_APP_SCROLL_RESTORATION_CONTRACT } from "@nextclaw/shared";
+import { scrollRestorationManager } from "@/shared/lib/navigation-history";
+
+type ScrollTarget =
+  | { kind: "document" }
+  | { kind: "element"; path: Array<{ index: number; tagName: string }> };
+
+type PanelAppScrollSnapshot = {
+  currentUrl: string;
+  target: ScrollTarget;
+};
+
+type UsePanelAppScrollRestorationParams = {
+  currentUrl: string | null;
+  iframeRef: RefObject<HTMLIFrameElement>;
+  isEnabled: boolean;
+  restorationKey: string | null;
+};
+
+function isScrollTarget(value: unknown): value is ScrollTarget {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Partial<ScrollTarget>;
+  if (candidate.kind === "document") return true;
+  return candidate.kind === "element"
+    && Array.isArray(candidate.path)
+    && candidate.path.length > 0
+    && candidate.path.length <= 30
+    && candidate.path.every((segment) => (
+      typeof segment?.index === "number"
+      && Number.isInteger(segment.index)
+      && segment.index >= 0
+      && segment.index <= 1000
+      && typeof segment.tagName === "string"
+      && segment.tagName.length > 0
+      && segment.tagName.length <= 32
+    ));
+}
+
+function isPanelAppScrollSnapshot(value: unknown): value is PanelAppScrollSnapshot {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Partial<PanelAppScrollSnapshot>;
+  return typeof candidate.currentUrl === "string" && isScrollTarget(candidate.target);
+}
+
+function isScrollMessage(value: unknown): value is {
+  target: ScrollTarget;
+  x: number;
+  y: number;
+} {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Partial<{
+    target: unknown;
+    type: string;
+    version: number;
+    x: number;
+    y: number;
+  }>;
+  return candidate.type === PANEL_APP_SCROLL_RESTORATION_CONTRACT.scrollMessageType
+    && candidate.version === PANEL_APP_SCROLL_RESTORATION_CONTRACT.version
+    && isScrollTarget(candidate.target)
+    && typeof candidate.x === "number"
+    && Number.isFinite(candidate.x)
+    && candidate.x >= 0
+    && typeof candidate.y === "number"
+    && Number.isFinite(candidate.y)
+    && candidate.y >= 0;
+}
+
+/** Bridges the Panel App iframe scroll protocol to the shared navigation history. */
+export function usePanelAppScrollRestoration({
+  currentUrl,
+  iframeRef,
+  isEnabled,
+  restorationKey,
+}: UsePanelAppScrollRestorationParams) {
+  useEffect(() => {
+    if (!currentUrl || !isEnabled || !restorationKey) return;
+    const onMessage = (event: MessageEvent) => {
+      if (event.source !== iframeRef.current?.contentWindow || !isScrollMessage(event.data)) {
+        return;
+      }
+      scrollRestorationManager.save(restorationKey, {
+        x: event.data.x,
+        y: event.data.y,
+        payload: { currentUrl, target: event.data.target } satisfies PanelAppScrollSnapshot,
+      });
+    };
+    window.addEventListener("message", onMessage);
+    return () => window.removeEventListener("message", onMessage);
+  }, [currentUrl, iframeRef, isEnabled, restorationKey]);
+
+  return useCallback(() => {
+    if (!currentUrl || !isEnabled || !restorationKey) return;
+    const position = scrollRestorationManager.read(restorationKey);
+    if (!position || !isPanelAppScrollSnapshot(position.payload) || position.payload.currentUrl !== currentUrl) {
+      return;
+    }
+    iframeRef.current?.contentWindow?.postMessage({
+      type: PANEL_APP_SCROLL_RESTORATION_CONTRACT.restoreScrollMessageType,
+      version: PANEL_APP_SCROLL_RESTORATION_CONTRACT.version,
+      target: position.payload.target,
+      x: position.x,
+      y: position.y,
+    }, "*");
+  }, [currentUrl, iframeRef, isEnabled, restorationKey]);
+}

package/src/shared/hooks/use-scroll-restoration.test.tsx

@@ -0,0 +1,62 @@
+import { fireEvent, render } from "@testing-library/react";
+import { beforeEach, describe, expect, it } from "vitest";
+import { useScrollRestoration } from "@/shared/hooks/use-scroll-restoration";
+import { scrollRestorationManager } from "@/shared/lib/navigation-history";
+
+function ScrollSurface({ restorationKey }: { restorationKey: string }) {
+  const scrollRestoration = useScrollRestoration<HTMLDivElement>({ restorationKey });
+  const { onScroll, scrollRef } = scrollRestoration;
+  return (
+    <div
+      ref={scrollRef}
+      data-testid="scroll-surface"
+      onScroll={onScroll}
+    />
+  );
+}
+
+describe("useScrollRestoration", () => {
+  beforeEach(() => scrollRestorationManager.clear());
+
+  it("restores an existing position during layout and saves scroll events", () => {
+    scrollRestorationManager.save("page:first", { x: 16, y: 48 });
+    const { getByTestId } = render(<ScrollSurface restorationKey="page:first" />);
+    const surface = getByTestId("scroll-surface") as HTMLDivElement;
+
+    expect(surface.scrollLeft).toBe(16);
+    expect(surface.scrollTop).toBe(48);
+
+    surface.scrollLeft = 24;
+    surface.scrollTop = 72;
+    fireEvent.scroll(surface);
+
+    expect(scrollRestorationManager.read("page:first")).toEqual({ x: 24, y: 72 });
+  });
+
+  it("saves the previous key and restores the next key when navigation changes", () => {
+    scrollRestorationManager.save("page:second", { x: 0, y: 96 });
+    const view = render(<ScrollSurface restorationKey="page:first" />);
+    const surface = view.getByTestId("scroll-surface") as HTMLDivElement;
+    surface.scrollTop = 32;
+    fireEvent.scroll(surface);
+
+    view.rerender(<ScrollSurface restorationKey="page:second" />);
+
+    expect(scrollRestorationManager.read("page:first")).toEqual({ x: 0, y: 32 });
+    expect(surface.scrollTop).toBe(96);
+  });
+
+  it("keeps the last scroll event when React resets the element during navigation", () => {
+    const view = render(<ScrollSurface restorationKey="page:first" />);
+    const surface = view.getByTestId("scroll-surface") as HTMLDivElement;
+    surface.scrollTop = 144;
+    fireEvent.scroll(surface);
+
+    // Switching the content can reset the DOM scroll position before the
+    // previous layout effect's cleanup runs.
+    surface.scrollTop = 0;
+    view.rerender(<ScrollSurface restorationKey="page:second" />);
+
+    expect(scrollRestorationManager.read("page:first")).toEqual({ x: 0, y: 144 });
+  });
+});

package/src/shared/hooks/use-scroll-restoration.ts

@@ -0,0 +1,61 @@
+import { useCallback, useLayoutEffect, useRef, type RefObject, type UIEvent } from "react";
+import {
+  scrollRestorationManager,
+  type ScrollRestorationPosition,
+} from "@/shared/lib/navigation-history";
+
+type UseScrollRestorationParams<T extends HTMLElement> = {
+  restorationKey: string | null;
+  scrollRef?: RefObject<T>;
+  isEnabled?: boolean;
+};
+
+/** Connects one DOM scroll surface to the shared in-memory navigation history. */
+export function useScrollRestoration<T extends HTMLElement>({
+  restorationKey,
+  scrollRef,
+  isEnabled = true,
+}: UseScrollRestorationParams<T>) {
+  const internalScrollRef = useRef<T>(null);
+  const lastKnownPositionRef = useRef<ScrollRestorationPosition | null>(null);
+  const resolvedScrollRef = scrollRef ?? internalScrollRef;
+
+  useLayoutEffect(() => {
+    if (!isEnabled || !restorationKey) return;
+    const element = resolvedScrollRef.current;
+    const position = scrollRestorationManager.read(restorationKey);
+    if (element && position) {
+      element.scrollLeft = position.x;
+      element.scrollTop = position.y;
+    }
+    if (element) {
+      lastKnownPositionRef.current = {
+        x: element.scrollLeft,
+        y: element.scrollTop,
+      };
+    }
+
+    return () => {
+      if (!element) return;
+      scrollRestorationManager.save(
+        restorationKey,
+        lastKnownPositionRef.current ?? {
+          x: element.scrollLeft,
+          y: element.scrollTop,
+        },
+      );
+    };
+  }, [isEnabled, restorationKey, resolvedScrollRef]);
+
+  const onScroll = useCallback((event: UIEvent<T>) => {
+    if (!isEnabled || !restorationKey) return;
+    const position = {
+      x: event.currentTarget.scrollLeft,
+      y: event.currentTarget.scrollTop,
+    };
+    lastKnownPositionRef.current = position;
+    scrollRestorationManager.save(restorationKey, position);
+  }, [isEnabled, restorationKey]);
+
+  return { onScroll, scrollRef: resolvedScrollRef };
+}

package/src/shared/lib/api/ncp-session-query-cache.utils.ts

@@ -149,6 +149,7 @@ export function applyNcpSessionRealtimeEvent(
   queryClient: QueryClient | undefined,
   event: Extract<WsEvent, { type: 'session.run-status' | 'session.summary.upsert' | 'session.summary.delete' }>
 ): void {
+  void queryClient?.invalidateQueries({ queryKey: ['ncp-session-pages'] });
   if (event.type === 'session.run-status') {
     updateNcpSessionRunStatusInQueryClient(queryClient, event.payload);
     return;

package/src/shared/lib/api/ncp-session.types.ts

@@ -103,6 +103,9 @@ export type NcpSessionSummaryView = NcpSessionSummary;
 export type NcpSessionsListView = {
   sessions: NcpSessionSummaryView[];
   total: number;
+  page?: number;
+  pageSize?: number;
+  hasMore?: boolean;
 };
 
 export type NcpMessageView = NcpMessage;

package/src/shared/lib/api/types.ts

@@ -488,6 +488,7 @@ export type PanelAppListView = {
   workspacePath: string;
   panelsPath: string;
   entries: PanelAppEntryView[];
+  unavailablePackages?: Array<{ appId: string; message: string }>;
 };
 
 export type PanelAppPreferencesUpdateView = {
@@ -638,6 +639,7 @@ export type SecretsConfigUpdate = {
 export type ProductAnalyticsAudience = 'external' | 'internal' | 'qa';
 
 export type ProductAnalyticsView = {
+  schemaVersion: 2;
   enabled: boolean;
   audience: ProductAnalyticsAudience;
 };
@@ -647,6 +649,13 @@ export type ProductAnalyticsConfigUpdate = {
   audience?: ProductAnalyticsAudience;
 };
 
+export type ProductAnalyticsStatusView = {
+  lastAttemptAt: string | null;
+  lastSuccessAt: string | null;
+  lastError: string | null;
+  pendingReceiptCount: number;
+};
+
 export type ChannelConfigUpdate = Record<string, unknown>;
 
 export type ConfigView = {

package/src/shared/lib/api/utils/config.utils.ts

@@ -31,6 +31,7 @@ import type {
   ProviderCreateResult,
   ProviderDeleteResult,
   ProductAnalyticsConfigUpdate,
+  ProductAnalyticsStatusView,
   ProductAnalyticsView,
   RuntimeConfigUpdate,
   SecretsConfigUpdate,
@@ -178,6 +179,10 @@ export async function updateProductAnalytics(
   return await nextclawClient.config.updateProductAnalytics(data);
 }
 
+export async function fetchProductAnalyticsStatus(): Promise<ProductAnalyticsStatusView> {
+  return await nextclawClient.config.fetchProductAnalyticsStatus();
+}
+
 export async function executeConfigAction(
   actionId: string,
   data: ConfigActionExecuteRequest

package/src/shared/lib/api/utils/ncp-session.utils.ts

@@ -14,6 +14,9 @@ import type {
 // GET /api/ncp/sessions
 export async function fetchNcpSessions(params?: {
   limit?: number;
+  page?: number;
+  pageSize?: number;
+  query?: string;
   peerId?: string;
 }): Promise<NcpSessionsListView> {
   return (await nextclawClient.sessions.list(params)) as NcpSessionsListView;

package/src/shared/lib/i18n/locales/en-US/chat.json

@@ -44,6 +44,7 @@
   "chatWorkspaceBack": "Back in workspace",
   "chatWorkspaceForward": "Forward in workspace",
   "chatWorkspaceRefreshFile": "Refresh preview",
+  "chatWorkspaceMarkdownOutline": "Document outline",
   "chatWorkspaceMaximizePanel": "Maximize workspace panel",
   "chatWorkspaceRestorePanel": "Restore workspace panel",
   "chatWorkspaceClosePanel": "Close workspace panel",
@@ -79,7 +80,7 @@
   "chatWorkspaceContinuousAttentionEmpty": "No continuous attention",
   "chatWorkspaceContinuousAttentionEmptyDescription": "The Agent has not established this type of ongoing relationship for the session.",
   "chatWorkspaceTokenUsage": "Token usage",
-  "chatWorkspaceTokenUsageDescription": "Counts this session's own AI runs. Cached input is included in input tokens; the hit rate is cached reads divided by all input.",
+  "chatWorkspaceTokenUsageDescription": "Summarizes this session's recorded Agent rounds. Cached input is included in input tokens; cache read ratio is cached reads divided by all input tokens.",
   "chatWorkspaceTokenUsageLoading": "Calculating token usage…",
   "chatWorkspaceTokenUsageLoadFailed": "Couldn’t load token usage.",
   "chatWorkspaceTokenUsageRetry": "Retry",
@@ -88,11 +89,14 @@
   "chatWorkspaceTokenUsageInput": "Input",
   "chatWorkspaceTokenUsageOutput": "Output",
   "chatWorkspaceTokenUsageCachedInput": "Cached input",
-  "chatWorkspaceTokenUsageCacheHitRate": "Cache hit rate",
-  "chatWorkspaceTokenUsageRuns": "AI runs",
+  "chatWorkspaceTokenUsageCacheHitRate": "Cache read ratio",
+  "chatWorkspaceTokenUsageRuns": "Agent rounds",
+  "chatWorkspaceTokenUsageModelCalls": "Model calls",
+  "chatWorkspaceTokenUsageReportedModelCalls": "Reported calls",
   "chatWorkspaceTokenUsageByModel": "By model",
-  "chatWorkspaceTokenUsageModelRunCount": "Runs: {count}",
-  "chatWorkspaceTokenUsageModelCacheHitRate": "Cache hit rate: {rate}",
+  "chatWorkspaceTokenUsageModelRunCount": "{count} agent rounds",
+  "chatWorkspaceTokenUsageModelCallCount": "{count} model calls",
+  "chatWorkspaceTokenUsageModelCacheHitRate": "Cache read ratio: {rate}",
   "chatWorkspaceTokenUsageReported": "Usage reported",
   "chatWorkspaceTokenUsagePartial": "Partial usage",
   "chatWorkspaceTokenUsageUnavailable": "Usage unavailable",
@@ -594,6 +598,12 @@
   "chatSidebarUnpinProject": "Unpin project",
   "chatSidebarExpandProject": "Expand project",
   "chatSidebarCollapseProject": "Collapse project",
+  "chatSidebarContextSessions": "Sessions",
+  "chatSidebarContextProject": "Project",
+  "chatSidebarContextPath": "Path",
+  "chatSidebarContextChildSessions": "Child sessions",
+  "chatSidebarContextScheduledTasks": "Scheduled tasks",
+  "chatSidebarContextNoProject": "No project",
   "chatSidebarProjectViewEmpty": "No projects yet",
   "chatBackgroundReplyFallbackTitle": "New reply",
   "chatBackgroundReplyFallbackPreview": "A reply is ready. Open the session to view it.",