@kabmo-labs/kabmo 0.7.0 → 0.9.0

package/src/client/hooks/workspace/file-tabs.test.ts

@@ -26,6 +26,8 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from 'bun:test';
 import { Window } from 'happy-dom';
 import type { h as PreactH, render as PreactRender } from 'preact';
+import type { ComponentChildren } from 'preact';
+import type { ComponentType } from 'preact/compat';
 import type { act as PreactAct } from 'preact/test-utils';
 import type { useFileTabs as UseFileTabsHook } from '@/client/hooks/workspace/file-tabs';
 import type { OpenFileInput } from '@/client/hooks/workspace/file-tabs';
@@ -44,7 +46,11 @@ const SESSION = 'new-file-tabs';
 const nativeFetch = Bun.fetch;
 
 let container: HTMLElement;
+/** The provider component, kept so a case can re-render with a different root. */
+let SessionStateProvider: ComponentType<{ sessionId: string; children: ComponentChildren }>;
 let handleOpenFile: ((file: OpenFileInput) => void) | null = null;
+/** The mounted probe, so a re-render can hand it another root. */
+let Probe: ComponentType<{ rootPath: string | null }>;
 let openedFiles: OpenedFile[] = [];
 let activeFileId: number | string | null = null;
 
@@ -56,23 +62,35 @@ async function settle() {
   }
 }
 
+/** Re-render the mounted tree with a different workspace root. */
+async function setRoot(rootPath: string | null): Promise<void> {
+  await act(async () => {
+    render(
+      h(SessionStateProvider, { sessionId: SESSION, children: h(Probe, { rootPath }) }),
+      container,
+    );
+  });
+  await settle();
+}
+
 /** Mount the hook inside the provider, with `stored` as the session's blob. */
-async function mount(stored: Record<string, unknown> = {}) {
+async function mount(stored: Record<string, unknown> = {}, root: string | null = ROOT) {
   globalThis.fetch = (async () => ({
     ok: true,
     json: async () => ({ sessionId: SESSION, state: stored }),
     text: async () => JSON.stringify({ sessionId: SESSION, state: stored }),
   })) as unknown as typeof fetch;
-  const { SessionStateProvider } = await import('@/client/components/common/session-state-provider/index');
-  const Probe = () => {
-    const tabs = useFileTabs(ROOT, SESSION);
+  const provider = await import('@/client/components/common/session-state-provider/index');
+  SessionStateProvider = provider.SessionStateProvider as typeof SessionStateProvider;
+  Probe = ({ rootPath }: { rootPath: string | null }) => {
+    const tabs = useFileTabs(rootPath, SESSION);
     handleOpenFile = tabs.handleOpenFile;
     openedFiles = tabs.openedFiles;
     activeFileId = tabs.activeFileId;
     return null;
   };
   await act(async () => {
-    render(h(SessionStateProvider, { sessionId: SESSION, children: h(Probe, {}) }), container);
+    render(h(SessionStateProvider, { sessionId: SESSION, children: h(Probe, { rootPath: root }) }), container);
   });
   await settle();
 }
@@ -147,6 +165,45 @@ describe('useFileTabs open resolution', () => {
     expect(activeFileId).toBe(fileTabId('src/a.ts'));
   });
 
+  /**
+   * A root that is not known yet must not close the tabs.
+   *
+   * `activeProjectPath` is derived from the sidebar's folder list, which is empty
+   * for a beat on every load and again whenever the structure topic
+   * re-subscribes. Treating that `null` as a root CHANGE wiped the file the user
+   * had just clicked, and the editor drew "Select a file to open" over it — the
+   * rare e2e failure this pins.
+   */
+  test('a transiently unknown root does not wipe the open tabs', async () => {
+    await mount();
+    await act(async () => {
+      handleOpenFile?.(explorerPayload('src/a.ts'));
+    });
+    await settle();
+    expect(openedFiles).toHaveLength(1);
+
+    // The folder list drops out and comes back — the same workspace.
+    await setRoot(null);
+    await setRoot(ROOT);
+
+    expect(openedFiles).toHaveLength(1);
+    expect(activeFileId).toBe('src/a.ts');
+  });
+
+  test('a DIFFERENT root closes the previous workspace’s tabs', async () => {
+    await mount();
+    await act(async () => {
+      handleOpenFile?.(explorerPayload('src/a.ts'));
+    });
+    await settle();
+    expect(openedFiles).toHaveLength(1);
+
+    await setRoot('/other');
+
+    expect(openedFiles).toHaveLength(0);
+    expect(activeFileId).toBeNull();
+  });
+
   test('reopening under the computed id activates the tab rather than adding one', async () => {
     await mount();
 

package/src/client/hooks/workspace/file-tabs.ts

@@ -52,24 +52,37 @@ export function useFileTabs(
     [sessionId],
   );
 
-  const activeRootRef = useRef<string | null | undefined>(undefined);
+  /** The last root a wipe was performed FOR; `null` until one is known. */
+  const wipedRootRef = useRef<string | null>(null);
   const { ready: layoutReady } = useSessionStateContext();
-  const wipedRootRef = useRef<string | null | undefined>(undefined);
 
   useEffect(() => {
-    if (activeRootRef.current === activeProjectPath) return;
-    activeRootRef.current = activeProjectPath;
-    if (!layoutReady || wipedRootRef.current === activeProjectPath) return;
+    // Only a CHANGE from one known root to another closes the previous
+    // workspace's tabs.
+    //
+    // Two rules, and each was a bug first. A root that is not known yet is not a
+    // root that changed: the path is derived from the sidebar's folder list,
+    // which is empty for a beat on every load (and again whenever the structure
+    // topic re-subscribes), so treating `null` as a root wiped the tabs a user
+    // had just opened. And the FIRST known root is not a change either — it is
+    // the workspace the page was already showing, so wiping on it discarded the
+    // tabs the session blob had just restored (measured: the e2e specs had to
+    // gate every tree click on the `/state` response to survive it, and a click
+    // that lost that race left the editor reading "Select a file to open" over
+    // the file the user had opened).
+    if (!activeProjectPath || !layoutReady) return;
+    const previous = wipedRootRef.current;
     wipedRootRef.current = activeProjectPath;
+    if (previous === null || previous === activeProjectPath) return;
     // The tabs are dropped, but their scroll offsets deliberately are NOT: this
-    // wipe is not a user closing a tab. It fires on every load (the root is null
-    // until the folder resolves), so dropping here erased the offset the session
-    // blob had just restored — measured: the offset persisted as `900`, and came
-    // back as `{}` after a reload. The entry is keyed by the file's path hash, so
-    // it is reused when that file is opened again, which is the point.
+    // wipe is not a user closing a tab. Dropping here erased the offset the
+    // session blob had just restored — measured: the offset persisted as `900`,
+    // and came back as `{}` after a reload. The entry is keyed by the file's
+    // path hash, so it is reused when that file is opened again, which is the
+    // point.
     setOpenedFiles([]);
     setActiveFileId(null);
-  }, [activeProjectPath, sessionId, layoutReady, setOpenedFiles, setActiveFileId]);
+  }, [activeProjectPath, layoutReady, setOpenedFiles, setActiveFileId]);
 
   const handleOpenFile = useCallback((file: OpenFileInput) => {
     const fileEntry: OpenedFile = {

package/src/client/hooks/workspace/file-tree-actions.ts

@@ -22,7 +22,7 @@ import type { FormEvent, RefObject } from 'preact/compat';
 import { useFetcher } from '@/client/lib/router/fetcher';
 import { toAbsolutePath } from '@/shared/lib/fs/paths';
 import { copyToClipboard } from '@/client/hooks/ui/clipboard';
-import { useFileCreate } from '@/client/hooks/workspace/file-create';
+import { useFileCreate, type CreatedEntry } from '@/client/hooks/workspace/file-create';
 import type { FileClipboard } from '@/client/hooks/workspace/file-clipboard';
 import type { FsActionResponse } from '@/shared/types';
 
@@ -40,7 +40,17 @@ export interface FileActionDeps {
   /** Which diff to open, when the row is a changed file. */
   diff?: { staged?: boolean; status?: string };
   onOpenFile?: (file: { path: string; name: string; root?: string; repo?: string }) => void;
+  /** Re-read the tree — a DELETE has no local answer, so it re-reads. */
   onActionComplete: () => void;
+  /**
+   * A row the panel just created, placed locally.
+   *
+   * A create answers with the whole result, so the tree inserts it rather than
+   * re-reading the root plus every open folder to learn it back.
+   */
+  onCreated?: (entry: CreatedEntry) => void;
+  /** A row the panel just renamed, moved locally — same reason as `onCreated`. */
+  onRenamed?: (fromPath: string, toPath: string) => void;
   /** The panel's clipboard: Cut/Copy fill it, Paste reads it. */
   clipboard: FileClipboard;
   /** Whether this row is a folder — what Cut/Copy/Paste need to name their target. */
@@ -56,12 +66,16 @@ export interface FileActions {
   showDeleteModal: boolean;
   showHistoryModal: boolean;
   showCreateModal: boolean;
+  /** Whether the open create dialog makes a folder. */
+  createKind: 'file' | 'folder';
   /** The server's refusal for the create request, rendered inside its dialog. */
   createError: string | null;
   createName: string;
   setCreateName: (value: string) => void;
   renameValue: string;
   setRenameValue: (value: string) => void;
+  /** The server's refusal for the rename request, rendered inside its dialog. */
+  renameError: string | null;
   /** True while a request is in flight; every dialog's buttons read it. */
   busy: boolean;
   /** Label of the row's Paste action, or null when a paste cannot land here. */
@@ -79,7 +93,7 @@ export interface FileActions {
   closeHistory: () => void;
 }
 
-export function useFileActions({ file, diff, onOpenFile, onActionComplete, clipboard, isFolder }: FileActionDeps): FileActions {
+export function useFileActions({ file, diff, onOpenFile, onActionComplete, onCreated, onRenamed, clipboard, isFolder }: FileActionDeps): FileActions {
   const actionFetcher = useFetcher<FsActionResponse>();
   const [contextMenu, setContextMenu] = useState<{ x: number; y: number } | null>(null);
   const contextMenuRef = useRef<HTMLDivElement>(null);
@@ -87,6 +101,7 @@ export function useFileActions({ file, diff, onOpenFile, onActionComplete, clipb
   const [showDeleteModal, setShowDeleteModal] = useState(false);
   const [showHistoryModal, setShowHistoryModal] = useState(false);
   const [renameValue, setRenameValue] = useState(file.path);
+  const [renameError, setRenameError] = useState<string | null>(null);
 
   const repo = file.repo;
   const rootPath = file.rootPath;
@@ -98,7 +113,10 @@ export function useFileActions({ file, diff, onOpenFile, onActionComplete, clipb
     folderPath: file.path,
     rootPath,
     repo,
-    onCreated: onActionComplete,
+    // The tree places the entry itself and does NOT reload: the response names
+    // the whole result, and re-reading the root plus every open folder to learn
+    // it back is the reload this path exists to avoid.
+    onCreated: (entry) => (onCreated ? onCreated(entry) : onActionComplete()),
     onOpenCreated: (created) => onOpenFile?.({ ...created, root: rootPath, repo: repo || '.' }),
   });
 
@@ -124,7 +142,15 @@ export function useFileActions({ file, diff, onOpenFile, onActionComplete, clipb
     if (data.success && !data.type) {
       setShowRenameModal(false);
       setShowDeleteModal(false);
-      onActionComplete();
+      setRenameError(null);
+      // A rename response names both ends, so the tree moves the row locally
+      // instead of re-reading every open folder to discover the move.
+      if (data.previousPath && data.path && onRenamed) onRenamed(data.previousPath, data.path);
+      else onActionComplete();
+    } else if (!data.success && data.error && showRenameModal) {
+      // A refusal keeps the dialog open with the server's own words beside the
+      // field: "already exists" is a message about what to type next.
+      setRenameError(data.error);
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [actionFetcher.state, actionFetcher.data]);
@@ -155,6 +181,7 @@ export function useFileActions({ file, diff, onOpenFile, onActionComplete, clipb
 
   const handleAction = (actionType: string) => {
     setContextMenu(null);
+    setRenameError(null);
     if (actionType === 'view') {
       openFile();
     } else if (actionType === 'diff') {
@@ -186,7 +213,9 @@ export function useFileActions({ file, diff, onOpenFile, onActionComplete, clipb
       setRenameValue(file.path);
       setShowRenameModal(true);
     } else if (actionType === 'new_file') {
-      create.openDialog();
+      create.openDialog('file');
+    } else if (actionType === 'new_folder') {
+      create.openDialog('folder');
     } else if (actionType === 'delete') {
       setShowDeleteModal(true);
     } else if (actionType === 'cut') {
@@ -202,6 +231,7 @@ export function useFileActions({ file, diff, onOpenFile, onActionComplete, clipb
 
   const submitRename = (e: FormEvent) => {
     e.preventDefault();
+    setRenameError(null);
     const fd = new FormData();
     fd.append('actionType', 'rename');
     fd.append('path', file.path);
@@ -225,11 +255,13 @@ export function useFileActions({ file, diff, onOpenFile, onActionComplete, clipb
     showDeleteModal,
     showHistoryModal,
     showCreateModal: create.open,
+    createKind: create.kind,
     createError: create.error,
     createName: create.name,
     setCreateName: create.setName,
     renameValue,
     setRenameValue,
+    renameError,
     busy: actionFetcher.state !== 'idle' || create.busy || clipboard.busy,
     pasteLabel,
     fetcherState: actionFetcher.state,

package/src/client/hooks/workspace/navbar-session-actions.ts

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The navbar's session menu, resolved from the session ON SCREEN.
+ *
+ * A hook rather than three statements in the layout because the lookup has a
+ * rule of its own: the session's row may live in a folder that is not expanded
+ * in the sidebar (or not visible at all), so it is found by id across every
+ * folder instead of by walking the visible list. No row means no menu — a
+ * session the sidebar does not know (a chat running outside every registered
+ * workspace) gets nothing rather than dead items.
+ *
+ * The pending `new-…` refusal lives here too: such a chat has no transcript
+ * anywhere yet, so the server refuses rename and delete, and the menu hides
+ * them the way the sidebar does.
+ */
+
+import { useMemo } from 'preact/hooks';
+import { useSidebarData } from '@/client/hooks/chat/omp/session-list';
+import { useSessionActions } from '@/client/hooks/workspace/session-actions';
+import { useSessionDelete, type SessionDeleteActions } from '@/client/hooks/workspace/session-delete';
+import type { WorkspaceFolderData } from '@/shared/types';
+
+/** What `TopNavbar` needs to draw its title menu. */
+export interface NavbarSessionMenu {
+  isArchived: boolean;
+  onRename?: (name: string) => void;
+  onRenameWithAi?: () => void;
+  onArchive: () => void;
+  onDelete?: () => void;
+}
+
+export interface NavbarSessionActions {
+  menu: NavbarSessionMenu | undefined;
+  /** The delete confirmation's own state machine, which the layout renders. */
+  sessionDelete: SessionDeleteActions;
+}
+
+export function useNavbarSessionActions(
+  folders: WorkspaceFolderData[],
+  sessionId: string | null,
+  report: (message: string, tone?: 'success' | 'error') => void,
+): NavbarSessionActions {
+  const sidebar = useSidebarData();
+  const actions = useSessionActions(sidebar.refresh, report);
+  const sessionDelete = useSessionDelete();
+
+  const activeSession = useMemo(() => {
+    if (!sessionId) return null;
+    for (const folder of folders) {
+      const found = (folder.sessions || []).find((s) => String(s.id) === String(sessionId));
+      if (found) return found;
+    }
+    return null;
+  }, [folders, sessionId]);
+
+  const pending = Boolean(sessionId && sessionId.startsWith('new-'));
+  const menu: NavbarSessionMenu | undefined = activeSession
+    ? {
+        isArchived: activeSession.is_archived === 1,
+        onRename: pending ? undefined : (name: string) => void actions.handleRename(activeSession, name),
+        onRenameWithAi: pending ? undefined : () => void actions.handleRenameWithAi(activeSession),
+        onArchive: () => actions.handleArchive(activeSession),
+        onDelete: pending ? undefined : () => sessionDelete.requestDelete(activeSession),
+      }
+    : undefined;
+
+  return { menu, sessionDelete };
+}

package/src/client/hooks/workspace/worktree/index.ts

@@ -0,0 +1,165 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Client state for the worktree surfaces: the list, creation and removal.
+ *
+ * One module for all three because they share the same two facts — the project
+ * the request is scoped to and the failure shape the server answers with — and
+ * splitting them would put the fetch envelope in three places.
+ *
+ * Nothing here invents a path: the server resolves the destination from the
+ * dialog's NAME and reports back what it used, so the client cannot name a
+ * directory outside the project.
+ */
+
+import { useCallback, useEffect, useState } from 'preact/hooks';
+import type { WorktreeFailure, WorktreeInfo, WorktreeListPayload, WorktreeValidation } from '@/shared/lib/workspace/worktree/types';
+
+export interface WorktreeRequestScope {
+  /** The project's `project_path`, sent as `?root=`. */
+  root: string | null;
+  /** Sent as `?folderId=` so an unbound-but-valid folder still resolves. */
+  folderId?: number | string | null;
+}
+
+function queryFor(scope: WorktreeRequestScope): string {
+  const params = new URLSearchParams();
+  if (scope.root) params.set('root', scope.root);
+  if (scope.folderId !== null && scope.folderId !== undefined) params.set('folderId', String(scope.folderId));
+  const query = params.toString();
+  return query ? `?${query}` : '';
+}
+
+/** A refusal the UI reports verbatim; `field` marks the input that caused it. */
+export class WorktreeRequestError extends Error {
+  readonly failure: WorktreeFailure;
+
+  constructor(failure: WorktreeFailure) {
+    super(failure.message);
+    this.name = 'WorktreeRequestError';
+    this.failure = failure;
+  }
+}
+
+async function readFailure(response: Response): Promise<never> {
+  const body = (await response.json().catch(() => null)) as (WorktreeFailure & { error?: string }) | null;
+  throw new WorktreeRequestError({
+    code: body?.code ?? 'create_failed',
+    message: body?.message ?? body?.error ?? `HTTP ${response.status}`,
+    ...(body?.field ? { field: body.field } : {}),
+    ...(body?.count !== undefined ? { count: body.count } : {}),
+  });
+}
+
+/** The project's worktrees, with the facts each row shows. */
+export function useWorktrees(scope: WorktreeRequestScope, enabled: boolean) {
+  const [payload, setPayload] = useState<WorktreeListPayload | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [failure, setFailure] = useState<WorktreeFailure | null>(null);
+
+  const refresh = useCallback(async () => {
+    if (!enabled) return;
+    setLoading(true);
+    try {
+      const response = await fetch(`/api/worktrees${queryFor(scope)}`);
+      if (!response.ok) await readFailure(response);
+      setPayload((await response.json()) as WorktreeListPayload);
+      setFailure(null);
+    } catch (cause) {
+      // Kept apart from the payload: an empty list and a failed read are
+      // different answers, and only one of them means nothing is there. The
+      // CODE travels too, because "this folder is not a repository" and "git
+      // could not answer" are different states to draw — and the first one is
+      // how a caller knows to offer no worktree control at all.
+      setFailure(
+        cause instanceof WorktreeRequestError
+          ? cause.failure
+          : { code: 'create_failed', message: cause instanceof Error ? cause.message : String(cause) },
+      );
+    } finally {
+      setLoading(false);
+    }
+  }, [enabled, scope.root, scope.folderId]);
+
+  useEffect(() => {
+    void refresh();
+  }, [refresh]);
+
+  return {
+    payload,
+    worktrees: payload?.worktrees ?? ([] as WorktreeInfo[]),
+    /**
+     * Whether the project is a git repository at all. `null` while it is still
+     * unknown: a caller that draws a worktree control must wait for the answer
+     * rather than offer one a plain folder can never satisfy.
+     */
+    isRepo: payload ? payload.isRepo : null,
+    /** The resolved parent directory a create would use. */
+    base: payload?.base ?? '',
+    loading,
+    failure,
+    /** The failure's message, for the surfaces that only print one. */
+    error: failure?.message ?? null,
+    refresh,
+  };
+}
+
+export interface CreateWorktreeRequest {
+  mode: 'new' | 'existing';
+  branch?: string;
+  worktreeName?: string;
+  startRef?: string;
+}
+
+/** The plan a create would use, without creating anything. */
+export async function validateWorktree(
+  scope: WorktreeRequestScope,
+  request: CreateWorktreeRequest,
+): Promise<WorktreeValidation> {
+  const response = await fetch(`/api/worktrees/validate${queryFor(scope)}`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(request),
+  });
+  const body = (await response.json().catch(() => null)) as WorktreeValidation | null;
+  if (!body) return { ok: false, failures: [{ code: 'create_failed', message: `HTTP ${response.status}` }] };
+  return body;
+}
+
+export async function createWorktree(
+  scope: WorktreeRequestScope,
+  request: CreateWorktreeRequest,
+): Promise<WorktreeInfo> {
+  const response = await fetch(`/api/worktrees${queryFor(scope)}`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(request),
+  });
+  if (!response.ok) await readFailure(response);
+  const body = (await response.json()) as { worktree: WorktreeInfo };
+  return body.worktree;
+}
+
+export interface RemoveWorktreeResult {
+  removed: true;
+  archived: string[];
+  branchDeleted: boolean;
+  branchKept: boolean;
+}
+
+export async function removeWorktree(
+  scope: WorktreeRequestScope,
+  worktreePath: string,
+  options: { deleteBranch?: boolean } = {},
+): Promise<RemoveWorktreeResult> {
+  const response = await fetch(`/api/worktrees${queryFor(scope)}`, {
+    method: 'DELETE',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ path: worktreePath, deleteBranch: options.deleteBranch === true }),
+  });
+  if (!response.ok) await readFailure(response);
+  return (await response.json()) as RemoveWorktreeResult;
+}

package/src/client/lib/desktop/bridge.ts

@@ -30,6 +30,14 @@
 export interface DesktopInfo {
   platform: string;
   shellVersion: string;
+  /**
+   * The machine's architecture, in the canonical vocabulary (`arm64` / `x64`).
+   *
+   * Every desktop artifact is per-architecture, so without this the console can
+   * only offer the release page. Absent on a shell too old to report it, which
+   * degrades the offer to that page rather than breaking it.
+   */
+  arch?: string;
   /** True when the shell hides the native title bar and the page draws it. */
   overlayTitlebar: boolean;
   /**
@@ -156,3 +164,40 @@ export function windowToggleMaximize(): Promise<void> {
 export function windowClose(): Promise<void> {
   return call<void>('window_close');
 }
+
+/**
+ * What the shell did with an update it was handed.
+ *
+ * The shell owns the whole run — download, verify, replace, relaunch — because
+ * only it can do any of those things: a page cannot replace the executable it is
+ * running inside, and a page's "download" leaves a file in a folder the user has
+ * to find. This is the report it sends back.
+ *
+ * `relaunching` is the honest terminal state on success: the shell is about to
+ * quit, so a caller that keeps a spinner going is describing a page that is
+ * already gone.
+ */
+export interface ShellUpdateOutcome {
+  success: boolean;
+  /** The version the shell installed, when it could read one. */
+  version?: string | null;
+  /** A sentence for the user — the shell's own, never a generic failure. */
+  message: string;
+  relaunching?: boolean;
+}
+
+/**
+ * Ask the shell to install the build it just offered.
+ *
+ * `url` and `version` are the console's answer, passed through rather than
+ * re-derived: the shell has no release list of its own, and asking it to fetch
+ * one would be a second reader of the same GitHub endpoint.
+ *
+ * The shell VERIFIES the bytes before installing them (the platform's own check —
+ * a code signature, an archive shape, a version floor). A console that is
+ * compromised can therefore make the shell download, but not make it run
+ * something the platform will not vouch for.
+ */
+export function applyShellUpdate(url: string, version: string): Promise<ShellUpdateOutcome> {
+  return call<ShellUpdateOutcome>('update_apply', { url, version });
+}

package/src/client/lib/search-reveal.ts

@@ -23,7 +23,7 @@
  * editor can decide by equality whether the request is for the file it holds.
  */
 
-import type { FindOptions } from '@/shared/lib/code/editor/find';
+import type { FindOptions } from '@/shared/lib/code/editor/find-scan';
 
 export interface SearchRevealRequest {
   /** Workspace-relative path of the file the match lives in. */

package/src/client/main.tsx

@@ -1,6 +1,7 @@
 import { hydrate } from 'preact';
 import { App } from '@/client/App';
 import { bootSyntax } from '@/shared/lib/code/highlighter';
+import { warmSyntaxTokenizers } from '@/shared/lib/code/highlighter-warmup';
 import { primeKabmoSettings } from '@/shared/lib/settings/client';
 import { initDocumentTheme } from '@/client/hooks/ui/theme';
 import { primeWindowChrome } from '@/client/hooks/ui/window-chrome';
@@ -70,7 +71,10 @@ installFileLaunchHandler((result) => {
 });
 
 // Fire-and-forget: warms the Shiki highlighter in parallel with hydration.
-bootSyntax();
+// Once the eager grammars land, each is tokenized once on a tiny sample during
+// idle time — loading a grammar is not compiling it, and the compile used to be
+// paid inside the first tool card the reader expanded.
+void bootSyntax().then(() => warmSyntaxTokenizers());
 
 if (root) {
   hydrate(