@agent-native/core 0.102.1 → 0.103.0

package/corpus/templates/content/.agents/skills/content/SKILL.md

@@ -3,7 +3,7 @@ name: content
 description: >-
   Use Content for repo-backed Markdown/MDX docs, blogs, resources, rich
   document editing, Notion-style databases and boards, structured intake
-  forms, local components, shareable copies, and Content local-file workspaces.
+  forms, local components, shareable copies, and connected local folders.
   Prefer Content actions over raw filesystem writes when available.
 metadata:
   visibility: exported
@@ -17,7 +17,7 @@ marketing pages, internal notes, and local MDX components. Also use Content for
 Notion-style databases, tables, boards, structured request intake, and forms
 whose submissions become database row pages. Content gives the agent a document
 tree, a rich editor, structured database properties and views, normal document
-actions, and an optional local-file source of truth.
+actions, and local folders that sync into the same database model.
 
 ## Choose The Path
 
@@ -33,9 +33,9 @@ actions, and an optional local-file source of truth.
   its exact title, then inspect it with `get-content-database` before creating
   or submitting anything. Do not create a second database when the canonical
   one already exists.
-- In Local File Mode, Content actions read and write the repo files declared in
-  `agent-native.json`; SQL remains cache/history/search glue, not the source of
-  truth for those pages.
+- Local folders are sources attached to a space's canonical Files database.
+  Imported pages are normal SQL-backed Content documents; the trusted local
+  bridge handles pull, export, stable file identity, and conflict review.
 - If Content tools are not visible and no local Content app or Desktop bridge is
   running, treat this skill as repo-editing guidance. Edit configured
   `.md`/`.mdx` files directly, preserve frontmatter and MDX imports, and tell
@@ -47,10 +47,10 @@ Prefer JSON input for action calls:
 
 ```bash
 pnpm action list-documents
-pnpm action get-document '{"id":"local-file:..."}'
-pnpm action edit-document '{"id":"local-file:...","find":"old copy","replace":"new copy"}'
-pnpm action update-document '{"id":"local-file:...","content":"# Updated\n\nBody"}'
-pnpm action share-local-file-document '{"id":"local-file:..."}'
+pnpm action get-document '{"id":"<document-id>"}'
+pnpm action edit-document '{"id":"<document-id>","find":"old copy","replace":"new copy"}'
+pnpm action update-document '{"id":"<document-id>","content":"# Updated\n\nBody"}'
+pnpm action connect-local-folder-source '{"connectionId":"<opaque-bridge-id>","label":"Docs","createSourceBackedSpace":true,"truthPolicy":"source_primary"}'
 ```
 
 Run `refresh-list` after create/update/delete operations when you need the open
@@ -132,7 +132,7 @@ guesswork:
   writing. If a named person cannot be resolved unambiguously, clarify in the
   originating Slack thread; never omit, downgrade, or silently drop the person.
 
-## Local File Mode
+## Local Folder Sources
 
 Install into an existing repo with:
 
@@ -140,40 +140,27 @@ Install into an existing repo with:
 npx @agent-native/core@latest skills add content --mode local-files --scope project
 ```
 
-The installer copies this skill and writes or updates `agent-native.json` with
-Content roots for `docs/`, `blog/`, `content/`, and `resources/`, plus a
-`components/` folder for local MDX components. A typical manifest looks like:
+The compatibility spelling still installs the skill, but it no longer enables
+a separate data mode. The CLI writes or updates `agent-native.json` with
+declarative local-folder sources and launches normal database-backed Content.
+A typical root looks like:
 
 ```json
 {
   "version": 1,
   "apps": {
     "content": {
-      "mode": "local-files",
       "roots": [
         {
           "name": "Docs",
           "path": "docs",
           "kind": "docs",
-          "extensions": [".md", ".mdx"]
-        },
-        {
-          "name": "Blog",
-          "path": "blog",
-          "kind": "blog",
-          "extensions": [".md", ".mdx"]
-        },
-        {
-          "name": "Content",
-          "path": "content",
-          "kind": "content",
-          "extensions": [".md", ".mdx"]
-        },
-        {
-          "name": "Resources",
-          "path": "resources",
-          "kind": "resources",
-          "extensions": [".md", ".mdx"]
+          "extensions": [".md", ".mdx"],
+          "source": {
+            "type": "local-folder",
+            "connectionId": "local-folder:<opaque-id>",
+            "truthPolicy": "source_primary"
+          }
         }
       ],
       "components": "components",
@@ -184,9 +171,10 @@ Content roots for `docs/`, `blog/`, `content/`, and `resources/`, plus a
 }
 ```
 
-Local File Mode does not make the host language model local, and the hosted
-Content app cannot read private repo files by itself. File access requires a
-local Content app, Agent Native Desktop, or another trusted local bridge.
+Content never stores an absolute local path or raw file body in source metadata.
+File access still requires a local Content app, Agent Native Desktop, or another
+trusted bridge. Disconnecting a folder leaves the SQL pages and disk files in
+place. Concurrent edits and missing source files require explicit review.
 
 ## MDX And Components
 
@@ -202,9 +190,8 @@ local Content app, Agent Native Desktop, or another trusted local bridge.
 
 ## Boundaries
 
-- Moving, renaming, and reordering local-file pages are not first-class Content
-  UI operations yet. Use normal file operations when the user asks for those,
-  then let Content rediscover the file tree.
+- Preserve a page's frontmatter `id` when renaming a source file so the next
+  sync recognizes it as the same global Content page.
 - Do not push/pull Notion, Builder.io, or other provider-backed content unless
   the user explicitly asks for provider sync.
 - Do not paste secrets, private provider data, or credential-looking values into

package/corpus/templates/content/AGENTS.md

@@ -96,6 +96,11 @@ cd templates/content && pnpm action <name> [args]
 | `list-documents`                            | `[--format json]`                                                                                                                                                                                  | List document metadata/tree; no full bodies                                                                                                                                       |
 | `export-content-source`                     | `[--format json]`                                                                                                                                                                                  | Export editable docs as `content/*.mdx` source files                                                                                                                              |
 | `import-content-source`                     | `--files <json> [--dryRun true\|false]`                                                                                                                                                            | Import `.md`/`.mdx` source files into editable docs                                                                                                                               |
+| `connect-local-folder-source`               | `--connectionId <opaque-id> --label <name> [--spaceId <id>\|--databaseId <id>\|--createSourceBackedSpace true] [--truthPolicy database_primary\|source_primary\|reviewed_bidirectional]`           | Connect a trusted browser/Desktop folder registry entry to canonical Files without storing its path or handle in SQL                                                              |
+| `sync-local-folder-source`                  | `--sourceId <id> --files <json> [--dryRun true\|false]`                                                                                                                                            | Materialize a connected folder through Files source rows and record concurrent changes for review                                                                                 |
+| `sync-manifest-local-folder-source`         | `--connectionId <opaque-id> [--file <relative-path>] [--spaceId <id>] [--dryRun true\|false]`                                                                                                      | Use the trusted local server bridge to materialize a manifest-declared folder into normal SQL-backed Content                                                                      |
+| `resolve-local-folder-conflict`             | `--changeSetId <id> --decision keep_content\|accept_source [--sourceContent <text>]`                                                                                                               | Resolve a reviewed folder conflict; accepting requires the exact hashed folder revision                                                                                           |
+| `disconnect-local-folder-source`            | `--sourceId <id>`                                                                                                                                                                                  | Disconnect a folder adapter without deleting local files or its SQL-backed Content pages                                                                                          |
 | `list-builder-docs`                         | `[--model docs-content\|blog-article] [--limit <n>]`                                                                                                                                               | List Builder docs/blog entries available for `.builder.mdx` pull                                                                                                                  |
 | `pull-builder-doc`                          | `--model <model> --entryId <builder-entry-id> [--dryRun true\|false]`                                                                                                                              | Pull one Builder entry into Content and return `.builder.mdx` plus `content/builder/.raw` sidecar files                                                                           |
 | `check-builder-doc`                         | `--files <json> [--path <file.builder.mdx>]` or `--documentId <id>`                                                                                                                                | Validate Builder MDX round-trip, sidecar hashes, and remote conflict status before push                                                                                           |
@@ -112,7 +117,10 @@ cd templates/content && pnpm action <name> [args]
 | `remove-local-file-source`                  | `[--sourceRootPath <path>]`                                                                                                                                                                        | Unlink local-file sources from Content without deleting local Markdown/MDX files                                                                                                  |
 | `list-local-component-files`                |                                                                                                                                                                                                    | List registered local MDX component source files                                                                                                                                  |
 | `write-local-component-file`                | `--workspaceId <id> --path <relative-component-path> --content <source>`                                                                                                                           | Create or update a file in a registered local `components/` folder                                                                                                                |
-| `create-content-database`                   | `[--documentId <id>] [--parentId <id>] [--title <text>] [--description <text>]`                                                                                                                    | Create a described database page or convert an existing page into a database                                                                                                      |
+| `ensure-content-spaces`                     |                                                                                                                                                                                                    | Idempotently provision the signed-in user's personal and current organization Content spaces, system databases, and catalog references                                            |
+| `backfill-content-files`                    |                                                                                                                                                                                                    | Assign legacy pages to Content spaces and reconcile exactly one canonical Files database membership per non-system page                                                           |
+| `list-content-spaces`                       |                                                                                                                                                                                                    | List already-provisioned Content spaces authorized by the signed-in user's current ownership or organization memberships                                                          |
+| `create-content-database`                   | `[--documentId <id>] [--spaceId <id>] [--parentId <id>] [--title <text>] [--description <text>]`                                                                                                   | Create a described database page in a Content space or convert an existing page into a database                                                                                   |
 | `create-inline-content-database`            | `--hostDocumentId <id> [--title <text>] [--description <text>]`                                                                                                                                    | Create a described database owned by an inline database block in the host document                                                                                                |
 | `get-content-database`                      | `--databaseId <id>` or `--documentId <id>`                                                                                                                                                         | Get a database with its description, property/option schema guidance, item pages, and computed ancestry context                                                                   |
 | `list-trashed-content-databases`            |                                                                                                                                                                                                    | List soft-deleted databases visible in the sidebar Trash surface                                                                                                                  |
@@ -193,37 +201,24 @@ strip of the markdown.
 
 ### Local Source Files
 
-Content has two file workflows:
+Content has one database-backed document model with optional folder sources:
 
-- **Database mode local folders:** the `/local-files` view links one or more
+- **Local folder sources:** the `/local-files` view links one or more
   browser or Agent Native Desktop folders to SQL-backed documents. The UI uses
-  folder rows: **Pull** reads local `.md`/`.mdx` files through
-  `import-content-source`, **Check** runs the same import as `--dryRun true`,
-  and **Push** uses `export-content-source` to write Content documents back to
-  the chosen folder. Files with known `id` values update existing docs only
-  when the caller has editor access, and files without ids create new private
-  docs for the current user. Imported rows keep `source.mode: "local-files"`
-  and `source.path`, so `list-documents`/`get-document` can distinguish them
-  from ordinary private pages and the sidebar can show them under Local files.
-  With one linked folder, imported paths stay flat (`content/page.mdx`); with
-  multiple linked folders, paths are prefixed by folder name so Local files can
-  group them by folder. Once a source folder is linked, the selected
-  `.md`/`.mdx` file is authoritative: opening the page reads the file, editor
-  saves write the file first, and SQL is updated afterward as
-  cache/history/search glue. Use `--dryRun true` before a large import when the
-  source folder may contain unexpected files.
-- **Local File Mode editing:** when the app runs with `AGENT_NATIVE_MODE=local-files`
-  or an `agent-native.json` whose app config enables local files, the standard
-  Content editor reads and writes configured repo files directly. The left
-  sidebar is populated from local roots such as `docs/`, `blog/`, `content/`,
-  and `resources/`; selecting a file opens `/page/<local-file-id>` and
-  `update-document` writes the selected `.md`/`.mdx` file. The document id is
-  derived from the file path, and unknown frontmatter is preserved when title,
-  content, icon, or favorite state changes.
-  Repos can opt into `profile: "docs/no-bookkeeping"` to keep docs edits from
-  adding absent `updatedAt`, `icon`, or `isFavorite` frontmatter. Content-only
-  edits under that profile preserve existing frontmatter but do not create new
-  bookkeeping keys; explicit title/icon/favorite edits still persist.
+  folder rows: **Pull** calls `sync-local-folder-source`, **Check** runs the
+  same action with `dryRun: true`, and **Push** uses the source-scoped
+  `export-content-source`. Imported files become ordinary SQL documents in the
+  target space's canonical Files database. Preserve frontmatter `id` across
+  renames; missing files and concurrent changes become reviewable incoming
+  change sets instead of silently deleting or overwriting a page. SQL stores
+  only opaque connection identity, relative paths, and hashes. Disconnecting a
+  folder keeps both the Content pages and disk files.
+- **Manifest/CLI bridge:** `agent-native content local-files <target>` remains
+  as a compatibility spelling, but it launches normal database-backed Content.
+  `agent-native.json` declares `source.type: "local-folder"` and an opaque
+  `connectionId`; it does not select a separate application mode. The trusted
+  local server bridge materializes that source through
+  `sync-manifest-local-folder-source`.
 - **Local MDX components:** local file workspaces can expose React components
   from the configured `components` folder. Export PascalCase components such as
   `ImpactCounter` from `.tsx` files, then use `<ImpactCounter />` in MDX or pick

package/corpus/templates/content/actions/_builder-docs-client.ts

@@ -36,6 +36,12 @@ import {
   type BuilderCmsSourceEntry,
 } from "./_builder-cms-source-adapter.js";
 import { executeBuilderCmsWrite } from "./_builder-cms-write-client.js";
+import { ensureDocumentFilesMembership } from "./_content-files.js";
+import {
+  organizationContentSpaceId,
+  personalContentSpaceId,
+  provisionContentSpaces,
+} from "./_content-spaces.js";
 import { flushOpenDocumentEditorToSql } from "./_document-flush.js";
 
 type FetchLike = typeof fetch;
@@ -524,6 +530,17 @@ export async function pullBuilderDocIntoContent(args: {
   if (!ownerEmail) throw new Error("no authenticated user");
   const orgId = getRequestOrgId() ?? null;
   const db = getDb();
+  const provisioned = args.dryRun
+    ? null
+    : await provisionContentSpaces(db, ownerEmail);
+  const targetSpaceId = orgId
+    ? organizationContentSpaceId(orgId)
+    : personalContentSpaceId(ownerEmail);
+  if (provisioned && !provisioned.spaceIds.includes(targetSpaceId)) {
+    throw new Error(
+      "The active organization does not have a writable Content space.",
+    );
+  }
   const entry = await readFullBuilderDocsEntry({
     model: args.model,
     entryId: args.entryId,
@@ -554,6 +571,9 @@ export async function pullBuilderDocIntoContent(args: {
       `Requires editor access to update document "${documentId}".`,
     );
   }
+  if (existing?.spaceId && existing.spaceId !== targetSpaceId) {
+    throw new Error("Builder document belongs to a different Content space.");
+  }
 
   const sourceFields = builderDocumentSourceFields(bundle, now);
 
@@ -562,6 +582,7 @@ export async function pullBuilderDocIntoContent(args: {
       await db
         .update(schema.documents)
         .set({
+          spaceId: existing.spaceId ?? targetSpaceId,
           title: bundle.mdx.title,
           content: bundle.mdx.body,
           updatedAt: now,
@@ -571,6 +592,7 @@ export async function pullBuilderDocIntoContent(args: {
     } else {
       await db.insert(schema.documents).values({
         id: documentId,
+        spaceId: targetSpaceId,
         ownerEmail,
         orgId,
         parentId: null,
@@ -586,6 +608,7 @@ export async function pullBuilderDocIntoContent(args: {
         ...sourceFields,
       });
     }
+    await ensureDocumentFilesMembership(db, documentId, now);
     await replaceBuilderDocumentSidecars({
       db,
       documentId,

package/corpus/templates/content/actions/_content-database-source-adapters.ts

@@ -68,13 +68,31 @@ const notionDatabaseAdapter: ContentDatabaseSourceAdapter = {
   read: readNotionDatabaseSource,
 };
 
+const localFolderAdapter: ContentDatabaseSourceAdapter = {
+  sourceType: "local-folder",
+  async read() {
+    return {
+      state: "error",
+      entries: [],
+      fields: [],
+      fetchedAt: new Date().toISOString(),
+      message:
+        "Local folder refresh requires the trusted browser or Desktop bridge.",
+      metadata: { bridgeRequired: true },
+    };
+  },
+};
+
 const adapters = new Map<
   ContentDatabaseSourceType,
   ContentDatabaseSourceAdapter
 >(
-  [builderCmsAdapter, localTableAdapter, notionDatabaseAdapter].map(
-    (adapter) => [adapter.sourceType, adapter],
-  ),
+  [
+    builderCmsAdapter,
+    localTableAdapter,
+    notionDatabaseAdapter,
+    localFolderAdapter,
+  ].map((adapter) => [adapter.sourceType, adapter]),
 );
 
 export function getContentDatabaseSourceAdapter(

package/corpus/templates/content/actions/_content-files.ts

@@ -0,0 +1,338 @@
+import { createHash } from "node:crypto";
+
+import { accessFilter } from "@agent-native/core/sharing";
+import { and, eq, inArray, isNull, or, sql } from "drizzle-orm";
+
+import { schema } from "../server/db/index.js";
+import {
+  listContentOrganizationMemberships,
+  normalizeContentSpaceEmail,
+  resolveContentSpaceAccess,
+} from "./_content-space-access.js";
+import {
+  organizationContentSpaceId,
+  personalContentSpaceId,
+} from "./_content-spaces.js";
+
+type Db = any;
+
+export type ContentFilesReconciliation = {
+  assignedSpaces: number;
+  insertedMemberships: number;
+  removedMemberships: number;
+  documents: number;
+};
+
+export function contentFilesItemId(databaseId: string, documentId: string) {
+  return `content_database_item_${createHash("sha256")
+    .update(`${databaseId}:${documentId}`)
+    .digest("hex")
+    .slice(0, 32)}`;
+}
+
+async function remapItemReferences(db: Db, replacements: Map<string, string>) {
+  if (!replacements.size) return;
+  const duplicateIds = [...replacements.keys()];
+  const remap = (column: any) => {
+    let expression = sql`CASE ${column}`;
+    for (const [duplicateId, canonicalId] of replacements)
+      expression = sql`${expression} WHEN ${duplicateId} THEN ${canonicalId}`;
+    return sql`${expression} ELSE ${column} END`;
+  };
+  for (const table of [
+    schema.contentSpaceCatalogItems,
+    schema.contentDatabaseBodyHydrationQueue,
+    schema.contentDatabaseSourceRows,
+    schema.contentDatabaseSourceChangeSets,
+  ]) {
+    await db
+      .update(table)
+      .set({ databaseItemId: remap(table.databaseItemId) })
+      .where(inArray(table.databaseItemId, duplicateIds));
+  }
+}
+
+async function reconcileDocuments(args: {
+  db: Db;
+  documents: Array<typeof schema.documents.$inferSelect>;
+  filesDatabases: Array<typeof schema.contentDatabases.$inferSelect>;
+  now: string;
+}) {
+  const filesBySpace = new Map(
+    args.filesDatabases.map((database) => [database.spaceId, database]),
+  );
+  const filesDatabaseIds = args.filesDatabases.map((database) => database.id);
+  const filesBackingDocumentIds = new Set(
+    args.filesDatabases.map((database) => database.documentId),
+  );
+  const existingItems = filesDatabaseIds.length
+    ? await args.db
+        .select()
+        .from(schema.contentDatabaseItems)
+        .where(
+          inArray(schema.contentDatabaseItems.databaseId, filesDatabaseIds),
+        )
+    : [];
+  const itemsByDocument = new Map<
+    string,
+    Array<typeof schema.contentDatabaseItems.$inferSelect>
+  >();
+  const nextPosition = new Map<string, number>();
+  for (const item of existingItems) {
+    const documentItems = itemsByDocument.get(item.documentId) ?? [];
+    documentItems.push(item);
+    itemsByDocument.set(item.documentId, documentItems);
+    nextPosition.set(
+      item.databaseId,
+      Math.max(nextPosition.get(item.databaseId) ?? 0, item.position + 1),
+    );
+  }
+
+  const deleteIds = new Set<string>();
+  const replacements = new Map<string, string>();
+  const inserts: Array<typeof schema.contentDatabaseItems.$inferInsert> = [];
+  for (const document of args.documents) {
+    const existing = itemsByDocument.get(document.id) ?? [];
+    if (filesBackingDocumentIds.has(document.id)) {
+      for (const item of existing) deleteIds.add(item.id);
+      continue;
+    }
+    const canonicalDatabase = filesBySpace.get(document.spaceId);
+    if (!canonicalDatabase) {
+      throw new Error(
+        `Content space for document "${document.id}" has no Files database`,
+      );
+    }
+    const canonicalItems = existing
+      .filter((item) => item.databaseId === canonicalDatabase.id)
+      .sort((left, right) => left.id.localeCompare(right.id));
+    const canonicalItemId =
+      canonicalItems[0]?.id ??
+      contentFilesItemId(canonicalDatabase.id, document.id);
+    for (const item of existing) {
+      if (item.databaseId !== canonicalDatabase.id) {
+        deleteIds.add(item.id);
+        replacements.set(item.id, canonicalItemId);
+      }
+    }
+    for (const duplicate of canonicalItems.slice(1)) {
+      deleteIds.add(duplicate.id);
+      replacements.set(duplicate.id, canonicalItemId);
+    }
+    if (canonicalItems.length === 0) {
+      const position = nextPosition.get(canonicalDatabase.id) ?? 0;
+      nextPosition.set(canonicalDatabase.id, position + 1);
+      inserts.push({
+        id: contentFilesItemId(canonicalDatabase.id, document.id),
+        ownerEmail: document.ownerEmail,
+        orgId: document.orgId,
+        databaseId: canonicalDatabase.id,
+        documentId: document.id,
+        position,
+        createdAt: args.now,
+        updatedAt: args.now,
+      });
+    }
+  }
+  await remapItemReferences(args.db, replacements);
+  if (deleteIds.size) {
+    await args.db
+      .delete(schema.contentDatabaseItems)
+      .where(inArray(schema.contentDatabaseItems.id, [...deleteIds]));
+  }
+  if (inserts.length) {
+    await args.db
+      .insert(schema.contentDatabaseItems)
+      .values(inserts)
+      .onConflictDoNothing();
+  }
+  return { inserted: inserts.length, removed: deleteIds.size };
+}
+
+export async function ensureDocumentFilesMembership(
+  db: Db,
+  documentId: string,
+  now = new Date().toISOString(),
+  accessContext?: { userEmail?: string; orgId?: string },
+) {
+  const [document] = await db
+    .select()
+    .from(schema.documents)
+    .where(
+      and(
+        eq(schema.documents.id, documentId),
+        accessFilter(schema.documents, schema.documentShares, accessContext),
+      ),
+    );
+  if (!document) throw new Error(`Document "${documentId}" not found`);
+  if (!document.spaceId)
+    throw new Error(`Document "${documentId}" does not have a Content space`);
+  const filesDatabases = await db
+    .select()
+    .from(schema.contentDatabases)
+    .where(
+      and(
+        eq(schema.contentDatabases.systemRole, "files"),
+        eq(schema.contentDatabases.spaceId, document.spaceId),
+      ),
+    );
+  return reconcileDocuments({ db, documents: [document], filesDatabases, now });
+}
+
+export async function ensureDocumentsFilesMembership(
+  db: Db,
+  documentIds: string[],
+  now = new Date().toISOString(),
+  ownerEmail?: string,
+) {
+  const ids = [...new Set(documentIds)];
+  if (ids.length === 0) return { inserted: 0, removed: 0 };
+  const documents = await db
+    .select()
+    .from(schema.documents)
+    .where(
+      and(
+        inArray(schema.documents.id, ids),
+        ownerEmail
+          ? or(
+              eq(schema.documents.ownerEmail, ownerEmail),
+              accessFilter(schema.documents, schema.documentShares),
+            )
+          : accessFilter(schema.documents, schema.documentShares),
+      ),
+    );
+  if (documents.length !== ids.length) {
+    const found = new Set(documents.map((document: any) => document.id));
+    const missing = ids.filter((id) => !found.has(id));
+    throw new Error(`Documents not found: ${missing.join(", ")}`);
+  }
+  for (const document of documents) {
+    if (!document.spaceId) {
+      throw new Error(
+        `Document "${document.id}" does not have a Content space`,
+      );
+    }
+  }
+  const spaceIds: string[] = Array.from(
+    new Set<string>(documents.map((document: any) => String(document.spaceId))),
+  );
+  const filesDatabases = await db
+    .select()
+    .from(schema.contentDatabases)
+    .where(
+      and(
+        eq(schema.contentDatabases.systemRole, "files"),
+        or(
+          ...spaceIds.map((spaceId) =>
+            eq(schema.contentDatabases.spaceId, spaceId),
+          ),
+        ),
+      ),
+    );
+  return reconcileDocuments({ db, documents, filesDatabases, now });
+}
+
+export async function reconcileContentFilesMemberships(
+  db: Db,
+  userEmail: string,
+): Promise<ContentFilesReconciliation> {
+  const email = normalizeContentSpaceEmail(userEmail);
+  const memberships = await listContentOrganizationMemberships(email);
+  const personalSpaceId = personalContentSpaceId(email);
+  const orgSpaceIds = new Map<string, string>();
+  for (const membership of memberships) {
+    const spaceId = organizationContentSpaceId(membership.orgId);
+    try {
+      await resolveContentSpaceAccess(spaceId, "editor");
+      orgSpaceIds.set(membership.orgId, spaceId);
+    } catch (error) {
+      if (
+        error instanceof Error &&
+        error.message ===
+          `Editor access is required for Content space "${spaceId}"`
+      ) {
+        continue;
+      }
+      throw error;
+    }
+  }
+  const accessibleSpaceIds = [personalSpaceId, ...orgSpaceIds.values()];
+  const now = new Date().toISOString();
+  const result: ContentFilesReconciliation = {
+    assignedSpaces: 0,
+    insertedMemberships: 0,
+    removedMemberships: 0,
+    documents: 0,
+  };
+
+  await db.transaction(async (tx: Db) => {
+    const personalLegacyDocuments = await tx
+      .select({ id: schema.documents.id })
+      .from(schema.documents)
+      .where(
+        and(
+          eq(schema.documents.ownerEmail, email),
+          isNull(schema.documents.orgId),
+          isNull(schema.documents.spaceId),
+        ),
+      );
+    if (personalLegacyDocuments.length) {
+      await tx
+        .update(schema.documents)
+        .set({ spaceId: personalSpaceId, updatedAt: now })
+        .where(
+          inArray(
+            schema.documents.id,
+            personalLegacyDocuments.map((row: any) => row.id),
+          ),
+        );
+      result.assignedSpaces += personalLegacyDocuments.length;
+    }
+    for (const [orgId, spaceId] of orgSpaceIds) {
+      const legacyDocuments = await tx
+        .select({ id: schema.documents.id })
+        .from(schema.documents)
+        .where(
+          and(
+            eq(schema.documents.orgId, orgId),
+            isNull(schema.documents.spaceId),
+          ),
+        );
+      if (!legacyDocuments.length) continue;
+      await tx
+        .update(schema.documents)
+        .set({ spaceId, updatedAt: now })
+        .where(
+          inArray(
+            schema.documents.id,
+            legacyDocuments.map((row: any) => row.id),
+          ),
+        );
+      result.assignedSpaces += legacyDocuments.length;
+    }
+
+    const documents = await tx
+      .select()
+      .from(schema.documents)
+      .where(inArray(schema.documents.spaceId, accessibleSpaceIds));
+    const filesDatabases = await tx
+      .select()
+      .from(schema.contentDatabases)
+      .where(
+        and(
+          eq(schema.contentDatabases.systemRole, "files"),
+          inArray(schema.contentDatabases.spaceId, accessibleSpaceIds),
+        ),
+      );
+    const membershipResult = await reconcileDocuments({
+      db: tx,
+      documents,
+      filesDatabases,
+      now,
+    });
+    result.documents = documents.length;
+    result.insertedMemberships = membershipResult.inserted;
+    result.removedMemberships = membershipResult.removed;
+  });
+  return result;
+}