diff --git a/src/.claude/settings.json b/src/.claude/settings.json
index eeec559c30d..acf37a66b69 100644
--- a/src/.claude/settings.json
+++ b/src/.claude/settings.json
@@ -1,32 +1,35 @@
 {
   "permissions": {
     "allow": [
+      "Bash(../node_modules/.bin/tsc:*)",
+      "Bash(NODE_OPTIONS=--max-old-space-size=8192 ../node_modules/.bin/tsc --noEmit)",
+      "Bash(curl:*)",
+      "Bash(docker run:*)",
       "Bash(find:*)",
       "Bash(gh pr view:*)",
       "Bash(gh:*)",
       "Bash(git add:*)",
+      "Bash(git checkout:*)",
       "Bash(git commit:*)",
+      "Bash(git push:*)",
       "Bash(grep:*)",
       "Bash(node:*)",
       "Bash(npm show:*)",
+      "Bash(npm view:*)",
       "Bash(npx tsc:*)",
       "Bash(pnpm build:*)",
+      "Bash(pnpm i18n:*)",
       "Bash(pnpm ts-build:*)",
       "Bash(pnpm tsc:*)",
       "Bash(prettier -w:*)",
+      "Bash(psql:*)",
       "WebFetch(domain:cocalc.com)",
       "WebFetch(domain:doc.cocalc.com)",
       "WebFetch(domain:docs.anthropic.com)",
       "WebFetch(domain:github.com)",
-      "Bash(git checkout:*)",
-      "Bash(git push:*)",
-      "Bash(NODE_OPTIONS=--max-old-space-size=8192 ../node_modules/.bin/tsc --noEmit)",
-      "Bash(docker run:*)",
-      "Bash(../node_modules/.bin/tsc:*)",
-      "Bash(npm view:*)",
-      "WebFetch(domain:www.anthropic.com)",
       "WebFetch(domain:mistral.ai)",
-      "Bash(pnpm i18n:*)",
+      "WebFetch(domain:www.anthropic.com)",
+      "mcp__cclsp__find_definition",
       "WebFetch(domain:simplelocalize.io)"
     ],
     "deny": []
diff --git a/src/CLAUDE.md b/src/CLAUDE.md
index 4e265a3923c..d68ea03150c 100644
--- a/src/CLAUDE.md
+++ b/src/CLAUDE.md
@@ -73,6 +73,8 @@ CoCalc is organized as a monorepo with key packages:
 - **TypeScript React Components**: All frontend code is TypeScript with proper typing
 - **Modular Store System**: Each feature has its own store/actions (AccountStore, BillingStore, etc.)
 - **WebSocket Communication**: Real-time communication with backend via WebSocket messages
+- **Authentication Waiting**: When frontend code needs to wait for user authentication, use `redux.getStore("account").async_wait({ until: () => store.get_account_id() != null, timeout: 0 })` to wait indefinitely until authentication completes
+- **Conat DKV Usage**: For key-value storage with real-time sync, use `webapp_client.conat_client.dkv({ account_id, name: "store-name" })` to get a distributed key-value store that syncs across sessions
 
 #### Backend Architecture
 
@@ -81,6 +83,8 @@ CoCalc is organized as a monorepo with key packages:
 - **Conat System**: Container orchestration for compute servers
 - **Event-Driven Architecture**: Extensive use of EventEmitter patterns
 - **Microservice-like Packages**: Each package handles specific functionality
+- **Database Access**: Use `getPool()` from `@cocalc/database/pool` for direct database queries in hub/backend code. Example: `const pool = getPool(); const { rows } = await pool.query('SELECT * FROM table WHERE id = $1', [id]);`
+- **Hub Migration Functions**: Migration functions in hub should be designed to run once at startup, use batch processing with delays between batches to avoid database saturation
 
 #### Communication Patterns
 
diff --git a/src/packages/frontend/project/page/flyouts/body.tsx b/src/packages/frontend/project/page/flyouts/body.tsx
index d71a3c2c3da..8221fe09965 100644
--- a/src/packages/frontend/project/page/flyouts/body.tsx
+++ b/src/packages/frontend/project/page/flyouts/body.tsx
@@ -14,10 +14,10 @@ import {
 } from "@cocalc/frontend/app-framework";
 import { Loading } from "@cocalc/frontend/components";
 import * as LS from "@cocalc/frontend/misc/local-storage-typed";
-import { useProjectContext } from "../../context";
+import { useProjectContext } from "@cocalc/frontend/project/context";
+import { FIXED_TABS_BG_COLOR } from "../activity-bar-tabs";
 import { FIX_BORDER } from "../common";
 import { FIXED_PROJECT_TABS, FixedTab } from "../file-tab";
-import { FIXED_TABS_BG_COLOR } from "../activity-bar-tabs";
 import { FLYOUT_PADDING } from "./consts";
 import { LSFlyout, lsKey, storeFlyoutState } from "./state";
 
@@ -56,7 +56,7 @@ export function FlyoutBody({ flyout, flyoutWidth }: FlyoutBodyProps) {
     { leading: false, trailing: true },
   );
 
-  // use this *once* around a vertically scollable content div in the component, e.g. results in a search.
+  // use this *once* around a vertically scrollable content div in the component, e.g. results in a search.
   // note: this won't work if the initial content is something else, e.g. a loading indicator.
   function wrap(content: React.ReactNode, style: CSS = {}) {
     return (
diff --git a/src/packages/frontend/project/page/flyouts/store.ts b/src/packages/frontend/project/page/flyouts/store.ts
index 26a9aaaa52f..3854ad22f47 100644
--- a/src/packages/frontend/project/page/flyouts/store.ts
+++ b/src/packages/frontend/project/page/flyouts/store.ts
@@ -3,115 +3,105 @@
  *  License: MS-RSL – see LICENSE.md for details
  */
 
-import { merge, sortBy, throttle, uniq, xor } from "lodash";
+/**
+// To debug starred files in the browser console:
+c = cc.client.conat_client
+bm = await c.dkv({account_id: cc.client.account_id, name: 'bookmark-starred-files'})
+// Check all bookmark data
+console.log('All bookmarks:', bm.getAll())
+// Check specific project bookmarks
+console.log('Project bookmarks (get):', bm.get("[project_id]"))
+// Set starred files for a project
+bm.set(project_id, ['file1.txt', 'folder/file2.md'])
+// Listen to changes
+bm.on('change', (e) => console.log('Bookmark change:', e))
+ */
+
+import { sortBy, uniq } from "lodash";
 import { useState } from "react";
 import useAsyncEffect from "use-async-effect";
 
-import api from "@cocalc/frontend/client/api";
-import { STARRED_FILES } from "@cocalc/util/consts/bookmarks";
-import {
-  GetStarredBookmarks,
-  GetStarredBookmarksPayload,
-  SetStarredBookmarks,
-} from "@cocalc/util/types/bookmarks";
-import {
-  FlyoutActiveStarred,
-  getFlyoutActiveStarred,
-  storeFlyoutState,
-} from "./state";
-
-// Additionally to local storage, we back the state of the starred files in the database.
-// Errors with the API are ignored, because we primarily rely on local storage.
-// The only really important situation to think of are when there is nothing in local storage but in the database,
-// or when there is
+import { redux } from "@cocalc/frontend/app-framework";
+import { webapp_client } from "@cocalc/frontend/webapp-client";
+import { CONAT_BOOKMARKS_KEY } from "@cocalc/util/consts/bookmarks";
+import type { FlyoutActiveStarred } from "./state";
+
+// Starred files are now managed entirely through conat with in-memory state.
+// No local storage dependency - conat handles synchronization and persistence.
 export function useStarredFilesManager(project_id: string) {
-  const [starred, setStarred] = useState<FlyoutActiveStarred>(
-    getFlyoutActiveStarred(project_id),
-  );
+  const [starred, setStarred] = useState<FlyoutActiveStarred>([]);
+  const [bookmarks, setBookmarks] = useState<any>(null);
+  const [isInitialized, setIsInitialized] = useState(false);
 
-  // once after mounting this, we update the starred bookmarks (which merges with what we have) and then stores it
+  // Initialize conat bookmarks once on mount, waiting for authentication
   useAsyncEffect(async () => {
-    await updateStarred();
+    // Wait until account is authenticated
+    const store = redux.getStore("account");
+    await store.async_wait({
+      until: () => store.get_account_id() != null,
+      timeout: 0, // indefinite timeout
+    });
+
+    const account_id = store.get_account_id();
+    await initializeConatBookmarks(account_id);
   }, []);
 
-  function setStarredLS(starred: string[]) {
-    setStarred(starred);
-    storeFlyoutState(project_id, "active", { starred: starred });
+  async function initializeConatBookmarks(account_id: string) {
+    try {
+      const conatBookmarks = await webapp_client.conat_client.dkv<string[]>({
+        account_id,
+        name: CONAT_BOOKMARKS_KEY,
+      });
+
+      setBookmarks(conatBookmarks);
+
+      // Listen for changes from other clients
+      conatBookmarks.on(
+        "change",
+        (changeEvent: { key: string; value?: string[]; prev?: string[] }) => {
+          if (changeEvent.key === project_id) {
+            const remoteStars = changeEvent.value || [];
+            setStarred(sortBy(uniq(remoteStars)));
+          }
+        },
+      );
+
+      // Load initial data from conat
+      const initialStars = conatBookmarks.get(project_id) || [];
+      if (Array.isArray(initialStars)) {
+        setStarred(sortBy(uniq(initialStars)));
+      }
+
+      setIsInitialized(true);
+    } catch (err) {
+      console.warn(`conat bookmark initialization warning -- ${err}`);
+      setIsInitialized(true); // Set initialized even on error to avoid infinite loading
+    }
   }
 
-  // TODO: there are also add/remove API endpoints, but for now we stick with set. Hardly worth optimizing.
   function setStarredPath(path: string, starState: boolean) {
+    if (!bookmarks || !isInitialized) {
+      console.warn("Conat bookmarks not yet initialized");
+      return;
+    }
+
     const next = starState
-      ? [...starred, path]
+      ? sortBy(uniq([...starred, path]))
       : starred.filter((p) => p !== path);
-    setStarredLS(next);
-    storeStarred(next);
-  }
 
-  async function storeStarred(stars: string[]) {
+    // Update local state immediately for responsive UI
+    setStarred(next);
+
+    // Store to conat (this will also trigger the change event for other clients)
     try {
-      const payload: SetStarredBookmarks = {
-        type: STARRED_FILES,
-        project_id,
-        stars,
-      };
-      await api("bookmarks/set", payload);
+      bookmarks.set(project_id, next);
     } catch (err) {
-      console.warn(`bookmark: warning -- ${err}`);
+      console.warn(`conat bookmark storage warning -- ${err}`);
+      // Revert local state on error
+      setStarred(starred);
     }
   }
 
-  // this is called once, when the flyout/tabs component is mounted
-  // throtteled, to usually take 1 sec from opening the panel to loading the stars
-  const updateStarred = throttle(
-    async () => {
-      try {
-        const payload: GetStarredBookmarksPayload = {
-          type: STARRED_FILES,
-          project_id,
-        };
-        const data: GetStarredBookmarks = await api("bookmarks/get", payload);
-
-        const { type, status } = data;
-
-        if (type !== STARRED_FILES) {
-          console.error(
-            `flyout/store/starred type must be ${STARRED_FILES} but we got`,
-            type,
-          );
-          return;
-        }
-
-        if (status === "success") {
-          const { stars } = data;
-          if (
-            Array.isArray(stars) &&
-            stars.every((x) => typeof x === "string")
-          ) {
-            stars.sort(); // sorted for the xor check below
-            const next = sortBy(uniq(merge(starred, stars)));
-            setStarredLS(next);
-            if (xor(stars, next).length > 0) {
-              // if there is a change (e.g. nothing in the database stored yet), store the stars
-              await storeStarred(next);
-            }
-          } else {
-            console.error("flyout/store/starred invalid payload", stars);
-          }
-        } else if (status === "error") {
-          const { error } = data;
-          console.error("flyout/store/starred error", error);
-        } else {
-          console.error("flyout/store/starred error: unknown status", status);
-        }
-      } catch (err) {
-        console.warn(`bookmark: warning -- ${err}`);
-      }
-    },
-    1000,
-    { trailing: true, leading: false },
-  );
-
   return {
     starred,
     setStarredPath,
diff --git a/src/packages/frontend/project/page/home-page/button.tsx b/src/packages/frontend/project/page/home-page/button.tsx
index e396f1fd736..497e2a99425 100644
--- a/src/packages/frontend/project/page/home-page/button.tsx
+++ b/src/packages/frontend/project/page/home-page/button.tsx
@@ -5,11 +5,7 @@
 
 import { Button } from "antd";
 
-import {
-  redux,
-  useActions,
-  useTypedRedux,
-} from "@cocalc/frontend/app-framework";
+import { redux, useActions } from "@cocalc/frontend/app-framework";
 import { Icon } from "@cocalc/frontend/components";
 import { getValidActivityBarOption } from "@cocalc/frontend/project/page/activity-bar";
 import { ACTIVITY_BAR_KEY } from "@cocalc/frontend/project/page/activity-bar-consts";
@@ -18,8 +14,6 @@ import { COLORS } from "@cocalc/util/theme";
 
 export default function HomePageButton({ project_id, active, width }) {
   const actions = useActions({ project_id });
-  const hideActionButtons = useTypedRedux(project_id, "hideActionButtons");
-  if (hideActionButtons) return <></>;
 
   return (
     <Button
diff --git a/src/packages/frontend/project_actions.ts b/src/packages/frontend/project_actions.ts
index c6ca0fed221..ebb8d14781c 100644
--- a/src/packages/frontend/project_actions.ts
+++ b/src/packages/frontend/project_actions.ts
@@ -3447,7 +3447,7 @@ export class ProjectActions extends Actions<ProjectStoreState> {
   }
 
   /* NOTE!  Below we store the modal state *both* in a private
-  variabel *and* in the store.  The reason is because we need
+  variable *and* in the store.  The reason is because we need
   to know it immediately after it is set in order for
   wait_until_no_modals to work robustless, and setState can
   wait before changing the state.
diff --git a/src/packages/hub/hub.ts b/src/packages/hub/hub.ts
index 5e5b84d4f1f..64bbe1056c9 100644
--- a/src/packages/hub/hub.ts
+++ b/src/packages/hub/hub.ts
@@ -11,6 +11,7 @@ import { callback } from "awaiting";
 import blocked from "blocked";
 import { spawn } from "child_process";
 import { program as commander, Option } from "commander";
+
 import basePath from "@cocalc/backend/base-path";
 import {
   pghost as DEFAULT_DB_HOST,
@@ -21,10 +22,18 @@ import { trimLogFileSize } from "@cocalc/backend/logger";
 import port from "@cocalc/backend/port";
 import { init_start_always_running_projects } from "@cocalc/database/postgres/always-running";
 import { load_server_settings_from_env } from "@cocalc/database/settings/server-settings";
+import {
+  initConatApi,
+  initConatChangefeedServer,
+  initConatPersist,
+  loadConatConfiguration,
+} from "@cocalc/server/conat";
+import { initConatServer } from "@cocalc/server/conat/socketio";
 import { init_passport } from "@cocalc/server/hub/auth";
 import { initialOnPremSetup } from "@cocalc/server/initial-onprem-setup";
 import initHandleMentions from "@cocalc/server/mentions/handle";
 import initMessageMaintenance from "@cocalc/server/messages/maintenance";
+import { start as startHubRegister } from "@cocalc/server/metrics/hub_register";
 import initProjectControl, {
   COCALC_MODES,
 } from "@cocalc/server/projects/control";
@@ -35,22 +44,15 @@ import initSalesloftMaintenance from "@cocalc/server/salesloft/init";
 import { stripe_sync } from "@cocalc/server/stripe/sync";
 import { callback2, retry_until_success } from "@cocalc/util/async-utils";
 import { set_agent_endpoint } from "./health-checks";
-import { start as startHubRegister } from "@cocalc/server/metrics/hub_register";
 import { getLogger } from "./logger";
 import initDatabase, { database } from "./servers/database";
 import initExpressApp from "./servers/express-app";
-import {
-  loadConatConfiguration,
-  initConatChangefeedServer,
-  initConatApi,
-  initConatPersist,
-} from "@cocalc/server/conat";
-import { initConatServer } from "@cocalc/server/conat/socketio";
 
 import initHttpRedirect from "./servers/http-redirect";
 
-import * as MetricsRecorder from "@cocalc/server/metrics/metrics-recorder";
 import { addErrorListeners } from "@cocalc/server/metrics/error-listener";
+import * as MetricsRecorder from "@cocalc/server/metrics/metrics-recorder";
+import { migrateBookmarksToConat } from "./migrate-bookmarks";
 
 // Logger tagged with 'hub' for this file.
 const logger = getLogger("hub");
@@ -291,6 +293,10 @@ async function startServer(): Promise<void> {
     // upgrades of projects.
     initPurchasesMaintenanceLoop();
     initSalesloftMaintenance();
+    // Migrate bookmarks from database to conat (runs once at startup)
+    migrateBookmarksToConat().catch((err) => {
+      logger.error("Failed to migrate bookmarks to conat:", err);
+    });
     setInterval(trimLogFileSize, 1000 * 60 * 3);
   }
 
diff --git a/src/packages/hub/migrate-bookmarks.ts b/src/packages/hub/migrate-bookmarks.ts
new file mode 100644
index 00000000000..3b82aeaf811
--- /dev/null
+++ b/src/packages/hub/migrate-bookmarks.ts
@@ -0,0 +1,111 @@
+/*
+ *  This file is part of CoCalc: Copyright © 2024 Sagemath, Inc.
+ *  License: MS-RSL – see LICENSE.md for details
+ */
+
+import { delay } from "awaiting";
+
+import { conat } from "@cocalc/backend/conat/conat";
+import { dkv } from "@cocalc/backend/conat/sync";
+import {
+  CONAT_BOOKMARKS_KEY,
+  STARRED_FILES,
+} from "@cocalc/util/consts/bookmarks";
+import { getLogger } from "./logger";
+import getPool from "@cocalc/database/pool";
+
+const L = getLogger("hub:migrate-bookmarks");
+
+const BATCH_SIZE = 100;
+const MIGRATION_DELAY = 500; // ms between batches to avoid database saturation
+
+export async function migrateBookmarksToConat(): Promise<void> {
+  L.info("Starting migration of bookmarks to conat...");
+
+  const pool = getPool();
+  let totalMigrated = 0;
+  let batchCount = 0;
+
+  while (true) {
+    try {
+      // Query for a batch of bookmark entries
+      const { rows } = await pool.query(
+        `
+          SELECT id, account_id, project_id, stars
+          FROM bookmarks
+          WHERE type = $1
+          ORDER BY id
+          LIMIT $2
+        `,
+        [STARRED_FILES, BATCH_SIZE],
+      );
+
+      if (rows.length === 0) {
+        L.info(
+          `Migration completed. Total migrated: ${totalMigrated} bookmarks`,
+        );
+        break;
+      }
+
+      batchCount++;
+      L.info(`Processing batch ${batchCount} with ${rows.length} bookmarks...`);
+
+      // Process each bookmark in the batch
+      const processedIds: string[] = [];
+
+      for (const row of rows) {
+        try {
+          const { id, account_id, project_id, stars } = row;
+
+          if (!account_id || !project_id || !Array.isArray(stars)) {
+            L.warn(
+              `Skipping invalid bookmark ${id}: account_id=${account_id}, project_id=${project_id}, stars=${stars}`,
+            );
+            processedIds.push(id);
+            continue;
+          }
+
+          // Get or create conat DKV for this account
+          const bookmarks = await dkv<string[]>({
+            name: CONAT_BOOKMARKS_KEY,
+            account_id,
+            client: conat(),
+          });
+
+          // Set the starred files for this project
+          bookmarks.set(project_id, stars);
+          L.debug(
+            `Migrated bookmark ${id} for account ${account_id}, project ${project_id} with ${stars.length} stars`,
+          );
+
+          processedIds.push(id);
+          totalMigrated++;
+        } catch (err) {
+          L.error(`Failed to migrate bookmark ${row.id}: ${err}`);
+          // Still add to processedIds so we don't get stuck on this one
+          processedIds.push(row.id);
+        }
+      }
+
+      // Delete the processed bookmarks from the database
+      if (processedIds.length > 0) {
+        await pool.query(`DELETE FROM bookmarks WHERE id = ANY($1)`, [
+          processedIds,
+        ]);
+        L.debug(`Deleted ${processedIds.length} bookmarks from database`);
+      }
+
+      // Wait between batches to avoid database saturation
+      if (rows.length === BATCH_SIZE) {
+        L.debug(`Waiting ${MIGRATION_DELAY}ms before next batch...`);
+        await delay(MIGRATION_DELAY);
+      }
+    } catch (err) {
+      L.error(`Error in migration batch: ${err}`);
+      // Wait longer on error before retrying
+      await delay(MIGRATION_DELAY * 3);
+    }
+  }
+
+  L.info("Bookmark migration to conat completed successfully");
+}
diff --git a/src/packages/next/lib/api/bookmarks.ts b/src/packages/next/lib/api/bookmarks.ts
deleted file mode 100644
index 9de3fdb62e9..00000000000
--- a/src/packages/next/lib/api/bookmarks.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- *  This file is part of CoCalc: Copyright © 2024 Sagemath, Inc.
- *  License: MS-RSL – see LICENSE.md for details
- */
-
-import isCollaborator from "@cocalc/server/projects/is-collaborator";
-import getAccountId from "lib/account/get-account";
-import getParams from "lib/api/get-params";
-
-import {
-  BookmarkGetInputSchema,
-  BookmarkSetInputSchema,
-} from "lib/api/schema/bookmarks";
-
-// Process a request for the api/v2/bookmarks/* endpoints
-
-// TODO: deduplicate this with proper typing
-
-export async function processSetRequest(req) {
-  // ATTN: very confusing: this is the account_id or project_id for project level API keys
-  // Since bookmakrs are account specific (and collaborators shouldn't snoop on others), we block project keys
-  // In the future, there might be project-wide stars, which are not account specific.
-  const account_id = await getAccountId(req);
-  if (!account_id) {
-    throw Error("must be signed in");
-  }
-
-  const data = BookmarkSetInputSchema.parse(getParams(req));
-
-  if (account_id === data.project_id) {
-    throw new Error(
-      `As of now, you cannot use a project-level API key to modify account specific bookmarks. Use the account level API key!`,
-    );
-  }
-
-  if (!(await isCollaborator({ account_id, project_id: data.project_id }))) {
-    throw Error("user must be a collaborator on the project");
-  }
-
-  return { ...data, account_id };
-}
-
-export async function processGetRequest(req) {
-  // ATTN: very confusing: this is the account_id or project_id for project level API keys
-  const account_id = await getAccountId(req);
-  if (!account_id) {
-    throw Error("must be signed in");
-  }
-
-  const data = BookmarkGetInputSchema.parse(getParams(req));
-
-  if (account_id === data.project_id) {
-    throw new Error(
-      `As of now, you cannot use a project-level API key to modify account specific bookmarks. Use the account level API key!`,
-    );
-  }
-
-  if (!(await isCollaborator({ account_id, project_id: data.project_id }))) {
-    throw Error("user must be a collaborator on the project");
-  }
-
-  return { ...data, account_id };
-}
diff --git a/src/packages/next/lib/api/schema/bookmarks.ts b/src/packages/next/lib/api/schema/bookmarks.ts
deleted file mode 100644
index 0d040396447..00000000000
--- a/src/packages/next/lib/api/schema/bookmarks.ts
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- *  This file is part of CoCalc: Copyright © 2024 Sagemath, Inc.
- *  License: MS-RSL – see LICENSE.md for details
- */
-
-import { z } from "../framework";
-
-import {
-  LoadStarredFilesBookmarksProps,
-  SaveStarredFilesBoookmarksProps,
-} from "@cocalc/server/bookmarks/starred";
-import { MAX_STARS, STARRED_FILES } from "@cocalc/util/consts/bookmarks";
-import {
-  GetStarredBookmarks,
-  GetStarredBookmarksPayload,
-  SetStarredBookmarks,
-} from "@cocalc/util/types/bookmarks";
-import { ProjectIdSchema } from "./projects/common";
-
-const ERROR = z.object({
-  status: z.literal("error"),
-  error: z.string(),
-});
-
-const COMMON_STARS = z.object({
-  project_id: ProjectIdSchema,
-  type: z.literal(STARRED_FILES),
-});
-
-export const BookmarkSetInputSchema = COMMON_STARS.extend({
-  stars: z
-    .string()
-    .array()
-    .max(MAX_STARS)
-    .describe("List of file paths or IDs"),
-}).describe("Set the list of starred items to the given list of stars.");
-
-export const BookmarkSetOutputSchema = z.union([
-  COMMON_STARS.merge(z.object({ status: z.literal("success") })),
-  ERROR,
-]);
-
-export const BookmarkAddInputSchema = BookmarkSetInputSchema.describe(
-  "Add a list of starred items to the list of bookmarks.",
-);
-export const BookmarkAddOutputSchema = BookmarkSetOutputSchema;
-
-export const BookmarkRemoveInputSchema = BookmarkSetInputSchema.describe(
-  "Remove a list of starred items from the given list of bookmarks.",
-);
-export const BookmarkRemoveOutputSchema = BookmarkSetOutputSchema;
-
-export const BookmarkGetInputSchema = COMMON_STARS.describe(
-  "Get the list of starred items for the given project ID and your account.",
-);
-export const BookmarkGetOutputSchema = z.union([
-  z
-    .object({
-      status: z.literal("success"),
-      stars: z
-        .array(z.string())
-        .describe(
-          "Array of IDs or file path strings, as they are in the starred tabs flyout",
-        ),
-      last_edited: z
-        .number()
-        .optional()
-        .describe("UNIX epoch timestamp, when bookmark was last edited"),
-    })
-    .merge(COMMON_STARS),
-  ERROR.merge(COMMON_STARS),
-]);
-
-export type BookmarkSetInputType = z.infer<typeof BookmarkSetInputSchema>;
-export type BookmarkSetOutputType = z.infer<typeof BookmarkSetOutputSchema>;
-export type BookmarkAddInputType = z.infer<typeof BookmarkAddInputSchema>;
-export type BookmarkAddOutputType = z.infer<typeof BookmarkRemoveOutputSchema>;
-export type BookmarkRemoveInputType = z.infer<typeof BookmarkRemoveInputSchema>;
-export type BookmarkRemoveOutputType = z.infer<typeof BookmarkAddOutputSchema>;
-export type BookmarkGetInputType = z.infer<typeof BookmarkGetInputSchema>;
-export type BookmarkGetOutputType = z.infer<typeof BookmarkGetOutputSchema>;
-
-// consistency checks
-export const _1: Omit<SaveStarredFilesBoookmarksProps, "mode" | "account_id"> =
-  {} as Omit<BookmarkSetInputType, typeof STARRED_FILES>;
-
-export const _2: Omit<LoadStarredFilesBookmarksProps, "account_id"> =
-  {} as Omit<BookmarkGetInputType, typeof STARRED_FILES>;
-
-export const _3: BookmarkGetOutputType = {} as GetStarredBookmarks;
-
-export const _4: BookmarkSetInputType = {} as SetStarredBookmarks;
-
-export const _5: BookmarkGetInputType = {} as GetStarredBookmarksPayload;
diff --git a/src/packages/next/pages/api/v2/bookmarks.test.ts b/src/packages/next/pages/api/v2/bookmarks.test.ts
deleted file mode 100644
index 10d6493b00d..00000000000
--- a/src/packages/next/pages/api/v2/bookmarks.test.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- *  This file is part of CoCalc: Copyright © 2024 Sagemath, Inc.
- *  License: MS-RSL – see LICENSE.md for details
- */
-
-// import { v4 } from "uuid";
-
-// import { createMocks } from "lib/api/test-framework";
-// import get from "./bookmarks/get";
-// import set from "./bookmarks/set";
-
-// TODO: this does not work at all. That mock does not authenticate with the API, hence you only get an error.
-
-describe("/api/v2/bookmarks", () => {
-  // const project_id = v4();
-
-  test("set then get", async () => {
-    // const { req, res } = createMocks({
-    //   method: "POST",
-    //   url: "/api/v2/bookmarks/set",
-    //   body: {
-    //     type: "starred-files",
-    //     project_id,
-    //     payload: ["foo.md", "bar.ipynb"],
-    //   },
-    // });
-    // await set(req, res);
-    // expect(res.statusCode).toBe(200);
-    // console.log(res._getJSONData());
-  });
-});
diff --git a/src/packages/next/pages/api/v2/bookmarks/add.ts b/src/packages/next/pages/api/v2/bookmarks/add.ts
index 26ce33582eb..e7109e22e02 100644
--- a/src/packages/next/pages/api/v2/bookmarks/add.ts
+++ b/src/packages/next/pages/api/v2/bookmarks/add.ts
@@ -3,20 +3,12 @@
  *  License: MS-RSL – see LICENSE.md for details
  */
 
+// NOOP endpoint - bookmarks now handled by conat
+// Keeping endpoint for backwards compatibility with older clients
+
 import { Request } from "express";
 
-import { getLogger } from "@cocalc/backend/logger";
-import { saveStarredFilesBookmarks } from "@cocalc/server/bookmarks/starred";
 import { STARRED_FILES } from "@cocalc/util/consts/bookmarks";
-import { apiRoute, apiRouteOperation } from "lib/api";
-import { processSetRequest } from "lib/api/bookmarks";
-import {
-  BookmarkAddInputSchema,
-  BookmarkAddOutputSchema,
-  BookmarkSetOutputType,
-} from "lib/api/schema/bookmarks";
-
-const L = getLogger("api:v2:bookmark:add");
 
 async function handle(req, res) {
   try {
@@ -27,19 +19,19 @@ async function handle(req, res) {
   }
 }
 
-async function add(req: Request): Promise<BookmarkSetOutputType> {
-  const { project_id, account_id, type, stars } = await processSetRequest(req);
-
+async function add(
+  req: Request,
+): Promise<{
+  status: "success" | "error";
+  project_id?: string;
+  type?: string;
+  error?: string;
+}> {
+  const { project_id, type } = req.body;
+
+  // NOOP: Always return success since bookmarks are now handled by conat
   switch (type) {
     case STARRED_FILES: {
-      L.debug("set", { project_id, stars });
-      await saveStarredFilesBookmarks({
-        project_id,
-        stars,
-        account_id,
-        mode: "add",
-      });
-
       return { status: "success", project_id, type };
     }
 
@@ -48,23 +40,4 @@ async function add(req: Request): Promise<BookmarkSetOutputType> {
   }
 }
 
-export default apiRoute({
-  addBookmarks: apiRouteOperation({
-    method: "POST",
-    openApiOperation: {
-      tags: ["Projects"],
-    },
-  })
-    .input({
-      contentType: "application/json",
-      body: BookmarkAddInputSchema,
-    })
-    .outputs([
-      {
-        status: 200,
-        contentType: "application/json",
-        body: BookmarkAddOutputSchema,
-      },
-    ])
-    .handler(handle),
-});
+export default handle;
diff --git a/src/packages/next/pages/api/v2/bookmarks/get.ts b/src/packages/next/pages/api/v2/bookmarks/get.ts
index 6679cc4adbd..e9064bace26 100644
--- a/src/packages/next/pages/api/v2/bookmarks/get.ts
+++ b/src/packages/next/pages/api/v2/bookmarks/get.ts
@@ -3,17 +3,12 @@
  *  License: MS-RSL – see LICENSE.md for details
  */
 
+// NOOP endpoint - bookmarks now handled by conat
+// Keeping endpoint for backwards compatibility with older clients
+
 import { Request } from "express";
 
-import { loadStarredFilesBookmarks } from "@cocalc/server/bookmarks/starred";
 import { STARRED_FILES } from "@cocalc/util/consts/bookmarks";
-import { apiRoute, apiRouteOperation } from "lib/api";
-import { processGetRequest } from "lib/api/bookmarks";
-import {
-  BookmarkGetInputSchema,
-  BookmarkGetOutputSchema,
-  BookmarkGetOutputType,
-} from "lib/api/schema/bookmarks";
 
 async function handle(req, res) {
   try {
@@ -24,21 +19,24 @@ async function handle(req, res) {
   }
 }
 
-async function get(req: Request): Promise<BookmarkGetOutputType> {
-  const { project_id, account_id, type } = await processGetRequest(req);
-
+async function get(
+  req: Request,
+): Promise<{
+  status: "success" | "error";
+  stars?: string[];
+  type?: string;
+  project_id?: string;
+  error?: string;
+}> {
+  const { type, project_id } = req.body;
+
+  // NOOP: Always return empty bookmarks since they're now handled by conat
   switch (type) {
     case STARRED_FILES: {
-      const { stars, last_edited } = await loadStarredFilesBookmarks({
-        project_id,
-        account_id,
-      });
-
       return {
         type,
         project_id,
-        stars,
-        last_edited,
+        stars: [],
         status: "success",
       };
     }
@@ -53,23 +51,4 @@ async function get(req: Request): Promise<BookmarkGetOutputType> {
   }
 }
 
-export default apiRoute({
-  getBookmarks: apiRouteOperation({
-    method: "POST",
-    openApiOperation: {
-      tags: ["Projects"],
-    },
-  })
-    .input({
-      contentType: "application/json",
-      body: BookmarkGetInputSchema,
-    })
-    .outputs([
-      {
-        status: 200,
-        contentType: "application/json",
-        body: BookmarkGetOutputSchema,
-      },
-    ])
-    .handler(handle),
-});
+export default handle;
diff --git a/src/packages/next/pages/api/v2/bookmarks/remove.ts b/src/packages/next/pages/api/v2/bookmarks/remove.ts
index 3b3e873fe4d..5a9626dc9f9 100644
--- a/src/packages/next/pages/api/v2/bookmarks/remove.ts
+++ b/src/packages/next/pages/api/v2/bookmarks/remove.ts
@@ -3,20 +3,12 @@
  *  License: MS-RSL – see LICENSE.md for details
  */
 
+// NOOP endpoint - bookmarks now handled by conat
+// Keeping endpoint for backwards compatibility with older clients
+
 import { Request } from "express";
 
-import { getLogger } from "@cocalc/backend/logger";
-import { saveStarredFilesBookmarks } from "@cocalc/server/bookmarks/starred";
 import { STARRED_FILES } from "@cocalc/util/consts/bookmarks";
-import { apiRoute, apiRouteOperation } from "lib/api";
-import { processSetRequest } from "lib/api/bookmarks";
-import {
-  BookmarkRemoveInputSchema,
-  BookmarkRemoveOutputSchema,
-  BookmarkSetOutputType,
-} from "lib/api/schema/bookmarks";
-
-const L = getLogger("api:v2:bookmark:remove");
 
 async function handle(req, res) {
   try {
@@ -27,19 +19,19 @@ async function handle(req, res) {
   }
 }
 
-async function remove(req: Request): Promise<BookmarkSetOutputType> {
-  const { project_id, account_id, type, stars } = await processSetRequest(req);
-
+async function remove(
+  req: Request,
+): Promise<{
+  status: "success" | "error";
+  project_id?: string;
+  type?: string;
+  error?: string;
+}> {
+  const { project_id, type } = req.body;
+
+  // NOOP: Always return success since bookmarks are now handled by conat
   switch (type) {
     case STARRED_FILES: {
-      L.debug("set", { project_id, stars });
-      await saveStarredFilesBookmarks({
-        project_id,
-        account_id,
-        stars,
-        mode: "remove",
-      });
-
       return { status: "success", project_id, type };
     }
 
@@ -48,23 +40,4 @@ async function remove(req: Request): Promise<BookmarkSetOutputType> {
   }
 }
 
-export default apiRoute({
-  removeBookmarks: apiRouteOperation({
-    method: "POST",
-    openApiOperation: {
-      tags: ["Projects"],
-    },
-  })
-    .input({
-      contentType: "application/json",
-      body: BookmarkRemoveInputSchema,
-    })
-    .outputs([
-      {
-        status: 200,
-        contentType: "application/json",
-        body: BookmarkRemoveOutputSchema,
-      },
-    ])
-    .handler(handle),
-});
+export default handle;
diff --git a/src/packages/next/pages/api/v2/bookmarks/set.ts b/src/packages/next/pages/api/v2/bookmarks/set.ts
index 74e55235b0c..7b552fbcf57 100644
--- a/src/packages/next/pages/api/v2/bookmarks/set.ts
+++ b/src/packages/next/pages/api/v2/bookmarks/set.ts
@@ -3,20 +3,12 @@
  *  License: MS-RSL – see LICENSE.md for details
  */
 
+// NOOP endpoint - bookmarks now handled by conat
+// Keeping endpoint for backwards compatibility with older clients
+
 import { Request } from "express";
 
-import { getLogger } from "@cocalc/backend/logger";
-import { saveStarredFilesBookmarks } from "@cocalc/server/bookmarks/starred";
 import { STARRED_FILES } from "@cocalc/util/consts/bookmarks";
-import { apiRoute, apiRouteOperation } from "lib/api";
-import { processSetRequest } from "lib/api/bookmarks";
-import {
-  BookmarkSetInputSchema,
-  BookmarkSetOutputSchema,
-  BookmarkSetOutputType,
-} from "lib/api/schema/bookmarks";
-
-const L = getLogger("api:v2:bookmark:set");
 
 async function handle(req, res) {
   try {
@@ -27,19 +19,19 @@ async function handle(req, res) {
   }
 }
 
-async function set(req: Request): Promise<BookmarkSetOutputType> {
-  const { project_id, account_id, type, stars } = await processSetRequest(req);
-
+async function set(
+  req: Request,
+): Promise<{
+  status: "success" | "error";
+  project_id?: string;
+  type?: string;
+  error?: string;
+}> {
+  const { project_id, type } = req.body;
+
+  // NOOP: Always return success since bookmarks are now handled by conat
   switch (type) {
     case STARRED_FILES: {
-      L.debug("set", { project_id, stars });
-      await saveStarredFilesBookmarks({
-        project_id,
-        account_id,
-        stars,
-        mode: "set",
-      });
-
       return { status: "success", project_id, type };
     }
 
@@ -48,23 +40,4 @@ async function set(req: Request): Promise<BookmarkSetOutputType> {
   }
 }
 
-export default apiRoute({
-  setBookmarks: apiRouteOperation({
-    method: "POST",
-    openApiOperation: {
-      tags: ["Projects"],
-    },
-  })
-    .input({
-      contentType: "application/json",
-      body: BookmarkSetInputSchema,
-    })
-    .outputs([
-      {
-        status: 200,
-        contentType: "application/json",
-        body: BookmarkSetOutputSchema,
-      },
-    ])
-    .handler(handle),
-});
+export default handle;
diff --git a/src/packages/server/bookmarks/starred.ts b/src/packages/server/bookmarks/starred.ts
deleted file mode 100644
index e90dad69602..00000000000
--- a/src/packages/server/bookmarks/starred.ts
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- *  This file is part of CoCalc: Copyright © 2024 Sagemath, Inc.
- *  License: MS-RSL – see LICENSE.md for details
- */
-
-import getPool from "@cocalc/database/pool";
-import {
-  MAX_LENGTH_STAR,
-  MAX_STARS,
-  STARRED_FILES,
-} from "@cocalc/util/consts/bookmarks";
-import getLogger from "@cocalc/backend/logger";
-
-const L = getLogger("server:bookmarks");
-
-export type SaveStarredFilesBoookmarksProps = {
-  project_id: string;
-  account_id: string;
-  stars: string[];
-  mode: "set" | "add" | "remove";
-};
-
-export async function saveStarredFilesBookmarks({
-  project_id,
-  account_id,
-  stars,
-  mode,
-}: SaveStarredFilesBoookmarksProps): Promise<string[]> {
-  if (account_id === project_id) {
-    throw new Error(
-      `As of now, you cannot use a project-level API key to modify account specific bookmarks. Use the account level API key!`,
-    );
-  }
-
-  const pool = getPool();
-
-  // test if a row with the given project_id exists in the table projects
-  const { rows: project } = await pool.query(
-    `SELECT * FROM projects WHERE project_id = $1`,
-    [project_id],
-  );
-
-  if (project.length === 0) {
-    throw new Error(`Project '${project_id} does not exist`);
-  }
-
-  if (!Array.isArray(stars)) {
-    throw new Error(
-      `Invalid stars value: type='${typeof stars}'. Must be an array of strings.`,
-    );
-  }
-
-  if (stars.length > MAX_STARS) {
-    L.warn(
-      `Too many stars: '${stars.length}'. Truncating to ${MAX_STARS} items.`,
-    );
-    stars = stars.slice(0, MAX_STARS);
-  }
-
-  // test that all strings in starred are strings and have a maximum length of $MAX_LENGTH characters
-  for (const star of stars) {
-    if (typeof star !== "string" || star.length > MAX_LENGTH_STAR) {
-      throw new Error(
-        `Invalid star: '${star}' must be a string with a maximum length of ${MAX_LENGTH_STAR} characters`,
-      );
-    }
-  }
-
-  // in-place sort. neat to keep them in a canonical ordering.
-  stars.sort();
-
-  const { rows } = await pool.query(
-    `SELECT id FROM bookmarks WHERE project_id=$1 AND type=$2 AND account_id=$3`,
-    [project_id, STARRED_FILES, account_id],
-  );
-
-  const query = async (q, v): Promise<string[]> => {
-    const { rows } = await pool.query<{ stars: string[] }>(q, v);
-    return rows[0].stars;
-  };
-
-  if (rows.length > 0) {
-    switch (mode) {
-      case "add": {
-        // Add the new stars items to the list
-        return query(
-          `UPDATE bookmarks
-          SET stars = ARRAY_CAT(stars, $1::TEXT[]),
-              last_edited=$2
-          WHERE id = $3 AND account_id = $4 AND type=$5
-          RETURNING stars;`,
-          [stars, new Date(), rows[0].id, account_id, STARRED_FILES],
-        );
-      }
-      case "remove": {
-        // Remove any stars that may exist
-        return query(
-          `UPDATE bookmarks
-          SET stars = (
-                SELECT ARRAY_AGG(elem)
-                FROM UNNEST(stars) AS elem
-                WHERE NOT elem = ANY($1::TEXT[])
-              ),
-              last_edited=$2
-          WHERE id = $3 AND account_id=$4 AND type=$5
-          RETURNING stars;`,
-          [stars, new Date(), rows[0].id, account_id, STARRED_FILES],
-        );
-      }
-      case "set": {
-        // Instead of appending the new stars, we replace them with a set operation
-        return query(
-          `UPDATE bookmarks
-          SET stars=$1::TEXT[],
-              last_edited=$2
-          WHERE id = $3 AND account_id=$4 AND type=$5
-          RETURNING stars`,
-          [stars, new Date(), rows[0].id, account_id, STARRED_FILES],
-        );
-      }
-    }
-  } else {
-    return query(
-      `INSERT INTO bookmarks (type, project_id, stars, account_id, last_edited)
-       VALUES ($1, $2, $3::TEXT[], $4, $5) RETURNING stars`,
-      [STARRED_FILES, project_id, stars, account_id, new Date()],
-    );
-  }
-}
-
-export type LoadStarredFilesBookmarksProps = {
-  project_id: string;
-  account_id: string;
-};
-
-export async function loadStarredFilesBookmarks({
-  project_id,
-  account_id,
-}: LoadStarredFilesBookmarksProps): Promise<{
-  stars: string[];
-  last_edited?: number;
-}> {
-  const pool = getPool();
-  const { rows } = await pool.query(
-    `SELECT stars, last_edited FROM bookmarks WHERE project_id=$1 AND type=$2 AND account_id=$3`,
-    [project_id, STARRED_FILES, account_id],
-  );
-
-  if (rows.length > 0) {
-    const row = rows[0];
-    return {
-      stars: row.stars ?? [],
-      last_edited: row.last_edited?.getTime(),
-    };
-  } else {
-    return { stars: [] };
-  }
-}
diff --git a/src/packages/util/consts/bookmarks.ts b/src/packages/util/consts/bookmarks.ts
index 0d6570e071c..7e063098b41 100644
--- a/src/packages/util/consts/bookmarks.ts
+++ b/src/packages/util/consts/bookmarks.ts
@@ -4,3 +4,5 @@ export const MAX_STARS = 256;
 export const MAX_LENGTH_STAR = 2048;
 // the type of bookmark for starring files
 export const STARRED_FILES = "starred-files";
+// the conat key for storing bookmarks
+export const CONAT_BOOKMARKS_KEY = "bookmark-starred-files";