Improve Content workspace sidebar navigation

templates/content/AGENTS.md

@@ -51,16 +51,14 @@ Read the relevant skill before deeper work:
   and respect `contextMode: "off"` without silently restoring a pack.
 - `content-last-location-v1` — the last successfully loaded Page. The UI and
   landing resolver own this state; do not write it from agent workflows.
-- `content-trash` — bounded Trash filters, up to 100 selected Page IDs, the
-  preview Page ID, and the current purge operation ID. Treat selection and
-  filters as UI context, not deletion authority; plan the exact scope before
-  permanent deletion.
+- `content-trash` — Trash filters, selected/preview Page IDs, and purge operation
+  ID. This is UI context, not deletion authority.
 - Use actions for full document content and comment context.
 
 ## Actions
 
 | Action | Purpose |
-| --- | --- |
+| ------------------------------- | -------------------------------------------------------------------------------------------------------------- |
 | `view-screen` | Re-read the current screen when `<current-screen>` is stale |
 | `navigate` | Move the UI to a document, comments, media, or settings |
 | `refresh-list` | Repaint the sidebar after an out-of-band mutation |
@@ -70,7 +68,8 @@ Read the relevant skill before deeper work:
 | `pull-document` | Flush live collab state, then read (external edits) |
 | `get-blocks-field-word-count` | Count one exact Blocks field; omit `propertyId` for the primary Content body |
 | `create-document` | Create a page, optionally under a parent |
-| `resolve-content-landing` | Restore the caller's last authorized page |
+| `resolve-content-landing` | Restore the caller's last authorized page in a requested Content space |
+| `get-content-recent` | List personal recent destinations with current access, optionally scoped to a Content space's Files membership |
 | `edit-document` | Revisioned find/replace, or initialize an empty body |
 | `update-document` | Metadata or browser-owned full rewrite |
 | `delete-document` | Move a page and its children to Trash |
@@ -88,12 +87,12 @@ Every action carries its schema. Use `tool-search` for comments, sharing,
 Collections, Notion, local sources such as `remove-local-file-source`, and the
 rest of the registered surface.
 
-For permanent deletion, always plan before executing and report blockers or
-conflicts rather than claiming Trash is empty. Scope mode means all manageable
-Trash in the chosen space scope and intentionally ignores text, kind, actor,
-and location filters. A selected or matching Page includes only itself and its
-currently trashed descendants, never its Trash root or siblings. New or changed
-Trash after planning is not silently added.
+Permanent deletion requires a frozen plan. Read `document-editing` and report
+blockers or conflicts instead of claiming Trash is empty.
+
+Sidebar order and active Views use the personal view `navigation` patch, never
+parentage. Recent means foreground visits; paging, active-path lookup, and visit
+recording are UI-owned.
 
 ## Source Changes
 

templates/content/actions/_content-database-personal-view.ts

@@ -42,9 +42,10 @@ export const filterSchema = z.object({
   parentFilterGroupId: z.string().optional(),
 });
 
+const sidebarOrderItemIdSchema = z.string().min(1).max(256);
 export const sidebarOrderSchema = z.object({
   mode: z.enum(["custom", "last_edited", "name", "created"]),
-  itemIds: z.array(z.string()),
+  itemIds: z.array(sidebarOrderItemIdSchema).max(5_000),
 });
 
 const personalViewOverridesFields = {
@@ -123,24 +124,41 @@ export async function readPersonalDatabaseViewOverrides(
     userEmail,
     personalDatabaseViewSettingKey(databaseId),
   );
+  if (stored === null) return null;
   const parsed = personalViewOverridesSchema.safeParse(stored);
   if (parsed.success)
     return normalizePersonalDatabaseViewOverrides(parsed.data);
 
-  const legacy = legacyPersonalViewOverridesSchema.safeParse(stored);
-  if (!legacy.success) return null;
+  legacyPersonalViewOverridesSchema.parse(stored);
   const [database] = await getDb()
     .select({ systemRole: schema.contentDatabases.systemRole })
     .from(schema.contentDatabases)
     .where(eq(schema.contentDatabases.id, databaseId));
+  return migratePersonalDatabaseViewOverrides(
+    stored,
+    databaseId,
+    database?.systemRole ?? null,
+  );
+}
+
+export function migratePersonalDatabaseViewOverrides(
+  stored: unknown,
+  databaseId: string,
+  systemRole: string | null,
+) {
+  if (stored === null) return null;
+  const parsed = personalViewOverridesSchema.safeParse(stored);
+  if (parsed.success)
+    return normalizePersonalDatabaseViewOverrides(parsed.data);
+  const legacy = legacyPersonalViewOverridesSchema.parse(stored);
   const legacyParentKey = filesParentPropertyId(databaseId);
   return normalizePersonalDatabaseViewOverrides({
-    ...legacy.data,
+    ...legacy,
     version: PERSONAL_DATABASE_VIEW_OVERRIDES_VERSION,
-    views: legacy.data.views.map((view) => ({
+    views: legacy.views.map((view) => ({
       ...view,
       filters:
-        database?.systemRole === "files"
+        systemRole === "files"
           ? view.filters.filter(
               (filter) =>
                 !(

templates/content/actions/_content-favorites.ts

@@ -19,6 +19,14 @@ export function favoritesSystemIds(userEmail: string) {
   );
 }
 
+export function favoriteMembershipId(userEmail: string, documentId: string) {
+  const favoritesDatabaseId = favoritesSystemIds(userEmail).databaseId;
+  return `content_database_item_${createHash("sha256")
+    .update(`${favoritesDatabaseId}:${documentId}`)
+    .digest("hex")
+    .slice(0, 32)}`;
+}
+
 export async function favoriteDocumentIds(
   db: Db,
   userEmail: string,
@@ -48,7 +56,12 @@ export async function setFavoriteMembership(args: {
   const email = normalizeContentSpaceEmail(args.userEmail);
   const favoritesDatabaseId = favoritesSystemIds(email).databaseId;
   const [existing] = await args.db
-    .select({ id: schema.contentDatabaseItems.id })
+    .select({
+      id: schema.contentDatabaseItems.id,
+      position: schema.contentDatabaseItems.position,
+      createdAt: schema.contentDatabaseItems.createdAt,
+      updatedAt: schema.contentDatabaseItems.updatedAt,
+    })
     .from(schema.contentDatabaseItems)
     .where(
       and(
@@ -63,19 +76,28 @@ export async function setFavoriteMembership(args: {
         .delete(schema.contentDatabaseItems)
         .where(eq(schema.contentDatabaseItems.id, existing.id));
     }
-    return false;
+    return {
+      favorite: false,
+      changed: Boolean(existing),
+      membershipId:
+        existing?.id ?? favoriteMembershipId(email, args.documentId),
+      previous: existing ?? null,
+    };
   }
-  if (existing) return true;
+  if (existing)
+    return {
+      favorite: true,
+      changed: false,
+      membershipId: existing.id,
+      previous: existing,
+    };
 
   const [position] = await args.db
     .select({ max: sql<unknown>`COALESCE(MAX(position), -1)` })
     .from(schema.contentDatabaseItems)
     .where(eq(schema.contentDatabaseItems.databaseId, favoritesDatabaseId));
-  const id = `content_database_item_${createHash("sha256")
-    .update(`${favoritesDatabaseId}:${args.documentId}`)
-    .digest("hex")
-    .slice(0, 32)}`;
-  await args.db
+  const id = favoriteMembershipId(email, args.documentId);
+  const inserted = await args.db
     .insert(schema.contentDatabaseItems)
     .values({
       id,
@@ -87,6 +109,12 @@ export async function setFavoriteMembership(args: {
       createdAt: args.now,
       updatedAt: args.now,
     })
-    .onConflictDoNothing();
-  return true;
+    .onConflictDoNothing()
+    .returning({ id: schema.contentDatabaseItems.id });
+  return {
+    favorite: true,
+    changed: inserted.length > 0,
+    membershipId: id,
+    previous: null,
+  };
 }

templates/content/actions/_content-recent.ts

@@ -0,0 +1,194 @@
+import { getRequestOrgId } from "@agent-native/core/server/request-context";
+import { and, eq, inArray, isNull, or } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import {
+  contentRecentTargetKey,
+  type ContentRecentEntry,
+  type ContentRecentResult,
+} from "../shared/content-personal-navigation.js";
+import { readPersonalDatabaseViewOverrides } from "./_content-database-personal-view.js";
+import { resolveContentSpaceAccess } from "./_content-space-access.js";
+import { documentDiscoveryWhere } from "./_document-discovery-query.js";
+import { parseDatabaseViewConfig } from "./_property-utils.js";
+
+export function contentRecentSettingKey() {
+  return `content-recent:${JSON.stringify(getRequestOrgId() ?? null)}`;
+}
+
+const viewIdentitySchema = z.object({
+  views: z
+    .array(z.object({ id: z.string().trim().min(1), name: z.string() }))
+    .optional(),
+});
+
+export async function resolveContentRecentEntries(
+  userEmail: string,
+  entries: ContentRecentEntry[],
+  spaceId?: string,
+): Promise<ContentRecentResult[]> {
+  if (entries.length === 0) return [];
+  const db = getDb();
+  const orgId = getRequestOrgId();
+  let scopedEntries = entries;
+  if (spaceId) {
+    const access = await resolveContentSpaceAccess(spaceId, "viewer", { db });
+    if (access.space.orgId && access.space.orgId !== orgId) return [];
+    const memberships = await db
+      .select({ documentId: schema.contentDatabaseItems.documentId })
+      .from(schema.contentDatabaseItems)
+      .where(
+        and(
+          eq(
+            schema.contentDatabaseItems.databaseId,
+            access.space.filesDatabaseId,
+          ),
+          inArray(
+            schema.contentDatabaseItems.documentId,
+            entries.map((entry) => entry.target.documentId),
+          ),
+        ),
+      );
+    const memberIds = new Set(memberships.map((row) => row.documentId));
+    scopedEntries = entries.filter((entry) =>
+      memberIds.has(entry.target.documentId),
+    );
+  }
+  if (scopedEntries.length === 0) return [];
+  const documents = await db
+    .select({
+      id: schema.documents.id,
+      title: schema.documents.title,
+      icon: schema.documents.icon,
+    })
+    .from(schema.documents)
+    .where(
+      documentDiscoveryWhere({
+        userEmail,
+        authorizedOrgIds: orgId ? [orgId] : [],
+        additional: inArray(
+          schema.documents.id,
+          scopedEntries.map((entry) => entry.target.documentId),
+        ),
+      }),
+    );
+  const byId = new Map(documents.map((document) => [document.id, document]));
+  const databaseEntries = scopedEntries.filter(
+    (entry) => entry.target.databaseId,
+  );
+  const viewDocumentIds = databaseEntries
+    .filter(
+      (entry) => entry.target.databaseId && byId.has(entry.target.documentId),
+    )
+    .map((entry) => entry.target.documentId);
+  const databases =
+    viewDocumentIds.length === 0
+      ? []
+      : await db
+          .select({
+            id: schema.contentDatabases.id,
+            documentId: schema.contentDatabases.documentId,
+            viewConfigJson: schema.contentDatabases.viewConfigJson,
+          })
+          .from(schema.contentDatabases)
+          .where(
+            and(
+              or(
+                inArray(schema.contentDatabases.documentId, viewDocumentIds),
+                inArray(
+                  schema.contentDatabases.id,
+                  databaseEntries.map((entry) => entry.target.databaseId!),
+                ),
+              ),
+              isNull(schema.contentDatabases.deletedAt),
+            ),
+          );
+  const databasesById = new Map(
+    databases.map((database) => [database.id, database]),
+  );
+  const missingBackingDocumentIds = databases
+    .map((database) => database.documentId)
+    .filter((documentId) => !byId.has(documentId));
+  if (missingBackingDocumentIds.length > 0) {
+    const backingDocuments = await db
+      .select({
+        id: schema.documents.id,
+        title: schema.documents.title,
+        icon: schema.documents.icon,
+      })
+      .from(schema.documents)
+      .where(
+        documentDiscoveryWhere({
+          userEmail,
+          authorizedOrgIds: orgId ? [orgId] : [],
+          additional: inArray(schema.documents.id, missingBackingDocumentIds),
+        }),
+      );
+    for (const document of backingDocuments) byId.set(document.id, document);
+  }
+  const results: ContentRecentResult[] = [];
+  const seen = new Set<string>();
+  for (const entry of scopedEntries) {
+    const database = entry.target.databaseId
+      ? databasesById.get(entry.target.databaseId)
+      : undefined;
+    const document = byId.get(database?.documentId ?? entry.target.documentId);
+    if (!document) continue;
+    let viewName: string | null = null;
+    let target = database
+      ? { ...entry.target, documentId: database.documentId }
+      : entry.target;
+    let fallback: ContentRecentResult["fallback"];
+    if (entry.target.databaseId) {
+      if (!database || database.documentId !== document.id) continue;
+      if (entry.target.viewId) {
+        // Validate before the legacy parser, which otherwise coerces unreadable JSON to a default.
+        viewIdentitySchema.parse(JSON.parse(database.viewConfigJson));
+        const config = parseDatabaseViewConfig(database.viewConfigJson);
+        const view = config.views.find(
+          (candidate) => candidate.id === entry.target.viewId,
+        );
+        if (view) {
+          viewName = view.name;
+        } else {
+          const personal = await readPersonalDatabaseViewOverrides(
+            userEmail,
+            database.id,
+          );
+          const fallbackView =
+            config.views.find(
+              (candidate) => candidate.id === personal?.activeViewId,
+            ) ??
+            config.views.find(
+              (candidate) => candidate.id === config.activeViewId,
+            ) ??
+            config.views[0];
+          if (!fallbackView) continue;
+          target = {
+            documentId: document.id,
+            databaseId: database.id,
+            viewId: fallbackView.id,
+          };
+          viewName = fallbackView.name;
+          fallback = {
+            reason: "saved_view_unavailable",
+            requestedViewId: entry.target.viewId,
+          };
+        }
+      }
+    }
+    const key = contentRecentTargetKey(entry.target);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    results.push({
+      ...entry,
+      target,
+      title: document.title,
+      icon: document.icon,
+      viewName,
+      ...(fallback ? { fallback } : {}),
+    });
+  }
+  return results;
+}