@@ -1,6 +1,7 @@
 ---
 '@objectstack/spec': patch
 '@objectstack/rest': patch
+'@object-ui/console': patch
 ---
 
 Clause-②: no
@@ -12,5 +13,6 @@ When two books split one package's docs, for example a user manual and an admin
 
 - **`resolveBookTree(book, docs, bookPackage?, books?)`** takes an optional fourth argument, every registered book. With it, the *Uncategorized* group holds only the docs of the book's packages that no book claims. The claim judge is `resolveBookClaimedDocs` over each book, the same claim set `resolveDocAudiences` unions audiences over. Without it, the tree is the same as before.
 - **`GET /meta/book/:name/tree`** passes the books it already reads, so an administrator opening the user manual no longer sees the admin pages under *Uncategorized*. A doc that no book claims still rolls up there.
+- **The console's docs pages** render the book sidebar with the console's own copy of the resolver (`book-nav.ts`). It takes the same optional fourth argument, and the reader and the book landing pass the authored books, so the sidebar no longer lists a sibling book's pages under *Uncategorized* either.
 
 The change only removes entries from the catch-all: a sibling book's docs appear nowhere new, and a doc's effective audience (§6.7) does not change.
@@ -45,12 +45,12 @@ export function DocRefusal({ name, message }: { name?: string; message?: string
 export default function BookPage() {
   const { slug, appName } = useParams<{ slug: string; appName?: string }>();
   const { t } = useObjectTranslation();
-  const { books, docs, state } = useBookData();
+  const { books, authoredBooks, docs, state } = useBookData();
 
   const found = useMemo(() => books.find((b) => bookSlug(b) === slug), [books, slug]);
   const opensTo = useMemo(
-    () => (found ? firstDoc(resolveBookTree(found, docs)) : undefined),
-    [found, docs],
+    () => (found ? firstDoc(resolveBookTree(found, docs, undefined, authoredBooks)) : undefined),
+    [found, docs, authoredBooks],
   );
 
   if (state === 'loading') {
 
@@ -158,12 +158,14 @@ export default function DocPage() {
   // reading in, so its spine renders as a persistent left nav. Resolved from
   // the portal book set; degrades to no sidebar if the slug is unknown (e.g.
   // the backend serves no books yet).
-  const { books, docs: allDocs } = useBookData();
+  const { books, authoredBooks, docs: allDocs } = useBookData();
   const base = appName ? `/apps/${appName}/docs` : '/docs';
   const resolvedBook = useMemo<ResolvedBook | null>(() => {
     const book = books.find((b) => bookSlug(b) === slug);
-    return book ? resolveBookTree(book, allDocs) : null;
-  }, [books, allDocs, slug]);
+    // Every authored book judges the Uncategorized group, so a doc a sibling
+    // book places is not listed there (objectstack#27091).
+    return book ? resolveBookTree(book, allDocs, undefined, authoredBooks) : null;
+  }, [books, authoredBooks, allDocs, slug]);
   const docHref = useCallback((docName: string) => `${base}/${slug}/${docName}`, [base, slug]);
   // A `:slug` segment that is a book's NAME rather than its slug — what a
   // `{ type: 'doc', book, doc }` navigation entry links to (objectui#11197) — is
 
@@ -0,0 +1,135 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * objectstack#27091 — a doc a SIBLING book places is not this book's orphan.
+ *
+ * ADR-0046 §6.4 rolls up only the docs "left unplaced". HotCRM ships two books
+ * over one package (hotcrm#2327): `crm_manual` and `crm_admin_manual`, the
+ * latter gated by a permission set. Every doc is claimed by exactly one book,
+ * yet each book's sidebar listed the other's pages under a trailing
+ * Uncategorized group, because "claimed" was judged against the book's own
+ * groups only. The framework's `resolveBookTree` judges against every book
+ * since objectstack#27091; this port follows it, and the docs pages pass the
+ * AUTHORED books.
+ *
+ * Each resolver case is checked against the spec's resolver over the same
+ * docs and books, the answer `GET /meta/book/:name/tree` gives.
+ */
+
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { render, screen, cleanup } from '@testing-library/react';
+import { MemoryRouter, Routes, Route } from 'react-router-dom';
+import { resolveBookTree as specResolveBookTree } from '@objectstack/spec/system';
+
+const { ADAPTER } = vi.hoisted(() => {
+  const ADAPTER = {
+    getClient: () => ({
+      meta: {
+        getItems: async () => [],
+        getItem: async (_type: string, name: string) => ({ item: { name, content: `# ${name}` } }),
+      },
+    }),
+  };
+  return { ADAPTER };
+});
+
+vi.mock('@object-ui/app-shell', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useAdapter: () => ADAPTER,
+}));
+
+vi.mock('@object-ui/i18n', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useObjectTranslation: () => ({ t: (_k: string, o?: { defaultValue?: string }) => o?.defaultValue ?? _k }),
+}));
+
+// Imported AFTER the mocks so the page picks up the mocked modules.
+import DocPage from './DocPage';
+import { BookDataContext } from './use-book-data';
+import { buildPortalBooks, resolveBookTree, type Book, type ResolvedBook, type ResolverDoc } from './book-nav';
+
+const docs: ResolverDoc[] = [
+  { name: 'crm_overview', label: 'Overview', packageId: 'crm' },
+  { name: 'crm_sales_leads', label: 'Leads', packageId: 'crm' },
+  { name: 'crm_admin_access', label: 'Access control', packageId: 'crm' },
+  { name: 'crm_admin_automation', label: 'Automation', packageId: 'crm' },
+];
+const userManual: Book = {
+  name: 'crm_manual',
+  label: 'CRM Manual',
+  packageId: 'crm',
+  groups: [
+    { key: 'start', label: 'Start', include: 'crm_overview' },
+    { key: 'sales', label: 'Sales', include: 'crm_sales_*' },
+  ],
+};
+const adminManual: Book = {
+  name: 'crm_admin_manual',
+  label: 'CRM Admin Manual',
+  packageId: 'crm',
+  groups: [{ key: 'admin', label: 'Admin', include: 'crm_admin_*' }],
+};
+const authored = [userManual, adminManual];
+
+const keysAndDocs = (r: { groups: { key: string; entries: { doc?: string }[] }[] }) =>
+  Object.fromEntries(r.groups.map((g) => [g.key, g.entries.map((e) => e.doc)]));
+
+/** What `GET /meta/book/:name/tree` answers: the spec resolver, judged by every book. */
+const specBook = (b: Book) => ({ name: b.name, label: b.label, groups: b.groups ?? [], packageId: b.packageId });
+const endpointTree = (b: Book, all: ResolverDoc[]) =>
+  specResolveBookTree(specBook(b), all, b.packageId, authored.map(specBook));
+
+afterEach(() => {
+  cleanup();
+  vi.restoreAllMocks();
+});
+
+describe('objectstack#27091 — the port: a sibling book\'s pages are not Uncategorized', () => {
+  it('HotCRM\'s two books: neither tree has an Uncategorized group, and the spec agrees', () => {
+    const user: ResolvedBook = resolveBookTree(userManual, docs, undefined, authored);
+    expect(keysAndDocs(user)).toEqual({ start: ['crm_overview'], sales: ['crm_sales_leads'] });
+    expect(keysAndDocs(resolveBookTree(adminManual, docs, undefined, authored))).toEqual({
+      admin: ['crm_admin_access', 'crm_admin_automation'],
+    });
+    for (const b of authored) {
+      expect(keysAndDocs(resolveBookTree(b, docs, undefined, authored))).toEqual(keysAndDocs(endpointTree(b, docs)));
+    }
+  });
+
+  it('a doc NO book claims still rolls up under Uncategorized', () => {
+    const withStray = [...docs, { name: 'crm_stray', label: 'Stray', packageId: 'crm' }];
+    expect(keysAndDocs(resolveBookTree(userManual, withStray, undefined, authored)).uncategorized).toEqual(['crm_stray']);
+  });
+
+  it('CONTROL: without `books` the tree is unchanged, the sibling\'s pages still in Uncategorized', () => {
+    expect(keysAndDocs(resolveBookTree(userManual, docs)).uncategorized).toEqual([
+      'crm_admin_access',
+      'crm_admin_automation',
+    ]);
+  });
+});
+
+describe('objectstack#27091 — the reader\'s sidebar for crm_manual', () => {
+  it('lists the book\'s own pages and no Uncategorized group holding the admin pages', async () => {
+    const value = { authoredBooks: authored, books: buildPortalBooks(authored, docs), docs, state: 'ready' as const };
+    render(
+      <BookDataContext.Provider value={value}>
+        <MemoryRouter initialEntries={['/docs/crm_manual/crm_overview']}>
+          <Routes>
+            <Route path="/docs/:slug/:name" element={<DocPage />} />
+          </Routes>
+        </MemoryRouter>
+      </BookDataContext.Provider>,
+    );
+    expect((await screen.findAllByRole('link', { name: 'Leads' })).length).toBeGreaterThan(0);
+    expect(screen.queryByText('Uncategorized')).toBeNull();
+    expect(screen.queryByRole('link', { name: 'Access control' })).toBeNull();
+    expect(screen.queryByRole('link', { name: 'Automation' })).toBeNull();
+  });
+});
@@ -182,8 +182,19 @@ function entryFromDoc(doc: ResolverDoc): ResolvedEntry {
 /**
  * Resolve a book spine against the current doc set into a rendered tree.
  * Faithful port of ADR-0046 §6.2.1 — see book-nav.ts header.
+ *
+ * `books` is every authored book: a doc one of them claims is placed, not
+ * "left unplaced" (§6.4), so it never lands in this book's Uncategorized
+ * group (the framework's resolver answers the same since objectstack#27091).
+ * Pass the AUTHORED books, never the portal set: its synthetic implicit
+ * per-package books (§6.4) are a reading fallback, not an authored claim.
  */
-export function resolveBookTree(book: Book, docs: ResolverDoc[], bookPackage?: string): ResolvedBook {
+export function resolveBookTree(
+  book: Book,
+  docs: ResolverDoc[],
+  bookPackage?: string,
+  books?: readonly Book[],
+): ResolvedBook {
   const scopeDefault = bookPackage ?? book.packageId;
   const groupsSorted = [...(book.groups ?? [])]
     .map((g, i) => ({ g, i }))
@@ -265,12 +276,14 @@ export function resolveBookTree(book: Book, docs: ResolverDoc[], bookPackage?: s
   // asked through `include`'s own scope test (ADR-0046 §6.4; the framework's
   // resolver answers the same since objectstack#20980). Another package's
   // unplaced doc is that package's own book's orphan, not this one's. A book
-  // that declares no package keeps every unclaimed doc.
+  // that declares no package keeps every unclaimed doc. A doc another book in
+  // `books` claims is not an orphan either.
   const ownPackages = [scopeDefault, ...groupsSorted.map((g) => g.package)].filter(
     (p): p is string => typeof p === 'string' && p.length > 0,
   );
+  const claimedByAnyBook = books ? claimedByBooks(books, docs) : undefined;
   const orphans = docs
-    .filter((d) => !claimed.has(d.name))
+    .filter((d) => !claimed.has(d.name) && !claimedByAnyBook?.has(d.name))
     .filter((d) => ownPackages.length === 0 || ownPackages.some((p) => matchesInclude(d, '*', p)))
     .sort(byOrderThenLabel);
   if (orphans.length) {
@@ -285,6 +298,22 @@ export function resolveBookTree(book: Book, docs: ResolverDoc[], bookPackage?: s
   return { name: book.name, label: book.label, description: book.description, groups: resolvedGroups };
 }
 
+/**
+ * Every doc some book in `books` claims: the docs its authored groups place,
+ * never its synthetic Uncategorized group (the framework's
+ * `resolveBookClaimedDocs`, unioned over the books).
+ */
+function claimedByBooks(books: readonly Book[], docs: ResolverDoc[]): Set<string> {
+  const all = new Set<string>();
+  for (const book of books) {
+    for (const g of resolveBookTree(book, docs).groups) {
+      if (g.synthetic) continue;
+      for (const e of g.entries) if (e.doc) all.add(e.doc);
+    }
+  }
+  return all;
+}
+
 /**
  * Synthesize the implicit per-package book (ADR-0046 §6.4): no authored book ⇒
  * one book keyed by the package id, a single group including every doc.