diff --git a/.changeset/reliable-mcp-operation-results.md b/.changeset/reliable-mcp-operation-results.md
new file mode 100644
index 00000000000..8b84cf51549
--- /dev/null
+++ b/.changeset/reliable-mcp-operation-results.md
@@ -0,0 +1,5 @@
+---
+"@agent-native/core": patch
+---
+
+Preserve complete structured MCP action results for clients without inline apps, so mutation receipts remain available when display text is shortened.
diff --git a/.changeset/static-registry-audit-tools.md b/.changeset/static-registry-audit-tools.md
new file mode 100644
index 00000000000..bae1938562f
--- /dev/null
+++ b/.changeset/static-registry-audit-tools.md
@@ -0,0 +1,5 @@
+---
+"@agent-native/core": patch
+---
+
+Include core actions in the agent tool catalog when an app supplies a static action registry, so audit history remains discoverable while respecting disabled framework tool groups.
diff --git a/packages/core/src/action.ts b/packages/core/src/action.ts
index 151ac3d07b3..c1549e55cfb 100644
--- a/packages/core/src/action.ts
+++ b/packages/core/src/action.ts
@@ -437,6 +437,8 @@ export interface ActionMcpAppResourceConfig {
 }
 
 export interface ActionMcpAppConfig {
+  /** Preserve the sanitized object result alongside concise text, even without an inline app. Use for durable mutation receipts. */
+  structuredContent?: boolean;
   /**
    * Optional MCP Apps UI resource for hosts that render inline app iframes.
    * Required when the action should open an interactive app view. Omit when
@@ -1125,7 +1127,11 @@ export function defineAction(options: any) {
       return undefined;
     }
     // compactCatalog-only: no resource required; just keep the flag.
-    if (options.mcpApp.compactCatalog === true && !options.mcpApp.resource) {
+    if (
+      (options.mcpApp.compactCatalog === true ||
+        options.mcpApp.structuredContent === true) &&
+      !options.mcpApp.resource
+    ) {
       return options.mcpApp as ActionMcpAppConfig;
     }
     // Full resource: validate html is present.
diff --git a/packages/core/src/agent/production-agent.spec.ts b/packages/core/src/agent/production-agent.spec.ts
index 9abe5342d0b..7d6c04b5130 100644
--- a/packages/core/src/agent/production-agent.spec.ts
+++ b/packages/core/src/agent/production-agent.spec.ts
@@ -1278,6 +1278,39 @@ describe("buildUserContentWithAttachments", () => {
     expect(writeTool.description).toContain("Plan mode blocked");
   });
 
+  it("keeps object-only union actions available to the in-app agent", () => {
+    const anyOf = [
+      {
+        type: "object",
+        properties: { operation: { const: "create" } },
+        required: ["operation"],
+      },
+      {
+        type: "object",
+        properties: { operation: { const: "update" } },
+        required: ["operation"],
+      },
+    ];
+    const tools = actionsToEngineTools({
+      setup: {
+        tool: {
+          description: "Configure a database",
+          parameters: { anyOf } as any,
+        },
+        run: async () => ({}),
+      },
+      scalar: {
+        tool: {
+          description: "Invalid tool",
+          parameters: { type: "string" } as any,
+        },
+        run: async () => ({}),
+      },
+    });
+    expect(tools.map((tool) => tool.name)).toEqual(["setup"]);
+    expect(tools[0].inputSchema).toMatchObject({ type: "object", anyOf });
+  });
+
   it("keeps the default initial catalog to discovery/runtime tools", () => {
     const tools = actionsToEngineTools(
       attachToolSearch({
diff --git a/packages/core/src/agent/production-agent.ts b/packages/core/src/agent/production-agent.ts
index ce15505a0d1..2e4d4c16095 100644
--- a/packages/core/src/agent/production-agent.ts
+++ b/packages/core/src/agent/production-agent.ts
@@ -40,6 +40,7 @@ import { preUploadAttachments } from "../file-upload/pre-upload-attachments.js";
 import { isMcpActionResult } from "../mcp-client/app-result.js";
 import { extractMcpToolResultImages } from "../mcp-client/index.js";
 import { isMcpToolAllowedForRequest } from "../mcp-client/visibility.js";
+import { isObjectOnly } from "../mcp/tool-input-schema.js";
 import { shouldInferSentimentForTurn } from "../observability/sentiment.js";
 import {
   completeRun as completeProgressRun,
@@ -3744,7 +3745,7 @@ function normalizeToolInputSchema(
   schema: ActionTool["parameters"] | undefined,
 ): EngineTool["inputSchema"] | null {
   if (!schema) return { type: "object", properties: {} };
-  if (schema.type !== "object") return null;
+  if (!isObjectOnly(schema)) return null;
   type ToolParams = NonNullable<ActionTool["parameters"]>;
   let cloned: ToolParams;
   try {
diff --git a/packages/core/src/mcp/build-server.ts b/packages/core/src/mcp/build-server.ts
index 454bf45ca8a..34f0e46ef7a 100644
--- a/packages/core/src/mcp/build-server.ts
+++ b/packages/core/src/mcp/build-server.ts
@@ -2388,8 +2388,9 @@ export async function createMCPServerForRequest(
             Array.isArray(toolVisibility) &&
             toolVisibility.length > 0 &&
             toolVisibility.every((v) => v === "app");
-          const readOnlyStructuredResult =
-            entry.readOnly === true &&
+          const structuredResult =
+            (entry.readOnly === true ||
+              entry.mcpApp?.structuredContent === true) &&
             rawResultForClient &&
             typeof rawResultForClient === "object"
               ? Array.isArray(rawResultForClient)
@@ -2403,11 +2404,8 @@ export async function createMCPServerForRequest(
                 typeof rawResult === "object" &&
                 !Array.isArray(rawResult)
               ? (rawResult as Record<string, unknown>)
-              : readOnlyStructuredResult
-                ? mcpAppStructuredContent(
-                    readOnlyStructuredResult,
-                    responseMeta,
-                  )
+              : structuredResult
+                ? mcpAppStructuredContent(structuredResult, responseMeta)
                 : undefined;
           const text = mcpAppResource
             ? conciseMcpAppToolText(name, resultForClient, structuredContent!)
diff --git a/packages/core/src/mcp/server.spec.ts b/packages/core/src/mcp/server.spec.ts
index fe8db8e86c3..45e02e28dbb 100644
--- a/packages/core/src/mcp/server.spec.ts
+++ b/packages/core/src/mcp/server.spec.ts
@@ -3871,22 +3871,20 @@ describe("handleMcpRequest — web-standard runtime fallback (no Node req/res)",
     expect(out.result.content[0].text).not.toContain("embed-session-ticket");
   });
 
-  it("does NOT surface raw result via structuredContent for model-visible (non-app-only) tools", async () => {
-    // Counter-regression: only `visibility: ["app"]` tools get the raw
-    // structuredContent escape hatch. Tools the LLM can call must continue
-    // to go through the normal text + purge path so embed-start URLs and
-    // other internal fields stay hidden from the model.
+  it("preserves complete mutation receipts while sanitizing model-visible structured results", async () => {
     const embedConfig = {
       ...config,
       actions: {
         "model-callable-helper": {
+          mcpApp: { structuredContent: true },
           tool: {
             description: "A normal model-visible tool",
             // No `visibility` hint = model + app visible.
           },
           run: async () => ({
             startUrl: "/_agent-native/embed/start?ticket=should-be-hidden",
-            payload: "ok",
+            payload: "x".repeat(3000),
+            receipt: { id: "operation-42", verified: true },
           }),
         },
       },
@@ -3906,7 +3904,13 @@ describe("handleMcpRequest — web-standard runtime fallback (no Node req/res)",
     );
 
     expect(out.error).toBeUndefined();
-    expect(out.result.structuredContent).toBeUndefined();
+    expect(out.result.structuredContent).toEqual({
+      payload: "x".repeat(3000),
+      receipt: { id: "operation-42", verified: true },
+    });
+    expect(JSON.stringify(out.result.structuredContent)).not.toContain(
+      "should-be-hidden",
+    );
     expect(out.result.content[0].text).not.toContain("should-be-hidden");
   });
 
diff --git a/packages/core/src/mcp/tool-input-schema.ts b/packages/core/src/mcp/tool-input-schema.ts
index ec915118327..4859aa1e0b8 100644
--- a/packages/core/src/mcp/tool-input-schema.ts
+++ b/packages/core/src/mcp/tool-input-schema.ts
@@ -1,6 +1,6 @@
 import type { Tool } from "@modelcontextprotocol/server";
 
-function isObjectOnly(
+export function isObjectOnly(
   schema: unknown,
   ancestors = new Set<unknown>(),
 ): boolean {
diff --git a/packages/core/src/server/action-discovery.spec.ts b/packages/core/src/server/action-discovery.spec.ts
index f89e16ed773..8a7d68d714b 100644
--- a/packages/core/src/server/action-discovery.spec.ts
+++ b/packages/core/src/server/action-discovery.spec.ts
@@ -4,7 +4,10 @@ import path from "node:path";
 
 import { afterEach, describe, expect, it } from "vitest";
 
-import { resolveFrameworkTools } from "../framework-tools.js";
+import {
+  filterFrameworkToolGroups,
+  resolveFrameworkTools,
+} from "../framework-tools.js";
 import {
   ALWAYS_ON_CORE_ACTIONS,
   autoDiscoverActions,
@@ -68,6 +71,29 @@ describe("action discovery", () => {
     expect(registry["mutating-read"].readOnly).toBe(false);
   });
 
+  it(
+    "makes audit reads available with a static registry while respecting disabled groups",
+    async () => {
+      const registry = loadActionsFromStaticRegistry({});
+      await mergeCoreSharingActions(registry);
+      const enabled = filterFrameworkToolGroups(
+        registry,
+        resolveFrameworkTools({}).disabledGroups,
+      );
+      const disabled = filterFrameworkToolGroups(
+        registry,
+        resolveFrameworkTools({ frameworkTools: { audit: false } })
+          .disabledGroups,
+      );
+      for (const name of ["list-audit-events", "get-audit-event"]) {
+        expect(enabled[name]?.readOnly).toBe(true);
+        expect(disabled[name]).toBeUndefined();
+        expect(registry[name]).toBeDefined();
+      }
+    },
+    CORE_ACTION_DISCOVERY_TIMEOUT_MS,
+  );
+
   it("preserves grounding metadata from static action entries", () => {
     const registry = loadActionsFromStaticRegistry({
       "grounded-query": {
diff --git a/packages/core/src/server/agent-chat-plugin.surface.spec.ts b/packages/core/src/server/agent-chat-plugin.surface.spec.ts
index a42acf268bf..c0f6f05ae1f 100644
--- a/packages/core/src/server/agent-chat-plugin.surface.spec.ts
+++ b/packages/core/src/server/agent-chat-plugin.surface.spec.ts
@@ -542,6 +542,16 @@ describe("framework tool gating — wiring guards", () => {
     encoding: "utf-8",
   });
 
+  it("merges core actions before filtering an explicit agent registry", () => {
+    const merge = source.indexOf(
+      "await mergeCoreSharingActions(templateScriptsAll);",
+    );
+    expect(merge).toBeGreaterThan(source.indexOf("const rawActions ="));
+    expect(merge).toBeLessThan(
+      source.indexOf("filterAgentTools(templateScriptsAll)"),
+    );
+  });
+
   it("resolves the framework tool surface once and gates both agent registries", () => {
     expect(source).toContain(
       "const frameworkTools = resolveFrameworkTools(options);",
diff --git a/packages/core/src/server/agent-chat-plugin.ts b/packages/core/src/server/agent-chat-plugin.ts
index 237a4032bf6..0702e3d5ff9 100644
--- a/packages/core/src/server/agent-chat-plugin.ts
+++ b/packages/core/src/server/agent-chat-plugin.ts
@@ -934,6 +934,8 @@ export function createAgentChatPlugin(
       } catch {
         // Package action registration is optional.
       }
+      const { mergeCoreSharingActions } = await import("./action-discovery.js");
+      await mergeCoreSharingActions(templateScriptsAll);
 
       // Resource, chat, docs, db, and cross-agent scripts are available in both
       // prod and dev modes, unless the app switched the group off through
diff --git a/scripts/guard-db-tool-scoping.mjs b/scripts/guard-db-tool-scoping.mjs
index 17e770f3354..d388dd0a132 100644
--- a/scripts/guard-db-tool-scoping.mjs
+++ b/scripts/guard-db-tool-scoping.mjs
@@ -47,6 +47,8 @@ const SKIP_DIRS = new Set([
 // access is mediated through a scoped parent, custom action, public token, or
 // cache pathway. Key format: "<template>:<sql_table_name>".
 const INTENTIONAL_RAW_DB_DENYLIST = {
+  "content:content_database_setup_receipts":
+    "actor-scoped retry receipts; access is rechecked through database setup actions",
   "analytics:bigquery_cache": "provider cache, not a user-facing resource",
   "analytics:first_party_analytics_cache":
     "internal query cache, accessed through scoped analytics queries",
diff --git a/templates/content/.agents/skills/document-editing/references/databases.md b/templates/content/.agents/skills/document-editing/references/databases.md
index e3262787a2b..55efe9f10c6 100644
--- a/templates/content/.agents/skills/document-editing/references/databases.md
+++ b/templates/content/.agents/skills/document-editing/references/databases.md
@@ -67,6 +67,31 @@ still reads as the active context. In table views, clicking a row title opens
 that side preview; inline title editing lives behind the hover pencil
 affordance.
 
+## Ordinary database setup through MCP
+
+Resolve an exact authorized space before creating an ordinary database. Creation,
+safe property edits, saved table-view edits, and recoverable database Trash/restore
+use caller intent keys and verified receipts. Repeat an unchanged request with its
+original key after a lost response; a different payload needs a different key.
+
+Database discovery returns the mutation target, schema revision, configuration
+revision, supported setup operations, and field write restrictions. Use these
+fresh values for the next mutation. Stale revisions require a read and a new
+decision, not an automatic overwrite. Property and view names are labels; their
+stable IDs identify edits. Sparse patches preserve omitted fields, and empty
+lists explicitly clear supported settings.
+
+Ordinary setup supports stored property types, additive options, metadata edits,
+the existing text natural key, and table presentation. It refuses destructive
+type/option changes, source-managed schema edits, and relationship/computed-field
+authoring. Source status is readable, but this surface does not define joins,
+row unions, source bindings, or write-mode changes. Discovery of a source-backed
+row never establishes permission to write its fields.
+
+Read back each changed object separately, then use its Open in Content link.
+Rows retain both membership and Page identity in their links. Trash remains
+recoverable; never substitute permanent deletion for ordinary cleanup.
+
 ## Property types
 
 Document properties are SQL-backed, Notion-style structured metadata rather
diff --git a/templates/content/actions/_content-space-access.ts b/templates/content/actions/_content-space-access.ts
index c233132dab5..b5a37f02446 100644
--- a/templates/content/actions/_content-space-access.ts
+++ b/templates/content/actions/_content-space-access.ts
@@ -1,3 +1,4 @@
+import { ActionContractError } from "@agent-native/core/action";
 import { getDbExec } from "@agent-native/core/db";
 import { getRequestUserEmail } from "@agent-native/core/server/request-context";
 import { and, eq, isNull, sql } from "drizzle-orm";
@@ -22,7 +23,11 @@ type ContentOrganizationMembership = {
 
 export function normalizeContentSpaceEmail(email: string): string {
   const normalized = email.trim().toLowerCase();
-  if (!normalized) throw new Error("no authenticated user");
+  if (!normalized)
+    throw new ActionContractError("Sign in to select a Content space.", {
+      errorCode: "UNAUTHORIZED",
+      statusCode: 401,
+    });
   return normalized;
 }
 
@@ -190,18 +195,28 @@ export async function resolveContentSpaceAccess(
   options: { db?: any } = {},
 ): Promise<ContentSpaceAccess> {
   const userEmail = getRequestUserEmail();
-  if (!userEmail) throw new Error("no authenticated user");
+  if (!userEmail)
+    throw new ActionContractError("Sign in to select a Content space.", {
+      errorCode: "UNAUTHORIZED",
+      statusCode: 401,
+    });
   const normalizedUserEmail = normalizeContentSpaceEmail(userEmail);
   const [space] = await (options.db ?? getDb())
     .select()
     .from(schema.contentSpaces)
     .where(eq(schema.contentSpaces.id, spaceId));
   if (!space || space.archivedAt)
-    throw new Error(`Content space "${spaceId}" not found`);
+    throw new ActionContractError("Content space not found.", {
+      errorCode: "SPACE_NOT_FOUND",
+      statusCode: 404,
+    });
 
   if (!space.orgId) {
     if (normalizeContentSpaceEmail(space.ownerEmail) !== normalizedUserEmail) {
-      throw new Error(`Not authorized for Content space "${spaceId}"`);
+      throw new ActionContractError("Content space not found.", {
+        errorCode: "SPACE_NOT_FOUND",
+        statusCode: 404,
+      });
     }
     return {
       space,
@@ -216,7 +231,10 @@ export async function resolveContentSpaceAccess(
     options,
   );
   if (!membership)
-    throw new Error(`Not authorized for Content space "${spaceId}"`);
+    throw new ActionContractError("Content space not found.", {
+      errorCode: "SPACE_NOT_FOUND",
+      statusCode: 404,
+    });
   const role: ContentSpaceRole =
     membership.role === "owner"
       ? "owner"
@@ -229,12 +247,16 @@ export async function resolveContentSpaceAccess(
     membership.role !== "admin" &&
     membership.role !== "member"
   ) {
-    throw new Error(
-      `Contributor access is required for Content space "${spaceId}"`,
+    throw new ActionContractError(
+      "Contributor access is required for this Content space.",
+      { errorCode: "FORBIDDEN", statusCode: 403 },
     );
   }
   if (requiredRole === "editor" && role === "viewer") {
-    throw new Error(`Editor access is required for Content space "${spaceId}"`);
+    throw new ActionContractError(
+      "Editor access is required for this Content space.",
+      { errorCode: "FORBIDDEN", statusCode: 403 },
+    );
   }
   return {
     space,
diff --git a/templates/content/actions/_database-property-setup.ts b/templates/content/actions/_database-property-setup.ts
new file mode 100644
index 00000000000..dee5fa35fc5
--- /dev/null
+++ b/templates/content/actions/_database-property-setup.ts
@@ -0,0 +1,596 @@
+import { and, eq, sql } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import {
+  DOCUMENT_PROPERTY_VISIBILITIES,
+  parsePropertyOptions,
+  serializePropertyOptions,
+  normalizePropertyVisibility,
+  type DocumentPropertyOption,
+  type DocumentPropertyOptions,
+  type DocumentPropertyType,
+} from "../shared/properties.js";
+import { type MutationContext } from "./_database-row-mutation.js";
+import {
+  runDatabaseSetupMutation,
+  setupError,
+  setupGuardSchema,
+} from "./_database-setup-mutation.js";
+import { nanoid } from "./_property-utils.js";
+
+export const ordinaryPropertyTypes = [
+  "text",
+  "number",
+  "select",
+  "multi_select",
+  "status",
+  "date",
+  "person",
+  "place",
+  "files_media",
+  "checkbox",
+  "url",
+  "email",
+  "phone",
+] as const;
+
+const optionPropertyTypes = ["select", "multi_select", "status"] as const;
+const nonOptionPropertyTypes = [
+  "number",
+  "date",
+  "person",
+  "place",
+  "files_media",
+  "checkbox",
+  "url",
+  "email",
+  "phone",
+] as const;
+
+const optionColorSchema = z.enum([
+  "gray",
+  "brown",
+  "orange",
+  "yellow",
+  "green",
+  "blue",
+  "purple",
+  "pink",
+  "red",
+]);
+
+const propertyOptionSchema = z
+  .object({
+    id: z.string().trim().min(1).max(200),
+    name: z.string().trim().min(1).max(500),
+    color: optionColorSchema,
+    description: z.string().max(2_000).optional(),
+  })
+  .strict();
+
+const propertyDefinitionBase = z.object({
+  name: z.string().trim().min(1).max(500),
+  description: z.string().max(2_000).optional(),
+  visibility: z.enum(DOCUMENT_PROPERTY_VISIBILITIES).optional(),
+});
+
+const createDefinitionSchema = z.discriminatedUnion("type", [
+  propertyDefinitionBase
+    .extend({
+      type: z.literal("text"),
+      naturalKey: z.boolean().optional(),
+    })
+    .strict(),
+  propertyDefinitionBase
+    .extend({
+      type: z.enum(optionPropertyTypes),
+      options: z.array(propertyOptionSchema).max(100).optional(),
+    })
+    .strict(),
+  propertyDefinitionBase
+    .extend({ type: z.enum(nonOptionPropertyTypes) })
+    .strict(),
+]);
+
+const optionEditSchema = z.discriminatedUnion("operation", [
+  z
+    .object({ operation: z.literal("add"), option: propertyOptionSchema })
+    .strict(),
+  z
+    .object({
+      operation: z.literal("update"),
+      optionId: z.string().trim().min(1).max(200),
+      patch: z
+        .object({
+          name: z.string().trim().min(1).max(500).optional(),
+          color: optionColorSchema.optional(),
+          description: z.string().max(2_000).optional(),
+        })
+        .strict()
+        .refine(
+          (patch) => Object.keys(patch).length > 0,
+          "Option patch cannot be empty",
+        ),
+    })
+    .strict(),
+  z
+    .object({
+      operation: z.literal("reorder"),
+      optionIds: z.array(z.string().trim().min(1).max(200)).max(100),
+    })
+    .strict(),
+]);
+
+const updatePatchSchema = z
+  .object({
+    name: z.string().trim().min(1).max(500).optional(),
+    description: z.string().max(2_000).optional(),
+    visibility: z.enum(DOCUMENT_PROPERTY_VISIBILITIES).optional(),
+    optionEdits: z.array(optionEditSchema).max(100).optional(),
+    naturalKey: z.boolean().optional(),
+  })
+  .strict()
+  .refine(
+    (patch) => Object.keys(patch).length > 0,
+    "Property patch cannot be empty",
+  );
+
+export const configureDocumentPropertyAgentSchema = z.discriminatedUnion(
+  "operation",
+  [
+    setupGuardSchema
+      .extend({
+        operation: z.literal("create"),
+        definition: createDefinitionSchema,
+      })
+      .strict(),
+    setupGuardSchema
+      .extend({
+        operation: z.literal("update"),
+        propertyId: z.string().trim().min(1).max(200),
+        patch: updatePatchSchema,
+      })
+      .strict(),
+  ],
+);
+
+export type ConfigureDocumentPropertyAgentInput = z.infer<
+  typeof configureDocumentPropertyAgentSchema
+>;
+
+type Db = ReturnType<typeof getDb>;
+type Definition = typeof schema.documentPropertyDefinitions.$inferSelect;
+
+function normalizedOptionName(value: string) {
+  return value.trim().toLocaleLowerCase();
+}
+
+function validateOptions(options: readonly DocumentPropertyOption[]) {
+  const ids = new Set<string>();
+  const names = new Set<string>();
+  for (const option of options) {
+    if (ids.has(option.id)) {
+      setupError(
+        "INVALID_INPUT",
+        `Option ID \"${option.id}\" is duplicated.`,
+        400,
+      );
+    }
+    const name = normalizedOptionName(option.name);
+    if (names.has(name)) {
+      setupError(
+        "INVALID_INPUT",
+        `Option name \"${option.name}\" is duplicated.`,
+        400,
+      );
+    }
+    ids.add(option.id);
+    names.add(name);
+  }
+}
+
+function applyOptionEdits(
+  definition: Definition,
+  edits: Extract<
+    ConfigureDocumentPropertyAgentInput,
+    { operation: "update" }
+  >["patch"]["optionEdits"],
+) {
+  if (!edits) return parsePropertyOptions(definition.optionsJson);
+  if (!(optionPropertyTypes as readonly string[]).includes(definition.type)) {
+    setupError(
+      "UNSUPPORTED_SCHEMA_CHANGE",
+      "Only select, multi-select, and status properties have editable options.",
+      400,
+    );
+  }
+  const current = parsePropertyOptions(definition.optionsJson);
+  let options = [...(current.options ?? [])];
+  for (const edit of edits) {
+    if (edit.operation === "add") {
+      if (options.some((option) => option.id === edit.option.id)) {
+        setupError(
+          "INVALID_INPUT",
+          `Option ID \"${edit.option.id}\" already exists.`,
+          400,
+        );
+      }
+      options.push(edit.option);
+    } else if (edit.operation === "update") {
+      const index = options.findIndex((option) => option.id === edit.optionId);
+      if (index < 0) {
+        setupError(
+          "INVALID_INPUT",
+          `Option \"${edit.optionId}\" does not exist.`,
+          400,
+        );
+      }
+      options[index] = { ...options[index]!, ...edit.patch };
+    } else {
+      if (
+        edit.optionIds.length !== options.length ||
+        new Set(edit.optionIds).size !== options.length ||
+        edit.optionIds.some((id) => !options.some((option) => option.id === id))
+      ) {
+        setupError(
+          "UNSUPPORTED_SCHEMA_CHANGE",
+          "Option reorder must include every existing option ID exactly once.",
+          400,
+        );
+      }
+      const byId = new Map(options.map((option) => [option.id, option]));
+      options = edit.optionIds.map((id) => byId.get(id)!);
+    }
+    validateOptions(options);
+  }
+  return { ...current, options } satisfies DocumentPropertyOptions;
+}
+
+function canonicalProperty(definition: Definition, context: MutationContext) {
+  return {
+    id: definition.id,
+    databaseId: definition.databaseId,
+    systemRole: definition.systemRole,
+    name: definition.name,
+    type: definition.type as DocumentPropertyType,
+    description: definition.description,
+    visibility: normalizePropertyVisibility(definition.visibility),
+    options: parsePropertyOptions(definition.optionsJson),
+    position: definition.position,
+    naturalKey: context.database.naturalKeyPropertyId === definition.id,
+    createdAt: definition.createdAt,
+    updatedAt: definition.updatedAt,
+  };
+}
+
+async function readDefinition(tx: Db, databaseId: string, propertyId: string) {
+  const [definition] = await tx
+    .select()
+    .from(schema.documentPropertyDefinitions)
+    .where(
+      and(
+        eq(schema.documentPropertyDefinitions.id, propertyId),
+        eq(schema.documentPropertyDefinitions.databaseId, databaseId),
+      ),
+    );
+  if (!definition) {
+    setupError(
+      "NOT_FOUND_OR_INACCESSIBLE",
+      "The property is unavailable.",
+      404,
+    );
+  }
+  return definition;
+}
+
+async function configureNaturalKey(
+  tx: Db,
+  context: MutationContext,
+  propertyId: string,
+  naturalKey: boolean | undefined,
+) {
+  if (naturalKey === undefined) return;
+  if (!naturalKey) {
+    if (context.database.naturalKeyPropertyId !== propertyId) return;
+    await tx
+      .delete(schema.contentDatabaseItemKeyClaims)
+      .where(
+        and(
+          eq(
+            schema.contentDatabaseItemKeyClaims.databaseId,
+            context.database.id,
+          ),
+          eq(schema.contentDatabaseItemKeyClaims.propertyId, propertyId),
+        ),
+      );
+    await tx
+      .update(schema.contentDatabases)
+      .set({ naturalKeyPropertyId: null, updatedAt: new Date().toISOString() })
+      .where(eq(schema.contentDatabases.id, context.database.id));
+    return;
+  }
+
+  const definition = await readDefinition(tx, context.database.id, propertyId);
+  if (definition.type !== "text") {
+    setupError(
+      "UNSUPPORTED_SCHEMA_CHANGE",
+      "A database natural key must be an ordinary text property.",
+      400,
+    );
+  }
+  if (context.sourceManagedPropertyIds.has(propertyId)) {
+    setupError(
+      "SOURCE_MANAGED_PROPERTY",
+      "A source-managed property cannot be a natural key.",
+      400,
+    );
+  }
+  if (
+    context.database.naturalKeyPropertyId &&
+    context.database.naturalKeyPropertyId !== propertyId
+  ) {
+    setupError(
+      "NATURAL_KEY_CONFLICT",
+      "Clear the existing natural key before configuring another one.",
+    );
+  }
+  const values = await tx
+    .select({
+      valueJson: schema.documentPropertyValues.valueJson,
+      itemId: schema.contentDatabaseItems.id,
+      documentId: schema.contentDatabaseItems.documentId,
+    })
+    .from(schema.contentDatabaseItems)
+    .innerJoin(
+      schema.documentPropertyValues,
+      and(
+        eq(
+          schema.documentPropertyValues.documentId,
+          schema.contentDatabaseItems.documentId,
+        ),
+        eq(schema.documentPropertyValues.propertyId, propertyId),
+      ),
+    )
+    .where(eq(schema.contentDatabaseItems.databaseId, context.database.id));
+  const claims = new Map<string, (typeof values)[number]>();
+  for (const value of values) {
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(value.valueJson);
+    } catch {
+      setupError(
+        "NATURAL_KEY_CONFLICT",
+        "Natural key values must be readable strings.",
+        400,
+      );
+    }
+    if (parsed === null || parsed === "") continue;
+    if (typeof parsed !== "string" || !parsed.trim()) {
+      setupError(
+        "NATURAL_KEY_CONFLICT",
+        "Natural key values must be non-empty strings.",
+        400,
+      );
+    }
+    if (claims.has(value.valueJson)) {
+      setupError(
+        "NATURAL_KEY_CONFLICT",
+        "A natural key value belongs to more than one row.",
+        409,
+      );
+    }
+    claims.set(value.valueJson, value);
+  }
+  await tx
+    .delete(schema.contentDatabaseItemKeyClaims)
+    .where(
+      and(
+        eq(schema.contentDatabaseItemKeyClaims.databaseId, context.database.id),
+        eq(schema.contentDatabaseItemKeyClaims.propertyId, propertyId),
+      ),
+    );
+  if (claims.size > 0) {
+    const now = new Date().toISOString();
+    await tx.insert(schema.contentDatabaseItemKeyClaims).values(
+      [...claims.entries()].map(([keyValueJson, value]) => ({
+        id: nanoid(),
+        ownerEmail: context.database.ownerEmail,
+        orgId: context.database.orgId,
+        databaseId: context.database.id,
+        propertyId,
+        keyValueJson,
+        itemId: value.itemId,
+        documentId: value.documentId,
+        createdAt: now,
+        updatedAt: now,
+      })),
+    );
+  }
+  await tx
+    .update(schema.contentDatabases)
+    .set({
+      naturalKeyPropertyId: propertyId,
+      updatedAt: new Date().toISOString(),
+    })
+    .where(eq(schema.contentDatabases.id, context.database.id));
+}
+
+export async function runConfigureDocumentProperty(
+  input: ConfigureDocumentPropertyAgentInput,
+) {
+  return runDatabaseSetupMutation({
+    operation: `configure-document-property.${input.operation}`,
+    input,
+    payload:
+      input.operation === "create"
+        ? { operation: input.operation, definition: input.definition }
+        : {
+            operation: input.operation,
+            propertyId: input.propertyId,
+            patch: input.patch,
+          },
+    apply: async (tx, context) => {
+      if (context.database.systemRole) {
+        setupError(
+          "SYSTEM_DATABASE_UNSUPPORTED",
+          "Ordinary property setup is unavailable for system databases.",
+          400,
+        );
+      }
+      if (input.operation === "create") {
+        const propertyId = nanoid();
+        const definition = input.definition;
+        const options =
+          "options" in definition ? { options: definition.options ?? [] } : {};
+        if ("options" in definition) validateOptions(definition.options ?? []);
+        const [maxPosition] = await tx
+          .select({ max: sql<unknown>`COALESCE(MAX(position), -1)` })
+          .from(schema.documentPropertyDefinitions)
+          .where(
+            eq(
+              schema.documentPropertyDefinitions.databaseId,
+              context.database.id,
+            ),
+          );
+        const now = new Date().toISOString();
+        await tx.insert(schema.documentPropertyDefinitions).values({
+          id: propertyId,
+          ownerEmail: context.database.ownerEmail,
+          orgId: context.database.orgId,
+          databaseId: context.database.id,
+          name: definition.name,
+          description: definition.description?.trim() ?? "",
+          type: definition.type,
+          visibility: normalizePropertyVisibility(definition.visibility),
+          optionsJson: serializePropertyOptions(options),
+          position: Number(maxPosition?.max ?? -1) + 1,
+          createdAt: now,
+          updatedAt: now,
+        });
+        await configureNaturalKey(
+          tx,
+          context,
+          propertyId,
+          "naturalKey" in definition ? definition.naturalKey : undefined,
+        );
+        const canonical = await readDefinition(
+          tx,
+          context.database.id,
+          propertyId,
+        );
+        const nextContext = {
+          ...context,
+          database: {
+            ...context.database,
+            naturalKeyPropertyId:
+              "naturalKey" in definition && definition.naturalKey
+                ? propertyId
+                : context.database.naturalKeyPropertyId,
+          },
+        };
+        return {
+          outcome: "created" as const,
+          propertyId,
+          value: canonicalProperty(canonical, nextContext),
+        };
+      }
+
+      const existing = context.definitions.find(
+        (definition) => definition.id === input.propertyId,
+      );
+      if (!existing) {
+        setupError(
+          "NOT_FOUND_OR_INACCESSIBLE",
+          "The property is unavailable.",
+          404,
+        );
+      }
+      if (existing.systemRole) {
+        setupError(
+          "UNSUPPORTED_SCHEMA_CHANGE",
+          "System properties cannot be changed.",
+          400,
+        );
+      }
+      if (context.sourceManagedPropertyIds.has(existing.id)) {
+        setupError(
+          "SOURCE_MANAGED_PROPERTY",
+          "Source-managed property definitions cannot be changed here.",
+          400,
+        );
+      }
+      if (input.patch.naturalKey !== undefined && existing.type !== "text") {
+        setupError(
+          "UNSUPPORTED_SCHEMA_CHANGE",
+          "Only an ordinary text property can be a natural key.",
+          400,
+        );
+      }
+      const nextOptions = applyOptionEdits(existing, input.patch.optionEdits);
+      const now = new Date().toISOString();
+      const nextValues = {
+        name: input.patch.name ?? existing.name,
+        description:
+          input.patch.description === undefined
+            ? existing.description
+            : input.patch.description.trim(),
+        visibility:
+          input.patch.visibility === undefined
+            ? normalizePropertyVisibility(existing.visibility)
+            : input.patch.visibility,
+        optionsJson: serializePropertyOptions(nextOptions),
+      };
+      const changed =
+        nextValues.name !== existing.name ||
+        nextValues.description !== existing.description ||
+        nextValues.visibility !==
+          normalizePropertyVisibility(existing.visibility) ||
+        nextValues.optionsJson !==
+          serializePropertyOptions(
+            parsePropertyOptions(existing.optionsJson),
+          ) ||
+        (input.patch.naturalKey !== undefined &&
+          input.patch.naturalKey !==
+            (context.database.naturalKeyPropertyId === existing.id));
+      if (changed) {
+        await tx
+          .update(schema.documentPropertyDefinitions)
+          .set({ ...nextValues, updatedAt: now })
+          .where(eq(schema.documentPropertyDefinitions.id, existing.id));
+        await configureNaturalKey(
+          tx,
+          context,
+          existing.id,
+          input.patch.naturalKey,
+        );
+      }
+      const canonical = await readDefinition(
+        tx,
+        context.database.id,
+        existing.id,
+      );
+      const nextContext = {
+        ...context,
+        database: {
+          ...context.database,
+          naturalKeyPropertyId:
+            input.patch.naturalKey === undefined
+              ? context.database.naturalKeyPropertyId
+              : input.patch.naturalKey
+                ? existing.id
+                : context.database.naturalKeyPropertyId === existing.id
+                  ? null
+                  : context.database.naturalKeyPropertyId,
+        },
+      };
+      return {
+        outcome: changed ? ("updated" as const) : ("unchanged" as const),
+        propertyId: existing.id,
+        value: canonicalProperty(canonical, nextContext),
+      };
+    },
+  });
+}
+
+export const ordinaryPropertyTypeSchema = z.enum(ordinaryPropertyTypes);
diff --git a/templates/content/actions/_database-row-mutation.ts b/templates/content/actions/_database-row-mutation.ts
index 50e2d763086..1cd344fc71e 100644
--- a/templates/content/actions/_database-row-mutation.ts
+++ b/templates/content/actions/_database-row-mutation.ts
@@ -22,6 +22,7 @@ import {
   type DocumentPropertyType,
   type DocumentPropertyValue,
 } from "../shared/properties.js";
+import { contentDatabaseSourceManagedPropertyIds } from "../shared/source-field-policy.js";
 import {
   lockContentDatabaseMutation,
   touchContentDatabase,
@@ -249,6 +250,7 @@ export async function loadContext(
   role: "viewer" | "editor",
   db: Db = getDb(),
   accessAlreadyResolved = false,
+  includeDeleted = false,
 ): Promise<MutationContext> {
   const [database] = await db
     .select()
@@ -256,7 +258,7 @@ export async function loadContext(
     .where(
       and(
         eq(schema.contentDatabases.id, target.databaseId),
-        isNull(schema.contentDatabases.deletedAt),
+        includeDeleted ? undefined : isNull(schema.contentDatabases.deletedAt),
       ),
     );
   if (!database) {
@@ -273,7 +275,7 @@ export async function loadContext(
           .where(
             and(
               eq(schema.documents.id, database.documentId),
-              isNull(schema.documents.trashedAt),
+              includeDeleted ? undefined : isNull(schema.documents.trashedAt),
             ),
           )
       )[0]
@@ -317,7 +319,11 @@ export async function loadContext(
     .from(schema.documentPropertyDefinitions)
     .where(eq(schema.documentPropertyDefinitions.databaseId, database.id));
   const sourceFields = await db
-    .select({ propertyId: schema.contentDatabaseSourceFields.propertyId })
+    .select({
+      propertyId: schema.contentDatabaseSourceFields.propertyId,
+      writeOwner: schema.contentDatabaseSourceFields.writeOwner,
+      readOnly: schema.contentDatabaseSourceFields.readOnly,
+    })
     .from(schema.contentDatabaseSourceFields)
     .innerJoin(
       schema.contentDatabaseSources,
@@ -327,11 +333,8 @@ export async function loadContext(
       ),
     )
     .where(eq(schema.contentDatabaseSources.databaseId, database.id));
-  const sourceManagedPropertyIds = new Set(
-    sourceFields.flatMap((field) =>
-      field.propertyId ? [field.propertyId] : [],
-    ),
-  );
+  const sourceManagedPropertyIds =
+    contentDatabaseSourceManagedPropertyIds(sourceFields);
   return {
     database,
     databaseDocument,
@@ -833,7 +836,7 @@ function resultForReceipt(
     row: {
       itemId: snapshot.item.id,
       documentId: snapshot.document.id,
-      urlPath: `/page/${snapshot.document.id}`,
+      urlPath: `/page/${encodeURIComponent(snapshot.document.id)}?${new URLSearchParams({ databaseId: context.database.id, databaseDocumentId: context.database.documentId }).toString()}`,
       rowRevision: snapshot.revision,
     },
     affected: {
diff --git a/templates/content/actions/_database-setup-discovery.ts b/templates/content/actions/_database-setup-discovery.ts
new file mode 100644
index 00000000000..c9be5236d01
--- /dev/null
+++ b/templates/content/actions/_database-setup-discovery.ts
@@ -0,0 +1,53 @@
+import { resolveAccess } from "@agent-native/core/sharing";
+
+import { schema } from "../server/db/index.js";
+import type {
+  ContentDatabaseMutationContract,
+  ContentDatabaseSetupContract,
+} from "../shared/api.js";
+import { ordinaryPropertyTypes } from "./_database-property-setup.js";
+import { parseDatabaseViewConfig } from "./_property-utils.js";
+
+export async function getDatabaseSetupContract(
+  database: typeof schema.contentDatabases.$inferSelect,
+  mutationContract: ContentDatabaseMutationContract,
+): Promise<ContentDatabaseSetupContract> {
+  const access = await resolveAccess("document", database.documentId);
+  const role = access?.role;
+  const canEdit = role === "editor" || role === "admin" || role === "owner";
+  const target = {
+    spaceId: mutationContract.target.spaceId,
+    databaseId: database.id,
+    databaseDocumentId: database.documentId,
+  };
+  const databaseUrl = `/page/${encodeURIComponent(database.documentId)}`;
+  return {
+    target,
+    databaseUrl,
+    viewUrls: (
+      parseDatabaseViewConfig(database.viewConfigJson).views ?? []
+    ).map((view) => ({
+      viewId: view.id,
+      url: `${databaseUrl}?viewId=${encodeURIComponent(view.id)}`,
+    })),
+    supportedPropertyTypes: [...ordinaryPropertyTypes],
+    canEditSchema: canEdit,
+    canEditViews: canEdit,
+    canManageLifecycle:
+      (role === "admin" || role === "owner") && !database.ownerDocumentId,
+    sourceComposition: "unsupported",
+    properties: mutationContract.properties.map((property) => {
+      const ordinary = ordinaryPropertyTypes.some(
+        (type) => type === property.type,
+      );
+      const reason = !canEdit
+        ? "Database edit access required"
+        : property.sourceManaged
+          ? "Source-managed definition"
+          : !ordinary
+            ? "Blocks, computed and relationship definitions use their own actions"
+            : null;
+      return { propertyId: property.id, editable: reason === null, reason };
+    }),
+  };
+}
diff --git a/templates/content/actions/_database-setup-mutation.ts b/templates/content/actions/_database-setup-mutation.ts
new file mode 100644
index 00000000000..872f8aef9c7
--- /dev/null
+++ b/templates/content/actions/_database-setup-mutation.ts
@@ -0,0 +1,392 @@
+import { ActionContractError } from "@agent-native/core/action";
+import { writeAppState } from "@agent-native/core/application-state";
+import { getRequestUserEmail } from "@agent-native/core/server/request-context";
+import { accessFilter, assertAccess } from "@agent-native/core/sharing";
+import { and, eq, sql } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import { lockContentDatabaseMutation } from "./_content-database-mutation-lock.js";
+import {
+  assertSchema,
+  databaseMutationAgentTargetSchema,
+  digest,
+  loadContext,
+  type MutationContext,
+} from "./_database-row-mutation.js";
+import { nanoid } from "./_property-utils.js";
+
+export const setupGuardSchema = z.object({
+  target: databaseMutationAgentTargetSchema.strict(),
+  expectedSchemaRevision: z
+    .string()
+    .min(1)
+    .describe(
+      "Fresh schema revision from describe-content-database or get-content-database",
+    ),
+  idempotencyKey: z
+    .string()
+    .min(1)
+    .max(200)
+    .describe("Unique intent key; reuse unchanged after a lost response"),
+});
+
+export const setupLifecycleSchema = z
+  .object({
+    target: databaseMutationAgentTargetSchema.strict(),
+    expectedConfigurationRevision: z
+      .string()
+      .min(1)
+      .describe(
+        "Fresh configuration revision from database discovery or the last lifecycle receipt",
+      ),
+    idempotencyKey: z
+      .string()
+      .min(1)
+      .max(200)
+      .describe("Unique intent key; reuse unchanged after a lost response"),
+  })
+  .strict();
+
+type Db = ReturnType<typeof getDb>;
+type Target = z.infer<typeof databaseMutationAgentTargetSchema>;
+type Database = typeof schema.contentDatabases.$inferSelect;
+export type DatabaseSetupReceipt = {
+  receiptId: string;
+  operation: string;
+  outcome: "created" | "updated" | "unchanged" | "trashed" | "restored";
+  target: Target;
+  propertyId?: string;
+  viewId?: string;
+  idempotency: {
+    key: string;
+    result: "applied" | "replayed";
+    payloadDigest: string;
+  };
+  revisions: {
+    schemaBefore: string | null;
+    schemaAfter: string;
+    configurationBefore: string | null;
+    configurationAfter: string;
+  };
+  readback: { verified: true };
+  url: string;
+};
+
+export function setupAuditSummary(result: unknown, fallback: string): string {
+  const receipt = (result as { receipt?: DatabaseSetupReceipt } | null)
+    ?.receipt;
+  if (!receipt) return fallback;
+  const verb =
+    receipt.idempotency.result === "replayed"
+      ? "Verified earlier operation"
+      : receipt.operation;
+  return `${verb}; receipt ${receipt.receiptId}; property ${receipt.propertyId ?? "none"}; view ${receipt.viewId ?? "none"}; schema ${receipt.revisions.schemaBefore ?? "none"} -> ${receipt.revisions.schemaAfter}; configuration ${receipt.revisions.configurationBefore ?? "none"} -> ${receipt.revisions.configurationAfter}`;
+}
+
+export async function refreshAfterSetup(
+  receipt: DatabaseSetupReceipt,
+): Promise<void> {
+  try {
+    await writeAppState("refresh-signal", { ts: Date.now() });
+  } catch {
+    setupError(
+      "READBACK_UNAVAILABLE",
+      `Operation committed (receipt ${receipt.receiptId}), but its refresh signal failed. Retry the same input and idempotency key.`,
+      503,
+    );
+  }
+}
+
+export function configurationRevision(database: Database): string {
+  return digest({
+    viewConfigJson: database.viewConfigJson,
+    deletedAt: database.deletedAt,
+    ownerDocumentId: database.ownerDocumentId,
+    ownerBlockId: database.ownerBlockId,
+  });
+}
+
+export function setupError(
+  errorCode: string,
+  message: string,
+  statusCode = 409,
+): never {
+  throw new ActionContractError(message, { errorCode, statusCode });
+}
+
+export async function assertSetupAccess(
+  tx: Db,
+  target: Target,
+  role: "editor" | "admin" = "editor",
+) {
+  const [document] = await tx
+    .select({ id: schema.documents.id })
+    .from(schema.documents)
+    .where(
+      and(
+        eq(schema.documents.id, target.databaseDocumentId),
+        accessFilter(schema.documents, schema.documentShares, undefined, role),
+      ),
+    );
+  if (!document)
+    setupError(
+      "DATABASE_NOT_FOUND",
+      "Content database is unavailable or you cannot edit it.",
+      404,
+    );
+}
+
+type StoredResult<T> = { receipt: DatabaseSetupReceipt; value: T };
+type Claim = typeof schema.contentDatabaseSetupReceipts.$inferSelect;
+
+export async function claimSetupIntent(
+  tx: Db,
+  operation: string,
+  scopeId: string,
+  idempotencyKey: string,
+  payload: unknown,
+): Promise<Claim> {
+  const email = getRequestUserEmail()?.trim().toLowerCase();
+  if (!email)
+    setupError("UNAUTHORIZED", "Sign in to change a Content database.", 401);
+  const payloadDigest = digest(payload);
+  const table = schema.contentDatabaseSetupReceipts;
+  const inserted = await tx
+    .insert(table)
+    .values({
+      id: nanoid(),
+      actorEmail: email,
+      operation,
+      scopeId,
+      idempotencyKey,
+      payloadDigest,
+    })
+    .onConflictDoNothing()
+    .returning({ id: table.id });
+  // The unique claim serializes identical requests across hosted workers, including creation before a database exists.
+  const [claim] = await tx
+    .update(table)
+    .set({ payloadDigest: sql`${table.payloadDigest}` })
+    .where(
+      and(
+        eq(table.actorEmail, email),
+        eq(table.operation, operation),
+        eq(table.scopeId, scopeId),
+        eq(table.idempotencyKey, idempotencyKey),
+      ),
+    )
+    .returning();
+  if (!claim)
+    setupError(
+      "RECEIPT_MISMATCH",
+      "The database operation claim could not be read.",
+    );
+  if (claim.payloadDigest !== payloadDigest)
+    setupError(
+      "IDEMPOTENCY_KEY_REUSED",
+      "This key was already used for a different database operation. Use the original payload to retry it.",
+    );
+  if (inserted.length === 0 && claim.resultJson === null)
+    setupError(
+      "RECEIPT_MISMATCH",
+      "A saved operation is missing its receipt. It cannot safely be applied again.",
+    );
+  return claim;
+}
+
+export function replaySetupIntent<T>(
+  claim: Claim,
+  expectedTarget?: Partial<Target>,
+): StoredResult<T> | null {
+  if (claim.resultJson === null) return null;
+  let parsed: StoredResult<T>;
+  try {
+    parsed = JSON.parse(claim.resultJson);
+  } catch {
+    return setupError(
+      "RECEIPT_MISMATCH",
+      "The saved database operation receipt is unreadable.",
+    );
+  }
+  if (
+    parsed?.receipt?.receiptId !== claim.id ||
+    parsed.receipt.operation !== claim.operation ||
+    parsed.receipt.target?.databaseId !== claim.databaseId ||
+    parsed.receipt.idempotency?.payloadDigest !== claim.payloadDigest ||
+    parsed.receipt.idempotency.key !== claim.idempotencyKey ||
+    parsed.receipt.readback?.verified !== true ||
+    Object.entries(expectedTarget ?? {}).some(
+      ([key, value]) => parsed.receipt.target[key as keyof Target] !== value,
+    )
+  ) {
+    setupError(
+      "RECEIPT_MISMATCH",
+      "The saved database operation receipt is inconsistent.",
+    );
+  }
+  const value = parsed.value as Record<string, unknown> | null;
+  if (
+    !value ||
+    typeof value !== "object" ||
+    (value.databaseId !== undefined &&
+      value.databaseId !== parsed.receipt.target.databaseId) ||
+    (value.documentId !== undefined &&
+      value.documentId !== parsed.receipt.target.databaseDocumentId) ||
+    (parsed.receipt.propertyId !== undefined &&
+      value.id !== parsed.receipt.propertyId) ||
+    (parsed.receipt.viewId !== undefined &&
+      value.id !== parsed.receipt.viewId &&
+      value.defaultViewId !== parsed.receipt.viewId)
+  ) {
+    setupError(
+      "RECEIPT_MISMATCH",
+      "The saved database operation result does not match its receipt.",
+    );
+  }
+  return {
+    ...parsed,
+    receipt: {
+      ...parsed.receipt,
+      idempotency: { ...parsed.receipt.idempotency, result: "replayed" },
+    },
+  };
+}
+
+export async function finishSetupIntent<T>(
+  tx: Db,
+  claim: Claim,
+  target: Target,
+  before: MutationContext | null,
+  after: MutationContext,
+  result: {
+    outcome: DatabaseSetupReceipt["outcome"];
+    propertyId?: string;
+    viewId?: string;
+    value: T;
+  },
+): Promise<StoredResult<T>> {
+  if (
+    (result.outcome === "trashed" && after.database.deletedAt === null) ||
+    (result.outcome === "restored" && after.database.deletedAt !== null)
+  )
+    setupError(
+      "READBACK_UNAVAILABLE",
+      "The lifecycle change could not be verified and was rolled back.",
+    );
+  if (
+    result.propertyId &&
+    !after.definitions.some((definition) => definition.id === result.propertyId)
+  )
+    setupError(
+      "READBACK_UNAVAILABLE",
+      "The property change could not be verified and was rolled back.",
+    );
+  const { value, ...changed } = result;
+  const url = `/page/${encodeURIComponent(target.databaseDocumentId)}${result.viewId ? `?viewId=${encodeURIComponent(result.viewId)}` : ""}`;
+  const completed: StoredResult<T> = {
+    value,
+    receipt: {
+      receiptId: claim.id,
+      operation: claim.operation,
+      target,
+      ...changed,
+      idempotency: {
+        key: claim.idempotencyKey,
+        result: "applied",
+        payloadDigest: claim.payloadDigest,
+      },
+      revisions: {
+        schemaBefore: before?.schemaRevision ?? null,
+        schemaAfter: after.schemaRevision,
+        configurationBefore: before
+          ? configurationRevision(before.database)
+          : null,
+        configurationAfter: configurationRevision(after.database),
+      },
+      readback: { verified: true },
+      url,
+    },
+  };
+  await tx
+    .update(schema.contentDatabaseSetupReceipts)
+    .set({
+      databaseId: target.databaseId,
+      resultJson: JSON.stringify(completed),
+    })
+    .where(eq(schema.contentDatabaseSetupReceipts.id, claim.id));
+  return completed;
+}
+
+export async function runDatabaseSetupMutation<T>(args: {
+  operation: string;
+  input: {
+    target: Target;
+    expectedSchemaRevision?: string;
+    expectedConfigurationRevision?: string;
+    idempotencyKey: string;
+  };
+  payload: unknown;
+  role?: "editor" | "admin";
+  includeDeleted?: boolean;
+  lock?: (tx: Db) => Promise<unknown>;
+  apply: (
+    tx: Db,
+    context: MutationContext,
+  ) => Promise<{
+    outcome: DatabaseSetupReceipt["outcome"];
+    propertyId?: string;
+    viewId?: string;
+    value: T;
+  }>;
+}): Promise<StoredResult<T>> {
+  const { input } = args;
+  await assertAccess(
+    "document",
+    input.target.databaseDocumentId,
+    args.role ?? "editor",
+  );
+  return getDb().transaction(async (transaction) => {
+    const tx = transaction as unknown as Db;
+    if (args.lock) await args.lock(tx);
+    else await lockContentDatabaseMutation(tx, input.target.databaseId);
+    await assertSetupAccess(tx, input.target, args.role);
+    const before = await loadContext(
+      input.target,
+      "editor",
+      tx,
+      true,
+      args.includeDeleted,
+    );
+    const claim = await claimSetupIntent(
+      tx,
+      args.operation,
+      input.target.databaseId,
+      input.idempotencyKey,
+      args.payload,
+    );
+    const replay = replaySetupIntent<T>(claim, input.target);
+    if (replay) return replay;
+    if (input.expectedSchemaRevision !== undefined)
+      assertSchema(before, input.expectedSchemaRevision);
+    if (
+      input.expectedConfigurationRevision !== undefined &&
+      input.expectedConfigurationRevision !==
+        configurationRevision(before.database)
+    ) {
+      setupError(
+        "CONFIGURATION_REVISION_CONFLICT",
+        "The database configuration changed. Read it again before choosing an update.",
+      );
+    }
+    const result = await args.apply(tx, before);
+    const after = await loadContext(
+      input.target,
+      "editor",
+      tx,
+      true,
+      args.includeDeleted,
+    );
+    return finishSetupIntent(tx, claim, input.target, before, after, result);
+  });
+}
diff --git a/templates/content/actions/_database-source-utils.test.ts b/templates/content/actions/_database-source-utils.test.ts
index 4952deb9a39..76620e785ec 100644
--- a/templates/content/actions/_database-source-utils.test.ts
+++ b/templates/content/actions/_database-source-utils.test.ts
@@ -49,6 +49,7 @@ import {
   normalizeSourceFreshness,
   refreshBuilderBodySourceValuesFromStoredLossless,
   serializeBuilderCmsSourceReadMetadataRecord,
+  serializeSourceField,
   serializeSourceMetadataRecord,
   sourceSnapshotValuesJsonProjectionSql,
   sourceSnapshotDocumentSelection,
@@ -310,6 +311,32 @@ describe("database source helpers", () => {
     expect(normalizeSourceFreshness("mysterious fog")).toBe("unknown");
   });
 
+  it("rejects unreadable source field write policy during serialization", () => {
+    const row = {
+      id: "field-1",
+      propertyId: "property-1",
+      localFieldKey: "property-1",
+      sourceFieldKey: "field",
+      sourceFieldLabel: "Field",
+      sourceFieldType: "text",
+      mappingType: "property",
+      writeOwner: "unknown",
+      readOnly: 0,
+      provenance: "test",
+      freshness: "fresh",
+      lastSyncedAt: null,
+    };
+    expect(() => serializeSourceField(row as never, "Field")).toThrow(
+      "Invalid Content source field write owner: unknown",
+    );
+    expect(() =>
+      serializeSourceField(
+        { ...row, writeOwner: "local", readOnly: 2 } as never,
+        "Field",
+      ),
+    ).toThrow("Invalid Content source field read-only value: 2");
+  });
+
   it("omits heavy Builder body payloads from read snapshots", () => {
     const values = {
       "data.title": "Readable title",
diff --git a/templates/content/actions/_database-source-utils.ts b/templates/content/actions/_database-source-utils.ts
index 1665d9e908e..b9329773ec8 100644
--- a/templates/content/actions/_database-source-utils.ts
+++ b/templates/content/actions/_database-source-utils.ts
@@ -30,7 +30,6 @@ import type {
   ContentDatabaseSourceRow,
   ContentDatabaseSourceSyncState,
   ContentDatabaseSourceType,
-  ContentDatabaseSourceWriteOwner,
   BuilderCmsModelFieldSummary,
   DocumentProperty,
   DocumentPropertyOptions,
@@ -54,6 +53,10 @@ import {
   type DocumentPropertyOptionColor,
 } from "../shared/properties.js";
 import { sanitizeNormalizationFormula } from "../shared/properties.js";
+import {
+  parseContentDatabaseSourceFieldReadOnly,
+  parseContentDatabaseSourceWriteOwner,
+} from "../shared/source-field-policy.js";
 import {
   bulkChunkSizeForColumnCount,
   chunks,
@@ -470,12 +473,6 @@ export function normalizeSourceSyncState(
     : "linked";
 }
 
-function normalizeWriteOwner(
-  value: string | null | undefined,
-): ContentDatabaseSourceWriteOwner {
-  return value === "source" || value === "derived" ? value : "local";
-}
-
 function normalizeSourceType(
   value: string | null | undefined,
 ): ContentDatabaseSourceType {
@@ -596,8 +593,8 @@ export function serializeSourceField(
       row.mappingType === "title" || row.mappingType === "system"
         ? row.mappingType
         : "property",
-    writeOwner: normalizeWriteOwner(row.writeOwner),
-    readOnly: row.readOnly === 1,
+    writeOwner: parseContentDatabaseSourceWriteOwner(row.writeOwner),
+    readOnly: parseContentDatabaseSourceFieldReadOnly(row.readOnly),
     provenance: row.provenance,
     freshness: normalizeSourceFreshness(row.freshness),
     lastSyncedAt: row.lastSyncedAt,
diff --git a/templates/content/actions/_database-utils.ts b/templates/content/actions/_database-utils.ts
index 38a371f6009..b134818ef1f 100644
--- a/templates/content/actions/_database-utils.ts
+++ b/templates/content/actions/_database-utils.ts
@@ -49,6 +49,8 @@ import {
   databaseRowRevision,
   getDatabaseMutationContract,
 } from "./_database-row-mutation.js";
+import { getDatabaseSetupContract } from "./_database-setup-discovery.js";
+import { configurationRevision } from "./_database-setup-mutation.js";
 import { getAllContentDatabaseSourceSnapshots } from "./_database-source-utils.js";
 import { softDeletedDatabaseDocumentExclusions } from "./_document-discovery-query.js";
 import { serializeDocumentSource } from "./_document-source.js";
@@ -1174,7 +1176,10 @@ export async function getContentDatabasePageResponse(
   });
   // Opt-in federated columns (a secondary field the user added via the picker)
   // get their per-row values from the matched overlay at read time.
-  const itemsWithOverlay = applyFederatedOverlayValues(federatedItems);
+  const itemsWithOverlay = applyFederatedOverlayValues(
+    federatedItems,
+    pagedSources,
+  );
   return {
     databaseRecord: database,
     properties: responseProperties,
@@ -1233,6 +1238,26 @@ export async function getContentDatabaseResponse(
     ? await getDocumentContextPath(databaseDocument)
     : [];
 
+  const mutationContract =
+    page.databaseRecord.spaceId && !page.databaseRecord.systemRole
+      ? await getDatabaseMutationContract(
+          {
+            authorityScope: page.databaseRecord.orgId
+              ? {
+                  kind: "organization",
+                  id: page.databaseRecord.orgId,
+                }
+              : {
+                  kind: "personal",
+                  id: page.databaseRecord.ownerEmail,
+                },
+            spaceId: page.databaseRecord.spaceId,
+            databaseId: page.databaseRecord.id,
+            databaseDocumentId: page.databaseRecord.documentId,
+          },
+          { accessAlreadyResolved: true },
+        )
+      : undefined;
   return {
     database: serializeDatabase(
       page.databaseRecord,
@@ -1245,26 +1270,11 @@ export async function getContentDatabaseResponse(
     sources: page.sources,
     pagination: page.pagination,
     tableQueryMode: page.tableQueryMode,
-    mutationContract:
-      page.databaseRecord.spaceId && !page.databaseRecord.systemRole
-        ? await getDatabaseMutationContract(
-            {
-              authorityScope: page.databaseRecord.orgId
-                ? {
-                    kind: "organization",
-                    id: page.databaseRecord.orgId,
-                  }
-                : {
-                    kind: "personal",
-                    id: page.databaseRecord.ownerEmail,
-                  },
-              spaceId: page.databaseRecord.spaceId,
-              databaseId: page.databaseRecord.id,
-              databaseDocumentId: page.databaseRecord.documentId,
-            },
-            { accessAlreadyResolved: true },
-          )
-        : undefined,
+    mutationContract,
+    configurationRevision: configurationRevision(page.databaseRecord),
+    setupContract: mutationContract
+      ? await getDatabaseSetupContract(page.databaseRecord, mutationContract)
+      : undefined,
   };
 }
 
diff --git a/templates/content/actions/_database-view-setup.ts b/templates/content/actions/_database-view-setup.ts
new file mode 100644
index 00000000000..fddbeb804d1
--- /dev/null
+++ b/templates/content/actions/_database-view-setup.ts
@@ -0,0 +1,555 @@
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import type {
+  ContentDatabaseFilter,
+  ContentDatabaseFilterOperator,
+  ContentDatabaseView,
+  ContentDatabaseViewConfig,
+} from "../shared/api.js";
+import type { DocumentPropertyType } from "../shared/properties.js";
+import {
+  runDatabaseSetupMutation,
+  setupError,
+  setupGuardSchema,
+} from "./_database-setup-mutation.js";
+import { nanoid, parseDatabaseViewConfig } from "./_property-utils.js";
+
+const sortSchema = z
+  .object({
+    key: z.string().trim().min(1).max(200),
+    label: z.string().max(500),
+    direction: z.enum(["asc", "desc"]),
+  })
+  .strict();
+
+const filterSchema = z
+  .object({
+    key: z.string().trim().min(1).max(200),
+    label: z.string().max(500),
+    operator: z.enum([
+      "contains",
+      "equals",
+      "does_not_equal",
+      "greater_than",
+      "less_than",
+      "before",
+      "after",
+      "between",
+      "is_checked",
+      "is_unchecked",
+      "is_empty",
+      "is_not_empty",
+    ]),
+    value: z.string(),
+    filterGroupId: z.string().max(200).optional(),
+    parentFilterGroupId: z.string().max(200).optional(),
+  })
+  .strict();
+
+const tablePatchFields = {
+  sorts: z.array(sortSchema).max(100).optional(),
+  filters: z.array(filterSchema).max(100).optional(),
+  filterMode: z.enum(["and", "or"]).optional(),
+  columnWidths: z
+    .record(
+      z.string().trim().min(1).max(200),
+      z.number().finite().positive().max(4_000),
+    )
+    .optional(),
+  hiddenPropertyIds: z
+    .array(z.string().trim().min(1).max(200))
+    .max(100)
+    .optional(),
+  propertyOrderIds: z
+    .array(z.string().trim().min(1).max(200))
+    .max(100)
+    .optional(),
+  tableColumnOrderIds: z
+    .array(z.string().trim().min(1).max(200))
+    .max(100)
+    .optional(),
+  wrapCells: z.boolean().optional(),
+  columnWrapOverrides: z
+    .record(z.string().trim().min(1).max(200), z.boolean())
+    .optional(),
+  frozenThroughColumnId: z
+    .string()
+    .trim()
+    .min(1)
+    .max(200)
+    .nullable()
+    .optional(),
+  rowDensity: z.enum(["compact", "default", "comfortable"]).optional(),
+  openPagesIn: z.enum(["preview", "full_page"]).optional(),
+};
+
+const boundedTablePatchSchema = z
+  .object(tablePatchFields)
+  .strict()
+  .superRefine((patch, context) => {
+    for (const key of ["columnWidths", "columnWrapOverrides"] as const) {
+      if (patch[key] && Object.keys(patch[key]).length > 100) {
+        context.addIssue({
+          code: "custom",
+          path: [key],
+          message: `${key} supports at most 100 entries`,
+        });
+      }
+    }
+  });
+
+const updateTablePatchSchema = z
+  .object({
+    name: z.string().trim().min(1).max(500).optional(),
+    ...tablePatchFields,
+  })
+  .strict()
+  .refine(
+    (patch) => Object.keys(patch).length > 0,
+    "View patch cannot be empty",
+  );
+
+export const updateContentDatabaseViewAgentSchema = z.discriminatedUnion(
+  "operation",
+  [
+    setupGuardSchema
+      .extend({
+        expectedConfigurationRevision: z.string().min(1),
+        operation: z.literal("create"),
+        view: z
+          .object({
+            name: z.string().trim().min(1).max(500),
+            type: z.literal("table"),
+            config: boundedTablePatchSchema.optional(),
+          })
+          .strict(),
+      })
+      .strict(),
+    setupGuardSchema
+      .extend({
+        expectedConfigurationRevision: z.string().min(1),
+        operation: z.literal("update"),
+        viewId: z.string().trim().min(1).max(200),
+        patch: updateTablePatchSchema,
+      })
+      .strict(),
+  ],
+);
+
+export type UpdateContentDatabaseViewAgentInput = z.infer<
+  typeof updateContentDatabaseViewAgentSchema
+>;
+
+const operatorsByType: Partial<
+  Record<DocumentPropertyType, readonly ContentDatabaseFilterOperator[]>
+> = {
+  checkbox: ["is_checked", "is_unchecked"],
+  select: ["contains", "does_not_equal", "is_empty", "is_not_empty"],
+  status: ["contains", "does_not_equal", "is_empty", "is_not_empty"],
+  multi_select: ["contains", "does_not_equal", "is_empty", "is_not_empty"],
+  person: ["contains", "does_not_equal", "is_empty", "is_not_empty"],
+  number: [
+    "equals",
+    "does_not_equal",
+    "greater_than",
+    "less_than",
+    "is_empty",
+    "is_not_empty",
+  ],
+  date: [
+    "equals",
+    "does_not_equal",
+    "before",
+    "after",
+    "between",
+    "is_empty",
+    "is_not_empty",
+  ],
+  created_time: [
+    "equals",
+    "does_not_equal",
+    "before",
+    "after",
+    "between",
+    "is_empty",
+    "is_not_empty",
+  ],
+  last_edited_time: [
+    "equals",
+    "does_not_equal",
+    "before",
+    "after",
+    "between",
+    "is_empty",
+    "is_not_empty",
+  ],
+};
+
+const defaultOperators: readonly ContentDatabaseFilterOperator[] = [
+  "contains",
+  "equals",
+  "does_not_equal",
+  "is_empty",
+  "is_not_empty",
+];
+
+function uniqueReferences(values: readonly string[], field: string) {
+  if (new Set(values).size !== values.length) {
+    setupError(
+      "INVALID_VIEW_REFERENCE",
+      `${field} contains a duplicate reference.`,
+      400,
+    );
+  }
+}
+
+function validateTablePatch(
+  patch:
+    | z.infer<typeof updateTablePatchSchema>
+    | z.infer<typeof boundedTablePatchSchema>,
+  definitions: readonly (typeof schema.documentPropertyDefinitions.$inferSelect)[],
+) {
+  const typeById = new Map(
+    definitions.map((definition) => [
+      definition.id,
+      definition.type as DocumentPropertyType,
+    ]),
+  );
+  const propertyIds = new Set(typeById.keys());
+  const columnIds = new Set(["name", ...propertyIds]);
+  const assertReferences = (
+    values: readonly string[] | undefined,
+    allowed: ReadonlySet<string>,
+    field: string,
+  ) => {
+    if (!values) return;
+    uniqueReferences(values, field);
+    const invalid = values.find((value) => !allowed.has(value));
+    if (invalid) {
+      setupError(
+        "INVALID_VIEW_REFERENCE",
+        `${field} references unavailable property \"${invalid}\".`,
+        400,
+      );
+    }
+  };
+  assertReferences(patch.hiddenPropertyIds, propertyIds, "hiddenPropertyIds");
+  assertReferences(patch.propertyOrderIds, propertyIds, "propertyOrderIds");
+  assertReferences(patch.tableColumnOrderIds, columnIds, "tableColumnOrderIds");
+  assertReferences(
+    patch.sorts?.map((sort) => sort.key),
+    columnIds,
+    "sorts",
+  );
+  assertReferences(
+    patch.filters?.map((filter) => filter.key),
+    columnIds,
+    "filters",
+  );
+  assertReferences(
+    patch.columnWidths ? Object.keys(patch.columnWidths) : undefined,
+    columnIds,
+    "columnWidths",
+  );
+  assertReferences(
+    patch.columnWrapOverrides
+      ? Object.keys(patch.columnWrapOverrides)
+      : undefined,
+    columnIds,
+    "columnWrapOverrides",
+  );
+  if (
+    patch.frozenThroughColumnId &&
+    !columnIds.has(patch.frozenThroughColumnId)
+  ) {
+    setupError(
+      "INVALID_VIEW_REFERENCE",
+      `frozenThroughColumnId references unavailable property \"${patch.frozenThroughColumnId}\".`,
+      400,
+    );
+  }
+  for (const filter of patch.filters ?? []) {
+    const type = filter.key === "name" ? "text" : typeById.get(filter.key)!;
+    const allowed = operatorsByType[type] ?? defaultOperators;
+    if (!allowed.includes(filter.operator)) {
+      setupError(
+        "INVALID_VIEW_REFERENCE",
+        `Filter operator \"${filter.operator}\" is not valid for property \"${filter.key}\".`,
+        400,
+      );
+    }
+  }
+}
+
+function parseRawConfig(value: string | null) {
+  if (!value) return {} as Record<string, unknown>;
+  try {
+    const parsed = JSON.parse(value);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      setupError(
+        "READBACK_UNAVAILABLE",
+        "Saved database views are unreadable.",
+        500,
+      );
+    }
+    return parsed as Record<string, unknown>;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      setupError(
+        "READBACK_UNAVAILABLE",
+        "Saved database views are unreadable.",
+        500,
+      );
+    }
+    throw error;
+  }
+}
+
+function defaultTableView(
+  id: string,
+  name: string,
+  patch: z.infer<typeof boundedTablePatchSchema> = {},
+): ContentDatabaseView {
+  return {
+    id,
+    name,
+    type: "table",
+    sorts: patch.sorts ?? [],
+    filters: patch.filters ?? [],
+    filterMode: patch.filterMode ?? "and",
+    columnWidths: patch.columnWidths ?? {},
+    hiddenPropertyIds: patch.hiddenPropertyIds ?? [],
+    propertyOrderIds: patch.propertyOrderIds ?? [],
+    tableColumnOrderIds: patch.tableColumnOrderIds ?? [],
+    wrapCells: patch.wrapCells ?? false,
+    columnWrapOverrides: patch.columnWrapOverrides ?? {},
+    frozenThroughColumnId: patch.frozenThroughColumnId,
+    rowDensity: patch.rowDensity ?? "default",
+    openPagesIn: patch.openPagesIn ?? "preview",
+  };
+}
+
+async function readCanonicalView(
+  tx: ReturnType<typeof getDb>,
+  databaseId: string,
+  viewId: string,
+) {
+  const [database] = await tx
+    .select({ viewConfigJson: schema.contentDatabases.viewConfigJson })
+    .from(schema.contentDatabases)
+    .where(eq(schema.contentDatabases.id, databaseId));
+  if (!database) {
+    setupError(
+      "NOT_FOUND_OR_INACCESSIBLE",
+      "The database is unavailable.",
+      404,
+    );
+  }
+  const view = parseDatabaseViewConfig(database.viewConfigJson).views.find(
+    (candidate) => candidate.id === viewId,
+  );
+  if (!view) {
+    setupError(
+      "READBACK_UNAVAILABLE",
+      "The saved view could not be read back.",
+      500,
+    );
+  }
+  return view;
+}
+
+async function readCanonicalViewConfig(
+  tx: ReturnType<typeof getDb>,
+  databaseId: string,
+) {
+  const [database] = await tx
+    .select({ viewConfigJson: schema.contentDatabases.viewConfigJson })
+    .from(schema.contentDatabases)
+    .where(eq(schema.contentDatabases.id, databaseId));
+  if (!database) {
+    setupError(
+      "NOT_FOUND_OR_INACCESSIBLE",
+      "The database is unavailable.",
+      404,
+    );
+  }
+  return parseDatabaseViewConfig(database.viewConfigJson);
+}
+
+export async function runUpdateContentDatabaseView(
+  input: UpdateContentDatabaseViewAgentInput,
+) {
+  return runDatabaseSetupMutation({
+    operation: `update-content-database-view.${input.operation}`,
+    input,
+    payload:
+      input.operation === "create"
+        ? { operation: input.operation, view: input.view }
+        : {
+            operation: input.operation,
+            viewId: input.viewId,
+            patch: input.patch,
+          },
+    apply: async (tx, context) => {
+      const rawConfig = parseRawConfig(context.database.viewConfigJson);
+      const normalized = parseDatabaseViewConfig(
+        context.database.viewConfigJson,
+      );
+      const rawViews = Array.isArray(rawConfig.views)
+        ? [...rawConfig.views]
+        : normalized.views.map((view) => ({ ...view }));
+      let viewId: string;
+      let nextViews: unknown[];
+
+      if (input.operation === "create") {
+        validateTablePatch(input.view.config ?? {}, context.definitions);
+        viewId = nanoid();
+        nextViews = [
+          ...rawViews,
+          defaultTableView(viewId, input.view.name, input.view.config),
+        ];
+      } else {
+        const existing = normalized.views.find(
+          (view) => view.id === input.viewId,
+        );
+        if (!existing) {
+          setupError(
+            "INVALID_VIEW_REFERENCE",
+            "The saved view is unavailable.",
+            404,
+          );
+        }
+        if (existing.type !== "table") {
+          setupError(
+            "UNSUPPORTED_SCHEMA_CHANGE",
+            "Ordinary database setup can update only table views.",
+            400,
+          );
+        }
+        validateTablePatch(input.patch, context.definitions);
+        viewId = existing.id;
+        const index = rawViews.findIndex(
+          (view) =>
+            !!view &&
+            typeof view === "object" &&
+            (view as { id?: unknown }).id === viewId,
+        );
+        if (index < 0) {
+          setupError(
+            "READBACK_UNAVAILABLE",
+            "The saved view could not be updated safely.",
+            500,
+          );
+        }
+        nextViews = [...rawViews];
+        nextViews[index] = {
+          ...(rawViews[index] as Record<string, unknown>),
+          ...input.patch,
+        };
+      }
+
+      const nextRaw: Record<string, unknown> = {
+        ...rawConfig,
+        views: nextViews,
+      };
+      if (normalized.activeViewId === viewId) {
+        const selected = nextViews.find(
+          (view) =>
+            !!view &&
+            typeof view === "object" &&
+            (view as { id?: unknown }).id === viewId,
+        ) as Partial<ContentDatabaseView> | undefined;
+        nextRaw.sorts = selected?.sorts ?? normalized.sorts;
+        nextRaw.filters = selected?.filters ?? normalized.filters;
+        nextRaw.columnWidths =
+          selected?.columnWidths ?? normalized.columnWidths;
+      }
+      const nextJson = JSON.stringify(nextRaw);
+      const changed = nextJson !== (context.database.viewConfigJson ?? "");
+      if (changed) {
+        await tx
+          .update(schema.contentDatabases)
+          .set({
+            viewConfigJson: nextJson,
+            updatedAt: new Date().toISOString(),
+          })
+          .where(eq(schema.contentDatabases.id, context.database.id));
+      }
+      return {
+        outcome:
+          input.operation === "create"
+            ? ("created" as const)
+            : changed
+              ? ("updated" as const)
+              : ("unchanged" as const),
+        viewId,
+        value: await readCanonicalView(tx, context.database.id, viewId),
+      };
+    },
+  });
+}
+
+export async function runReplaceContentDatabaseViews(input: {
+  target: UpdateContentDatabaseViewAgentInput["target"];
+  expectedSchemaRevision: string;
+  expectedConfigurationRevision: string;
+  idempotencyKey: string;
+  viewConfig: Partial<ContentDatabaseViewConfig> &
+    Pick<ContentDatabaseViewConfig, "sorts" | "filters" | "columnWidths">;
+}) {
+  return runDatabaseSetupMutation({
+    operation: "update-content-database-view.replace",
+    input,
+    payload: { operation: "replace", viewConfig: input.viewConfig },
+    apply: async (tx, context) => {
+      const rawConfig = parseRawConfig(context.database.viewConfigJson);
+      const currentRawViews = Array.isArray(rawConfig.views)
+        ? rawConfig.views
+        : [];
+      const desired = parseDatabaseViewConfig(JSON.stringify(input.viewConfig));
+      const views = desired.views.map((view) => {
+        const saved = currentRawViews.find(
+          (candidate) =>
+            !!candidate &&
+            typeof candidate === "object" &&
+            (candidate as { id?: unknown }).id === view.id,
+        );
+        return saved && typeof saved === "object"
+          ? { ...(saved as Record<string, unknown>), ...view }
+          : view;
+      });
+      const nextRaw: Record<string, unknown> = {
+        ...rawConfig,
+        activeViewId: desired.activeViewId,
+        views,
+        sorts: desired.sorts,
+        filters: desired.filters,
+        columnWidths: desired.columnWidths,
+      };
+      const nextJson = JSON.stringify(nextRaw);
+      const changed = nextJson !== (context.database.viewConfigJson ?? "");
+      if (changed) {
+        await tx
+          .update(schema.contentDatabases)
+          .set({
+            viewConfigJson: nextJson,
+            updatedAt: new Date().toISOString(),
+          })
+          .where(eq(schema.contentDatabases.id, context.database.id));
+      }
+      return {
+        outcome: changed ? ("updated" as const) : ("unchanged" as const),
+        value: await readCanonicalViewConfig(tx, context.database.id),
+      };
+    },
+  });
+}
+
+export function filterIsCompatible(
+  filter: ContentDatabaseFilter,
+  type: DocumentPropertyType,
+) {
+  return (operatorsByType[type] ?? defaultOperators).includes(filter.operator);
+}
diff --git a/templates/content/actions/_federation-join.test.ts b/templates/content/actions/_federation-join.test.ts
index f0d4a66e2af..273ef458631 100644
--- a/templates/content/actions/_federation-join.test.ts
+++ b/templates/content/actions/_federation-join.test.ts
@@ -7,7 +7,11 @@ import type {
   ContentDatabaseSourceRole,
   ContentDatabaseSourceRow,
 } from "../shared/api";
-import { computeNormalizedKey, federateSources } from "./_federation-join";
+import {
+  applyFederatedOverlayValues,
+  computeNormalizedKey,
+  federateSources,
+} from "./_federation-join";
 
 function item(documentId: string): ContentDatabaseItem {
   return {
@@ -184,3 +188,211 @@ describe("federateSources", () => {
     expect(result[0].sourceOverlays).toBeUndefined();
   });
 });
+
+describe("applyFederatedOverlayValues", () => {
+  it("keeps only unambiguous local-owned mappings editable", () => {
+    const localProperty = {
+      definition: { id: "local-property" },
+      value: "Local value",
+      editable: true,
+    } as ContentDatabaseItem["properties"][number];
+    const local = source({ id: "local", rows: [] });
+    local.fields = [
+      {
+        id: "local-field",
+        propertyId: "local-property",
+        propertyName: "Local field",
+        localFieldKey: "local-property",
+        sourceFieldKey: "local-property",
+        sourceFieldLabel: "Local field",
+        sourceFieldType: "text",
+        mappingType: "property",
+        writeOwner: "local",
+        readOnly: false,
+        provenance: "test",
+        freshness: "fresh",
+        lastSyncedAt: null,
+      },
+    ];
+
+    expect(
+      applyFederatedOverlayValues(
+        [{ ...item("doc-local"), properties: [localProperty] }],
+        [local],
+      )[0].properties[0],
+    ).toMatchObject({ value: "Local value", editable: true });
+
+    const blocking = source({ id: "blocking", rows: [] });
+    blocking.fields = [
+      {
+        ...local.fields[0],
+        id: "source-field",
+        writeOwner: "source",
+      },
+    ];
+    expect(
+      applyFederatedOverlayValues(
+        [{ ...item("doc-blocked"), properties: [localProperty] }],
+        [local, blocking],
+      )[0].properties[0],
+    ).toMatchObject({ value: "Local value", editable: false });
+  });
+
+  it("keeps an overlay-provided value noneditable even with local metadata", () => {
+    const local = source({ id: "local", rows: [] });
+    local.fields = [
+      {
+        id: "local-field",
+        propertyId: "local-property",
+        propertyName: "Local field",
+        localFieldKey: "local-property",
+        sourceFieldKey: "local-property",
+        sourceFieldLabel: "Local field",
+        sourceFieldType: "text",
+        mappingType: "property",
+        writeOwner: "local",
+        readOnly: false,
+        provenance: "test",
+        freshness: "fresh",
+        lastSyncedAt: null,
+      },
+    ];
+    const overlaid = {
+      ...item("doc-overlay"),
+      properties: [
+        {
+          definition: { id: "local-property" },
+          value: "Stale local value",
+          editable: true,
+        } as ContentDatabaseItem["properties"][number],
+      ],
+      sourceOverlays: [
+        {
+          sourceId: "local",
+          sourceName: "Local",
+          sourceRowId: "row-1",
+          values: { "local-property": "Overlay value" },
+          fields: local.fields,
+        },
+      ],
+    };
+
+    expect(
+      applyFederatedOverlayValues([overlaid], [local])[0].properties[0],
+    ).toMatchObject({ value: "Overlay value", editable: false });
+  });
+
+  it("keeps mapped properties read-only without blanking a primary value", () => {
+    const secondaryProperty = {
+      definition: { id: "secondary-property" },
+      value: "stale local value",
+      editable: true,
+    } as ContentDatabaseItem["properties"][number];
+    const primaryProperty = {
+      definition: { id: "primary-property" },
+      value: "Primary source value",
+      editable: true,
+    } as ContentDatabaseItem["properties"][number];
+    const sharedProperty = {
+      definition: { id: "shared-property" },
+      value: "Shared primary value",
+      editable: true,
+    } as ContentDatabaseItem["properties"][number];
+    const unmatchedItem = {
+      ...item("doc-unmatched"),
+      properties: [secondaryProperty, primaryProperty, sharedProperty],
+    };
+    const primary = source({
+      id: "primary",
+      federation: federation("primary", "slug", "{slug}"),
+      rows: [row("doc-unmatched", {})],
+    });
+    primary.fields = [
+      {
+        id: "primary-field",
+        propertyId: "primary-property",
+        propertyName: "Primary owner",
+        localFieldKey: "primary-property",
+        sourceFieldKey: "primary-owner",
+        sourceFieldLabel: "Primary owner",
+        sourceFieldType: "text",
+        mappingType: "property",
+        writeOwner: "source",
+        readOnly: true,
+        provenance: "test",
+        freshness: "fresh",
+        lastSyncedAt: null,
+      },
+      {
+        id: "primary-shared-field",
+        propertyId: "shared-property",
+        propertyName: "Shared owner",
+        localFieldKey: "shared-property",
+        sourceFieldKey: "shared-owner",
+        sourceFieldLabel: "Shared owner",
+        sourceFieldType: "text",
+        mappingType: "property",
+        writeOwner: "local",
+        readOnly: false,
+        provenance: "test",
+        freshness: "fresh",
+        lastSyncedAt: null,
+      },
+    ];
+    const secondary = source({
+      id: "secondary",
+      federation: federation("secondary", "slug", "{slug}"),
+      rows: [],
+    });
+    secondary.fields = [
+      {
+        id: "managed-field",
+        propertyId: "secondary-property",
+        propertyName: "Source owner",
+        localFieldKey: "secondary-property",
+        sourceFieldKey: "owner",
+        sourceFieldLabel: "Owner",
+        sourceFieldType: "text",
+        mappingType: "property",
+        writeOwner: "source",
+        readOnly: true,
+        provenance: "test",
+        freshness: "fresh",
+        lastSyncedAt: null,
+      },
+      {
+        id: "secondary-shared-field",
+        propertyId: "shared-property",
+        propertyName: "Shared owner",
+        localFieldKey: "shared-property",
+        sourceFieldKey: "shared-owner",
+        sourceFieldLabel: "Shared owner",
+        sourceFieldType: "text",
+        mappingType: "property",
+        writeOwner: "source",
+        readOnly: true,
+        provenance: "test",
+        freshness: "fresh",
+        lastSyncedAt: null,
+      },
+    ];
+
+    const federated = federateSources({
+      items: [unmatchedItem],
+      sources: [primary, secondary],
+    });
+    expect(federated[0].sourceOverlays).toBeUndefined();
+    expect(
+      applyFederatedOverlayValues(federated, [primary, secondary])[0]
+        .properties[0],
+    ).toMatchObject({ value: null, editable: false });
+    expect(
+      applyFederatedOverlayValues(federated, [primary, secondary])[0]
+        .properties[1],
+    ).toMatchObject({ value: "Primary source value", editable: false });
+    expect(
+      applyFederatedOverlayValues(federated, [primary, secondary])[0]
+        .properties[2],
+    ).toMatchObject({ value: "Shared primary value", editable: false });
+  });
+});
diff --git a/templates/content/actions/_federation-join.ts b/templates/content/actions/_federation-join.ts
index 897c803e40d..31245676183 100644
--- a/templates/content/actions/_federation-join.ts
+++ b/templates/content/actions/_federation-join.ts
@@ -19,6 +19,10 @@ import type {
   DocumentPropertyValue,
 } from "../shared/api.js";
 import { evaluateNormalizationFormula } from "../shared/properties.js";
+import {
+  contentDatabaseSourceFieldAllowsLocalWrite,
+  contentDatabaseSourceManagedPropertyIds,
+} from "../shared/source-field-policy.js";
 
 // Map a source row's own values into the canonical key space. Returns null for
 // an un-joinable row (empty/broken formula result) — null never matches, not
@@ -142,11 +146,34 @@ export function federateSources(args: {
  */
 export function applyFederatedOverlayValues(
   items: ContentDatabaseItem[],
+  sources: ContentDatabaseSource[],
 ): ContentDatabaseItem[] {
+  const sourceManagedPropertyIds = contentDatabaseSourceManagedPropertyIds(
+    sources.flatMap((source) => source.fields),
+  );
+  const secondaryPropertyIds = new Set(
+    sources
+      .filter((source) => source.metadata.federation?.role === "secondary")
+      .flatMap((source) =>
+        source.fields.flatMap((field) =>
+          field.propertyId && !contentDatabaseSourceFieldAllowsLocalWrite(field)
+            ? [field.propertyId]
+            : [],
+        ),
+      ),
+  );
+  const primaryOrStandalonePropertyIds = new Set(
+    sources
+      .filter((source) => source.metadata.federation?.role !== "secondary")
+      .flatMap((source) =>
+        source.fields.flatMap((field) =>
+          field.propertyId ? [field.propertyId] : [],
+        ),
+      ),
+  );
   return items.map((item) => {
-    if (!item.sourceOverlays?.length) return item;
     const valueByPropertyId = new Map<string, DocumentPropertyValue>();
-    for (const overlay of item.sourceOverlays) {
+    for (const overlay of item.sourceOverlays ?? []) {
       for (const field of overlay.fields) {
         if (!field.propertyId) continue;
         valueByPropertyId.set(
@@ -155,18 +182,23 @@ export function applyFederatedOverlayValues(
         );
       }
     }
-    if (valueByPropertyId.size === 0) return item;
     return {
       ...item,
-      properties: item.properties.map((property) =>
-        valueByPropertyId.has(property.definition.id)
-          ? {
-              ...property,
-              value: valueByPropertyId.get(property.definition.id) ?? null,
-              editable: false,
-            }
-          : property,
-      ),
+      properties: item.properties.map((property) => {
+        const propertyId = property.definition.id;
+        if (valueByPropertyId.has(propertyId)) {
+          return {
+            ...property,
+            value: valueByPropertyId.get(propertyId) ?? null,
+            editable: false,
+          };
+        }
+        if (!sourceManagedPropertyIds.has(propertyId)) return property;
+        return secondaryPropertyIds.has(propertyId) &&
+          !primaryOrStandalonePropertyIds.has(propertyId)
+          ? { ...property, value: null, editable: false }
+          : { ...property, editable: false };
+      }),
     };
   });
 }
diff --git a/templates/content/actions/_property-utils.ts b/templates/content/actions/_property-utils.ts
index 1a119e8501d..299a622e427 100644
--- a/templates/content/actions/_property-utils.ts
+++ b/templates/content/actions/_property-utils.ts
@@ -48,6 +48,7 @@ import {
   type DocumentPropertyType,
   type DocumentPropertyValue,
 } from "../shared/properties.js";
+import { contentDatabaseSourceManagedPropertyIds } from "../shared/source-field-policy.js";
 import { chunks } from "./_batch-utils.js";
 import { readBlocksFieldIdentities } from "./_blocks-field-identity.js";
 import {
@@ -74,6 +75,28 @@ type ContentDatabaseItemRow = InferSelectModel<
 >;
 type DbClient = ReturnType<typeof getDb>;
 
+async function sourceManagedPropertyIdsForDatabase(
+  db: DbClient,
+  databaseId: string,
+) {
+  const fields = await db
+    .select({
+      propertyId: schema.contentDatabaseSourceFields.propertyId,
+      writeOwner: schema.contentDatabaseSourceFields.writeOwner,
+      readOnly: schema.contentDatabaseSourceFields.readOnly,
+    })
+    .from(schema.contentDatabaseSourceFields)
+    .innerJoin(
+      schema.contentDatabaseSources,
+      eq(
+        schema.contentDatabaseSources.id,
+        schema.contentDatabaseSourceFields.sourceId,
+      ),
+    )
+    .where(eq(schema.contentDatabaseSources.databaseId, databaseId));
+  return contentDatabaseSourceManagedPropertyIds(fields);
+}
+
 export function nanoid(size = 12): string {
   const chars =
     "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
@@ -623,6 +646,10 @@ export async function listPropertiesForDatabase(
     .orderBy(asc(schema.documentPropertyDefinitions.position));
 
   if (definitions.length === 0) return [];
+  const sourceManagedPropertyIds = await sourceManagedPropertyIdsForDatabase(
+    db,
+    databaseId,
+  );
 
   const values = valueDocument
     ? await db
@@ -724,7 +751,8 @@ export async function listPropertiesForDatabase(
       editable:
         includeContainerDerivedValues &&
         !definition.systemRole &&
-        !isComputedPropertyType(type),
+        !isComputedPropertyType(type) &&
+        !sourceManagedPropertyIds.has(definition.id),
       ...(valueDocument && isBlocksPropertyType(type)
         ? {
             blocksField: blocksFieldIdentityById.get(
@@ -816,6 +844,10 @@ export async function listPropertiesForDatabaseDocuments(
     for (const document of valueDocuments) result.set(document.id, []);
     return result;
   }
+  const sourceManagedPropertyIds = await sourceManagedPropertyIdsForDatabase(
+    db,
+    databaseId,
+  );
 
   const documentIds = valueDocuments.map((document) => document.id);
   const propertyIds = definitions.map((definition) => definition.id);
@@ -936,7 +968,8 @@ export async function listPropertiesForDatabaseDocuments(
         value,
         editable:
           !definition.systemRole &&
-          !isComputedPropertyType(propertyDefinition.type),
+          !isComputedPropertyType(propertyDefinition.type) &&
+          !sourceManagedPropertyIds.has(definition.id),
         ...(isBlocksPropertyType(propertyDefinition.type)
           ? {
               blocksField: blocksFieldIdentityById.get(
diff --git a/templates/content/actions/add-database-item.ts b/templates/content/actions/add-database-item.ts
index aa4b8a737fe..235999815c0 100644
--- a/templates/content/actions/add-database-item.ts
+++ b/templates/content/actions/add-database-item.ts
@@ -27,13 +27,15 @@ const schema = databaseMutationEnvelopeSchema.extend({
   propertyEntries: databasePropertyEntriesSchema,
 });
 const agentSchema = schema
-  .extend({ target: databaseMutationAgentTargetSchema })
-  .omit({ propertyValues: true });
+  .extend({ target: databaseMutationAgentTargetSchema.strict() })
+  .omit({ propertyValues: true })
+  .strict();
 
 export default defineAction({
   description:
     "Create one row in an exact ordinary Content database using the mutation target and schema revision from a fresh get-content-database read. Strictly validates every non-Blocks property, applies one new intent once per fresh idempotency key, and returns a verified receipt with stable membership and page identities.",
   mcpTool: true,
+  mcpApp: { structuredContent: true },
   agentInputSchema: agentSchema,
   publicAgent: {
     expose: true,
@@ -60,7 +62,8 @@ export default defineAction({
         : "Created Content database row";
     },
   },
-  run: async (args): Promise<ContentDatabaseRowMutationResult> => {
+  run: async (args, context): Promise<ContentDatabaseRowMutationResult> => {
+    if (context?.caller === "mcp") agentSchema.parse(args);
     const result = await createDatabaseRow(
       canonicalizeDatabasePropertyInput(args),
     );
@@ -81,14 +84,18 @@ export default defineAction({
     return { ...result, createdItem };
   },
   link: ({ result }) => {
-    const documentId = (result as ContentDatabaseRowMutationResult | null)
-      ?.receipt.row.documentId;
-    if (!documentId) return null;
+    const receipt = (result as ContentDatabaseRowMutationResult | null)
+      ?.receipt;
+    if (!receipt) return null;
     return {
       url: buildDeepLink({
         app: "content",
         view: "editor",
-        params: { documentId },
+        params: {
+          documentId: receipt.row.documentId,
+          databaseId: receipt.target.databaseId,
+          databaseDocumentId: receipt.target.databaseDocumentId,
+        },
       }),
       label: "Open database row",
       view: "editor",
diff --git a/templates/content/actions/configure-document-property.ts b/templates/content/actions/configure-document-property.ts
index c504aef31be..5483a352616 100644
--- a/templates/content/actions/configure-document-property.ts
+++ b/templates/content/actions/configure-document-property.ts
@@ -1,5 +1,6 @@
 import { defineAction } from "@agent-native/core/action";
 import { writeAppState } from "@agent-native/core/application-state";
+import { buildDeepLink } from "@agent-native/core/server";
 import { assertAccess } from "@agent-native/core/sharing";
 import { and, eq, sql } from "drizzle-orm";
 import { z } from "zod";
@@ -19,6 +20,14 @@ import {
 import { deleteBlocksFieldIdentity } from "./_blocks-field-identity.js";
 import { lockContentDatabaseMutation } from "./_content-database-mutation-lock.js";
 import { lockDatabaseMemberships } from "./_database-membership-lock.js";
+import {
+  configureDocumentPropertyAgentSchema,
+  runConfigureDocumentProperty,
+} from "./_database-property-setup.js";
+import {
+  refreshAfterSetup,
+  setupAuditSummary,
+} from "./_database-setup-mutation.js";
 import {
   nextAppendPosition,
   propertyDefinitionsPositionScope,
@@ -31,10 +40,8 @@ import {
   resolvePropertyDatabaseForDocument,
 } from "./_property-utils.js";
 
-export default defineAction({
-  description:
-    "Create or update a Notion-style property definition for content documents.",
-  schema: z.object({
+const legacyConfigureDocumentPropertySchema = z
+  .object({
     id: z.string().optional().describe("Existing property definition ID"),
     documentId: z
       .string()
@@ -67,19 +74,20 @@ export default defineAction({
       .object({
         options: z
           .array(
-            z.object({
-              id: z.string(),
-              name: z.string(),
-              color: z.string(),
-              description: z.string().optional(),
-            }),
+            z
+              .object({
+                id: z.string(),
+                name: z.string(),
+                color: z.string(),
+                description: z.string().optional(),
+              })
+              .strict(),
           )
           .optional(),
         formula: z.string().optional(),
         relation: z
-          .object({
-            databaseId: z.string().nullable().optional(),
-          })
+          .object({ databaseId: z.string().nullable().optional() })
+          .strict()
           .optional(),
         rollup: z
           .object({
@@ -97,14 +105,49 @@ export default defineAction({
               ])
               .optional(),
           })
+          .strict()
           .optional(),
       })
+      .strict()
       .optional()
       .describe(
         "Select/status/multi-select options, formula expression, relation target, or rollup config",
       ),
-  }),
-  run: async (args) => {
+  })
+  .strict();
+
+export default defineAction({
+  description:
+    "Create an ordinary Content database property or safely update its metadata, select options, and natural-key role using an exact target, fresh schema revision, and idempotency key.",
+  mcpTool: true,
+  mcpApp: { structuredContent: true },
+  agentInputSchema: configureDocumentPropertyAgentSchema,
+  schema: z.union([
+    configureDocumentPropertyAgentSchema,
+    legacyConfigureDocumentPropertySchema,
+  ]),
+  audit: {
+    recordInputs: false,
+    target: (args) => ({
+      type: "content-database",
+      id:
+        "operation" in args
+          ? args.target.databaseId
+          : (args.databaseId ?? args.documentId),
+      visibility: "private",
+    }),
+    summary: (_args, result) =>
+      setupAuditSummary(result, "Configured a Content database property"),
+  },
+  run: async (args, context) => {
+    if (context?.caller === "mcp") {
+      configureDocumentPropertyAgentSchema.parse(args);
+    }
+    if ("operation" in args) {
+      const result = await runConfigureDocumentProperty(args);
+      await refreshAfterSetup(result.receipt);
+      return result;
+    }
     const access = await assertAccess("document", args.documentId, "editor");
     const document = access.resource;
     const db = getDb();
@@ -368,6 +411,25 @@ export default defineAction({
       properties: await listPropertiesForDocument(document, database.id),
     };
   },
+  link: ({ result }) => {
+    const receipt = (
+      result as {
+        receipt?: { target?: { databaseDocumentId?: string } };
+      } | null
+    )?.receipt;
+    const documentId = receipt?.target?.databaseDocumentId;
+    if (!documentId) return null;
+    return {
+      url: buildDeepLink({
+        app: "content",
+        view: "editor",
+        to: `/page/${encodeURIComponent(documentId)}`,
+        params: { documentId },
+      }),
+      label: "Open in Content",
+      view: "editor",
+    };
+  },
 });
 
 async function configureNaturalKey(
diff --git a/templates/content/actions/content-database-lifecycle.db.test.ts b/templates/content/actions/content-database-lifecycle.db.test.ts
index 56dfb33608a..7461723744b 100644
--- a/templates/content/actions/content-database-lifecycle.db.test.ts
+++ b/templates/content/actions/content-database-lifecycle.db.test.ts
@@ -2228,6 +2228,8 @@ describe("content database soft-delete actions and reads", () => {
       expect.arrayContaining([
         {
           databaseId: ownedDeleted.databaseId,
+          spaceId: null,
+          configurationRevision: expect.any(String),
           title: "Database",
           documentId: ownedDeleted.databaseDocumentId,
           ownerDocumentId: null,
diff --git a/templates/content/actions/content-files.db.test.ts b/templates/content/actions/content-files.db.test.ts
index 3fb4fc01c94..aa641322609 100644
--- a/templates/content/actions/content-files.db.test.ts
+++ b/templates/content/actions/content-files.db.test.ts
@@ -47,12 +47,12 @@ beforeAll(async () => {
   const plugin = (await import("../server/plugins/db.js")).default;
   await plugin(undefined as any);
   await getDbExec().execute(`CREATE TABLE IF NOT EXISTS organizations (
-    id TEXT PRIMARY KEY, name TEXT NOT NULL, created_by TEXT NOT NULL, created_at INTEGER NOT NULL,
+    id TEXT PRIMARY KEY, name TEXT NOT NULL, created_by TEXT NOT NULL, created_at BIGINT NOT NULL,
     identity_authority TEXT, identity_id TEXT
   )`);
   await getDbExec().execute(`CREATE TABLE IF NOT EXISTS org_members (
-    id TEXT PRIMARY KEY, org_id TEXT NOT NULL, email TEXT NOT NULL, role TEXT NOT NULL, joined_at INTEGER NOT NULL,
-    federation_removal_pending_at INTEGER
+    id TEXT PRIMARY KEY, org_id TEXT NOT NULL, email TEXT NOT NULL, role TEXT NOT NULL, joined_at BIGINT NOT NULL,
+    federation_removal_pending_at BIGINT
   )`);
   await getDbExec().execute({
     sql: "INSERT INTO organizations (id, name, created_by, created_at) VALUES ($1, $2, $3, $4)",
diff --git a/templates/content/actions/create-content-database.ts b/templates/content/actions/create-content-database.ts
index 73dd9cd999f..e2a58e46fc4 100644
--- a/templates/content/actions/create-content-database.ts
+++ b/templates/content/actions/create-content-database.ts
@@ -26,6 +26,15 @@ import {
   organizationContentSpaceId,
   provisionContentSpaces,
 } from "./_content-spaces.js";
+import { loadContext } from "./_database-row-mutation.js";
+import {
+  assertSetupAccess,
+  claimSetupIntent,
+  finishSetupIntent,
+  replaySetupIntent,
+  setupError,
+  setupAuditSummary,
+} from "./_database-setup-mutation.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
 import {
   documentsPositionScope,
@@ -34,35 +43,93 @@ import {
 } from "./_position-utils.js";
 import { nanoid, seedDefaultBlocksField } from "./_property-utils.js";
 
-const createContentDatabaseSchema = z.object({
-  documentId: z
-    .string()
-    .optional()
-    .describe("Existing document to convert into a database page"),
-  newDocumentId: z
-    .string()
-    .optional()
-    .describe("Caller-provided document ID for a new database page"),
-  spaceId: z
-    .string()
-    .optional()
-    .describe("Content space for a new top-level database"),
-  parentId: z
-    .string()
-    .nullish()
-    .describe("Parent document for a new database page"),
-  title: z.string().optional().describe("Database title"),
-  description: z
-    .string()
-    .optional()
-    .describe("Stable guidance describing what belongs in this database"),
+const createContentDatabaseSchema = z
+  .object({
+    idempotencyKey: z
+      .string()
+      .min(1)
+      .max(200)
+      .optional()
+      .describe("Intent key for reliable creation in an exact space"),
+    documentId: z
+      .string()
+      .optional()
+      .describe("Existing document to convert into a database page"),
+    newDocumentId: z
+      .string()
+      .optional()
+      .describe("Caller-provided document ID for a new database page"),
+    spaceId: z
+      .string()
+      .optional()
+      .describe("Content space for a new top-level database"),
+    parentId: z
+      .string()
+      .nullish()
+      .describe("Parent document for a new database page"),
+    title: z.string().optional().describe("Database title"),
+    description: z
+      .string()
+      .optional()
+      .describe("Stable guidance describing what belongs in this database"),
+  })
+  .strict();
+
+const createDatabaseAgentSchema = z
+  .object({
+    spaceId: z
+      .string()
+      .min(1)
+      .describe("Exact authorized Content space ID from list-content-spaces"),
+    title: z
+      .string()
+      .trim()
+      .min(1)
+      .max(500)
+      .describe("Name of the new ordinary database"),
+    description: z
+      .string()
+      .max(10000)
+      .optional()
+      .describe("Guidance describing what belongs in this database"),
+    parentId: z
+      .string()
+      .min(1)
+      .optional()
+      .describe("Optional editable parent Page in the same exact space"),
+    idempotencyKey: z
+      .string()
+      .min(1)
+      .max(200)
+      .describe(
+        "Unique creation intent; reuse unchanged after a lost response",
+      ),
+  })
+  .strict();
+
+const createDatabaseReliableSchema = createDatabaseAgentSchema.extend({
+  newDocumentId: z.string().min(1).optional(),
+  parentId: z.string().min(1).nullish(),
 });
 
 export default defineAction({
   description:
-    "Create a Notion-style content database, optionally converting an existing document into the database page.",
+    "Create one ordinary Content database in an exact authorized space with a default table and verified receipt. Retry a lost response with the same payload and idempotency key.",
+  mcpTool: true,
+  agentInputSchema: createDatabaseAgentSchema,
+  audit: {
+    recordInputs: false,
+    target: (_args, result) => ({
+      type: "content-database",
+      id: (result as ContentDatabaseResponse).database.id,
+      visibility: "private",
+    }),
+    summary: (_args, result) =>
+      setupAuditSummary(result, "Created Content database"),
+  },
   schema: createContentDatabaseSchema,
   mcpApp: {
+    structuredContent: true,
     compactCatalog: true,
     resource: embedApp({
       title: "Open database",
@@ -72,7 +139,10 @@ export default defineAction({
       height: 900,
     }),
   },
-  run: async (args) => {
+  run: async (args, context) => {
+    if (context?.caller === "mcp") createDatabaseAgentSchema.parse(args);
+    if (args.idempotencyKey !== undefined)
+      return createReliableDatabase(createDatabaseReliableSchema.parse(args));
     const result = await createContentDatabaseCore(args);
     await writeAppState("refresh-signal", { ts: Date.now() });
     return result;
@@ -93,6 +163,83 @@ export default defineAction({
   },
 });
 
+async function createReliableDatabase(
+  args: z.infer<typeof createDatabaseReliableSchema>,
+) {
+  await resolveContentSpaceAccess(args.spaceId, "contributor");
+  if (args.parentId) await assertAccess("document", args.parentId, "editor");
+  const result = await getDb().transaction(async (transaction) => {
+    const tx = transaction as unknown as ReturnType<typeof getDb>;
+    await resolveContentSpaceAccess(args.spaceId, "contributor", { db: tx });
+    const claim = await claimSetupIntent(
+      tx,
+      "create-content-database",
+      args.spaceId,
+      args.idempotencyKey,
+      args,
+    );
+    const replay = replaySetupIntent<{
+      databaseId: string;
+      defaultViewId: string;
+    }>(claim, { spaceId: args.spaceId });
+    if (replay) {
+      await assertSetupAccess(tx, replay.receipt.target);
+      const context = await loadContext(
+        replay.receipt.target,
+        "editor",
+        tx,
+        true,
+        true,
+      );
+      if (context.database.deletedAt)
+        setupError(
+          "DATABASE_TRASHED",
+          "The original database was created and is now in Trash. Restore it instead of retrying creation.",
+        );
+      return replay;
+    }
+    const databaseId = await createContentDatabaseRecord(args, {
+      db: tx,
+      spaceId: args.spaceId,
+    });
+    const [database] = await tx
+      .select()
+      .from(schema.contentDatabases)
+      .where(eq(schema.contentDatabases.id, databaseId));
+    if (!database)
+      setupError(
+        "READBACK_UNAVAILABLE",
+        "The new database could not be verified; creation was rolled back.",
+      );
+    const target = {
+      spaceId: args.spaceId,
+      databaseId,
+      databaseDocumentId: database.documentId,
+    };
+    const after = await loadContext(target, "editor", tx, true);
+    return finishSetupIntent(tx, claim, target, null, after, {
+      outcome: "created",
+      viewId: "default",
+      value: { databaseId, defaultViewId: "default" },
+    });
+  });
+  try {
+    const response = await getContentDatabaseResponse(result.value.databaseId);
+    await writeAppState("refresh-signal", { ts: Date.now() });
+    return {
+      ...response,
+      receipt: result.receipt,
+      defaultViewId: result.value.defaultViewId,
+    };
+  } catch {
+    setupError(
+      "READBACK_UNAVAILABLE",
+      `Database creation committed (receipt ${result.receipt.receiptId}), but its response is unavailable. Retry the same input and idempotency key; do not create another database.`,
+      503,
+    );
+  }
+}
+
 export async function createContentDatabaseCore(
   args: CreateDatabaseRequest,
   options: { db?: any } = {},
diff --git a/templates/content/actions/database-property-view-setup.db.test.ts b/templates/content/actions/database-property-view-setup.db.test.ts
new file mode 100644
index 00000000000..890fe7170d2
--- /dev/null
+++ b/templates/content/actions/database-property-view-setup.db.test.ts
@@ -0,0 +1,303 @@
+import { rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { runWithRequestContext } from "@agent-native/core/server";
+import { eq } from "drizzle-orm";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+const path = join(
+  tmpdir(),
+  `content-property-view-setup-${process.pid}-${Date.now()}.pglite`,
+);
+const owner = `property-view-owner-${Date.now()}@example.com`;
+let getDb: typeof import("../server/db/index.js").getDb;
+let schema: typeof import("../server/db/schema.js");
+let createDatabase: typeof import("./create-content-database.js").default;
+let configureProperty: typeof import("./configure-document-property.js").default;
+let updateView: typeof import("./update-content-database-view.js").default;
+let readDatabase: typeof import("./get-content-database.js").default;
+let listSpaces: typeof import("./list-content-spaces.js").default;
+let spaceId: string;
+
+const asOwner = <T>(run: () => Promise<T>) =>
+  runWithRequestContext({ userEmail: owner }, run);
+
+beforeAll(async () => {
+  process.env.DATABASE_URL = `pglite:${path}`;
+  const db = await import("../server/db/index.js");
+  getDb = db.getDb;
+  schema = db.schema;
+  await (await import("../server/plugins/db.js")).default(undefined as never);
+  createDatabase = (await import("./create-content-database.js")).default;
+  configureProperty = (await import("./configure-document-property.js"))
+    .default;
+  updateView = (await import("./update-content-database-view.js")).default;
+  readDatabase = (await import("./get-content-database.js")).default;
+  listSpaces = (await import("./list-content-spaces.js")).default;
+  await asOwner(() =>
+    import("./_content-spaces.js").then((module) =>
+      module.provisionContentSpaces(getDb(), owner),
+    ),
+  );
+  const spaces = await asOwner(() => listSpaces.run({}));
+  spaceId = spaces.spaces[0]!.id;
+}, 120_000);
+
+afterAll(() => rmSync(path, { recursive: true, force: true }));
+
+describe("ordinary property and table-view setup", () => {
+  it("creates and safely edits an ordinary property with stable option identity", async () => {
+    const created = await asOwner(() =>
+      createDatabase.run({
+        spaceId,
+        title: "Property setup",
+        idempotencyKey: "property-database",
+      }),
+    );
+    const initial = await asOwner(() =>
+      readDatabase.run({ databaseId: created.database.id }),
+    );
+    if (!("mutationContract" in initial) || !initial.mutationContract) {
+      throw new Error("Expected a database mutation contract");
+    }
+    const target = {
+      spaceId,
+      databaseId: created.database.id,
+      databaseDocumentId: created.database.documentId,
+    };
+    const property = await asOwner(() =>
+      configureProperty.run({
+        operation: "create",
+        target,
+        expectedSchemaRevision: initial.mutationContract!.schemaRevision,
+        idempotencyKey: "create-status",
+        definition: {
+          name: "Status",
+          type: "status",
+          options: [
+            { id: "draft", name: "Draft", color: "gray" },
+            { id: "ready", name: "Ready", color: "green" },
+          ],
+        },
+      }),
+    );
+    expect(property.receipt).toMatchObject({
+      outcome: "created",
+      propertyId: property.value.id,
+      readback: { verified: true },
+    });
+    expect(
+      (
+        await asOwner(() =>
+          configureProperty.run({
+            operation: "create",
+            target,
+            expectedSchemaRevision: initial.mutationContract!.schemaRevision,
+            idempotencyKey: "create-status",
+            definition: {
+              name: "Status",
+              type: "status",
+              options: [
+                { id: "draft", name: "Draft", color: "gray" },
+                { id: "ready", name: "Ready", color: "green" },
+              ],
+            },
+          }),
+        )
+      ).receipt.idempotency.result,
+    ).toBe("replayed");
+
+    const fresh = await asOwner(() =>
+      readDatabase.run({ databaseId: created.database.id }),
+    );
+    if (!("mutationContract" in fresh) || !fresh.mutationContract) {
+      throw new Error("Expected a fresh database mutation contract");
+    }
+    const updated = await asOwner(() =>
+      configureProperty.run({
+        operation: "update",
+        target,
+        expectedSchemaRevision: fresh.mutationContract!.schemaRevision,
+        idempotencyKey: "rename-status",
+        propertyId: property.value.id,
+        patch: {
+          name: "Stage",
+          optionEdits: [
+            {
+              operation: "update",
+              optionId: "ready",
+              patch: { name: "Approved" },
+            },
+            { operation: "reorder", optionIds: ["ready", "draft"] },
+          ],
+        },
+      }),
+    );
+    expect(updated.value).toMatchObject({
+      id: property.value.id,
+      name: "Stage",
+      options: {
+        options: [
+          { id: "ready", name: "Approved" },
+          { id: "draft", name: "Draft" },
+        ],
+      },
+    });
+    await expect(
+      asOwner(() =>
+        configureProperty.run({
+          operation: "update",
+          target,
+          expectedSchemaRevision: initial.mutationContract!.schemaRevision,
+          idempotencyKey: "stale-property",
+          propertyId: property.value.id,
+          patch: { name: "Overwritten" },
+        }),
+      ),
+    ).rejects.toMatchObject({ errorCode: "SCHEMA_REVISION_CONFLICT" });
+  });
+
+  it("creates and sparsely updates a table view without widening invalid filters", async () => {
+    const created = await asOwner(() =>
+      createDatabase.run({
+        spaceId,
+        title: "View setup",
+        idempotencyKey: "view-database",
+      }),
+    );
+    await getDb()
+      .update(schema.contentDatabases)
+      .set({
+        viewConfigJson: JSON.stringify({
+          activeViewId: "default",
+          views: [
+            {
+              id: "default",
+              name: "Table",
+              type: "table",
+              sorts: [],
+              filters: [],
+              columnWidths: {},
+              futureSetting: { preserved: true },
+            },
+          ],
+          futureTopLevel: "preserved",
+        }),
+      })
+      .where(eq(schema.contentDatabases.id, created.database.id));
+    const initial = await asOwner(() =>
+      readDatabase.run({ databaseId: created.database.id }),
+    );
+    if (
+      !("mutationContract" in initial) ||
+      !initial.mutationContract ||
+      !("configurationRevision" in initial)
+    ) {
+      throw new Error("Expected setup revisions");
+    }
+    const target = {
+      spaceId,
+      databaseId: created.database.id,
+      databaseDocumentId: created.database.documentId,
+    };
+    const view = await asOwner(() =>
+      updateView.run({
+        operation: "create",
+        target,
+        expectedSchemaRevision: initial.mutationContract!.schemaRevision,
+        expectedConfigurationRevision: initial.configurationRevision,
+        idempotencyKey: "create-ready-view",
+        view: {
+          name: "Ready drafts",
+          type: "table",
+          config: { rowDensity: "compact", tableColumnOrderIds: ["name"] },
+        },
+      }),
+    );
+    expect(view.receipt).toMatchObject({
+      outcome: "created",
+      viewId: view.value.id,
+      readback: { verified: true },
+    });
+    const rawAfterCreate = await getDb()
+      .select({ value: schema.contentDatabases.viewConfigJson })
+      .from(schema.contentDatabases)
+      .where(eq(schema.contentDatabases.id, created.database.id));
+    expect(JSON.parse(rawAfterCreate[0]!.value!)).toMatchObject({
+      futureTopLevel: "preserved",
+      views: expect.arrayContaining([
+        expect.objectContaining({ futureSetting: { preserved: true } }),
+      ]),
+    });
+
+    const fresh = await asOwner(() =>
+      readDatabase.run({ databaseId: created.database.id }),
+    );
+    if (
+      !("mutationContract" in fresh) ||
+      !fresh.mutationContract ||
+      !("configurationRevision" in fresh)
+    ) {
+      throw new Error("Expected fresh setup revisions");
+    }
+    const updated = await asOwner(() =>
+      updateView.run({
+        operation: "update",
+        target,
+        expectedSchemaRevision: fresh.mutationContract!.schemaRevision,
+        expectedConfigurationRevision: fresh.configurationRevision,
+        idempotencyKey: "update-ready-view",
+        viewId: view.value.id,
+        patch: { wrapCells: true },
+      }),
+    );
+    expect(updated.value).toMatchObject({
+      id: view.value.id,
+      name: "Ready drafts",
+      rowDensity: "compact",
+      wrapCells: true,
+    });
+
+    const latest = await asOwner(() =>
+      readDatabase.run({ databaseId: created.database.id }),
+    );
+    if (
+      !("mutationContract" in latest) ||
+      !latest.mutationContract ||
+      !("configurationRevision" in latest)
+    ) {
+      throw new Error("Expected latest setup revisions");
+    }
+    await expect(
+      asOwner(() =>
+        updateView.run({
+          operation: "update",
+          target,
+          expectedSchemaRevision: latest.mutationContract!.schemaRevision,
+          expectedConfigurationRevision: latest.configurationRevision,
+          idempotencyKey: "invalid-filter",
+          viewId: view.value.id,
+          patch: {
+            filters: [
+              {
+                key: "missing-property",
+                label: "Missing",
+                operator: "equals",
+                value: "anything",
+              },
+            ],
+          },
+        }),
+      ),
+    ).rejects.toMatchObject({ errorCode: "INVALID_VIEW_REFERENCE" });
+    const afterInvalid = await asOwner(() =>
+      readDatabase.run({ databaseId: created.database.id }),
+    );
+    expect(
+      "configurationRevision" in afterInvalid
+        ? afterInvalid.configurationRevision
+        : null,
+    ).toBe(latest.configurationRevision);
+  });
+});
diff --git a/templates/content/actions/database-row-batch-actions.db.test.ts b/templates/content/actions/database-row-batch-actions.db.test.ts
index d348cd7b608..7f0e19dbd26 100644
--- a/templates/content/actions/database-row-batch-actions.db.test.ts
+++ b/templates/content/actions/database-row-batch-actions.db.test.ts
@@ -24,8 +24,11 @@ let addDatabaseItemAction: typeof import("./add-database-item.js").default;
 let lockDatabaseMemberships: typeof import("./_database-membership-lock.js").lockDatabaseMemberships;
 let replaceMockSourceRows: typeof import("./_database-source-utils.js").replaceMockSourceRows;
 let setDocumentPropertyAction: typeof import("./set-document-property.js").default;
+let getDocumentAction: typeof import("./get-document.js").default;
+let listDocumentPropertiesAction: typeof import("./list-document-properties.js").default;
 let getContentDatabaseAction: typeof import("./get-content-database.js").default;
 let updateDatabaseItemsAction: typeof import("./update-database-items.js").default;
+let updateDatabaseItemAction: typeof import("./update-database-item.js").default;
 let nextAppendPosition: typeof import("./_position-utils.js").nextAppendPosition;
 let createAppendPositionAllocator: typeof import("./_position-utils.js").createAppendPositionAllocator;
 let spaceId: string;
@@ -55,10 +58,15 @@ beforeAll(async () => {
     await import("./_position-utils.js"));
   setDocumentPropertyAction = (await import("./set-document-property.js"))
     .default;
+  getDocumentAction = (await import("./get-document.js")).default;
+  listDocumentPropertiesAction = (await import("./list-document-properties.js"))
+    .default;
   getContentDatabaseAction = (await import("./get-content-database.js"))
     .default;
   updateDatabaseItemsAction = (await import("./update-database-items.js"))
     .default;
+  updateDatabaseItemAction = (await import("./update-database-item.js"))
+    .default;
   const plugin = (await import("../server/plugins/db.js")).default;
   await plugin(undefined as any);
   const { systemIdsForContentSpace } = await import("./_content-spaces.js");
@@ -1015,6 +1023,352 @@ describe("database row batch actions", () => {
     expect(await orderedRows(databaseId)).toHaveLength(1);
   });
 
+  it("rejects document property writes for a mapped secondary field without a row overlay", async () => {
+    const { databaseId, rows } = await createDatabaseWithRows(1);
+    const now = new Date().toISOString();
+    const propertyId = nextId("source_managed_property");
+    const primarySourceId = nextId("primary_source");
+    const secondarySourceId = nextId("secondary_source");
+    const normalizationFormula = "lower(trim({slug}))";
+    const federation = (role: "primary" | "secondary") => ({
+      role,
+      keyField: "slug",
+      normalizationFormula,
+      join: {
+        kind: "identity",
+        collection: null,
+        localExpr: "{slug}",
+        remoteKeyField: "slug",
+        normalizationFormula,
+      },
+    });
+
+    await getDb().insert(schema.documentPropertyDefinitions).values({
+      id: propertyId,
+      ownerEmail: OWNER,
+      databaseId,
+      name: "Source owner",
+      type: "text",
+      visibility: "always_show",
+      optionsJson: "{}",
+      position: 0,
+      createdAt: now,
+      updatedAt: now,
+    });
+    await getDb()
+      .insert(schema.documentPropertyValues)
+      .values({
+        id: nextId("property_value"),
+        ownerEmail: OWNER,
+        documentId: rows[0].documentId,
+        propertyId,
+        valueJson: JSON.stringify("Original local value"),
+        createdAt: now,
+        updatedAt: now,
+      });
+    await getDb()
+      .insert(schema.contentDatabaseSources)
+      .values([
+        {
+          id: primarySourceId,
+          ownerEmail: OWNER,
+          databaseId,
+          sourceType: "mock-local",
+          sourceName: "Primary",
+          sourceTable: databaseId,
+          metadataJson: JSON.stringify({
+            primaryKey: "id",
+            titleField: "title",
+            federation: federation("primary"),
+          }),
+          createdAt: now,
+          updatedAt: now,
+        },
+        {
+          id: secondarySourceId,
+          ownerEmail: OWNER,
+          databaseId,
+          sourceType: "local-table",
+          sourceName: "Secondary",
+          sourceTable: nextId("upstream_database"),
+          metadataJson: JSON.stringify({
+            primaryKey: "id",
+            titleField: "title",
+            federation: federation("secondary"),
+          }),
+          createdAt: now,
+          updatedAt: now,
+        },
+      ]);
+    await getDb()
+      .insert(schema.contentDatabaseSourceRows)
+      .values({
+        id: nextId("primary_source_row"),
+        ownerEmail: OWNER,
+        sourceId: primarySourceId,
+        databaseItemId: rows[0].itemId,
+        documentId: rows[0].documentId,
+        sourceRowId: `mock-local-${rows[0].documentId}`,
+        sourceQualifiedId: `mock-local://${databaseId}/${rows[0].documentId}`,
+        sourceDisplayKey: "Row 0",
+        sourceValuesJson: "{}",
+        createdAt: now,
+        updatedAt: now,
+      });
+    await getDb()
+      .insert(schema.contentDatabaseSourceFields)
+      .values({
+        id: nextId("secondary_source_field"),
+        ownerEmail: OWNER,
+        sourceId: secondarySourceId,
+        propertyId,
+        localFieldKey: propertyId,
+        sourceFieldKey: "owner",
+        sourceFieldLabel: "Owner",
+        sourceFieldType: "text",
+        mappingType: "property",
+        writeOwner: "source",
+        readOnly: 1,
+        createdAt: now,
+        updatedAt: now,
+      });
+
+    const response = await runWithRequestContext({ userEmail: OWNER }, () =>
+      getContentDatabaseAction.run({ databaseId }),
+    );
+    if (!("items" in response)) throw new Error("Expected database rows");
+    const item = response.items.find(
+      (candidate) => candidate.document.id === rows[0].documentId,
+    );
+    expect(item?.sourceOverlays).toBeUndefined();
+    expect(
+      item?.properties.find(
+        (property) => property.definition.id === propertyId,
+      ),
+    ).toMatchObject({ value: null, editable: false });
+
+    await expect(
+      runWithRequestContext({ userEmail: OWNER }, () =>
+        setDocumentPropertyAction.run({
+          documentId: rows[0].documentId,
+          databaseId,
+          propertyId,
+          value: "Rejected write",
+        }),
+      ),
+    ).rejects.toMatchObject({ errorCode: "PROPERTY_NOT_WRITABLE" });
+    expect(
+      await getDb()
+        .select({ valueJson: schema.documentPropertyValues.valueJson })
+        .from(schema.documentPropertyValues)
+        .where(
+          and(
+            eq(schema.documentPropertyValues.documentId, rows[0].documentId),
+            eq(schema.documentPropertyValues.propertyId, propertyId),
+          ),
+        ),
+    ).toEqual([{ valueJson: JSON.stringify("Original local value") }]);
+  });
+
+  it("allows only locally owned writable mapped properties to save locally", async () => {
+    const { databaseId, databaseDocumentId, rows } =
+      await createDatabaseWithRows(1);
+    const now = new Date().toISOString();
+    const sourceId = nextId("source");
+    const mappings = [
+      { key: "local", writeOwner: "local", readOnly: 0 },
+      { key: "source", writeOwner: "source", readOnly: 0 },
+      { key: "derived", writeOwner: "derived", readOnly: 0 },
+      { key: "read_only", writeOwner: "local", readOnly: 1 },
+    ] as const;
+    const propertyIds = Object.fromEntries(
+      mappings.map(({ key }) => [key, nextId(`${key}_property`)]),
+    );
+
+    await getDb()
+      .insert(schema.documentPropertyDefinitions)
+      .values(
+        mappings.map(({ key }, position) => ({
+          id: propertyIds[key],
+          ownerEmail: OWNER,
+          databaseId,
+          name: key,
+          type: "text",
+          visibility: "always_show",
+          optionsJson: "{}",
+          position,
+          createdAt: now,
+          updatedAt: now,
+        })),
+      );
+    await getDb().insert(schema.contentDatabaseSources).values({
+      id: sourceId,
+      ownerEmail: OWNER,
+      databaseId,
+      sourceType: "mock-local",
+      sourceName: "Ownership fixture",
+      sourceTable: databaseId,
+      createdAt: now,
+      updatedAt: now,
+    });
+    await getDb()
+      .insert(schema.contentDatabaseSourceFields)
+      .values([
+        ...mappings.map(({ key, writeOwner, readOnly }) => ({
+          id: nextId(`${key}_source_field`),
+          ownerEmail: OWNER,
+          sourceId,
+          propertyId: propertyIds[key],
+          localFieldKey: key,
+          sourceFieldKey: key,
+          sourceFieldLabel: key,
+          sourceFieldType: "text",
+          mappingType: "property",
+          writeOwner,
+          readOnly,
+          createdAt: now,
+          updatedAt: now,
+        })),
+        {
+          id: nextId("additional_local_source_field"),
+          ownerEmail: OWNER,
+          sourceId,
+          propertyId: propertyIds.source,
+          localFieldKey: "source-local-copy",
+          sourceFieldKey: "source-local-copy",
+          sourceFieldLabel: "Additional local mapping",
+          sourceFieldType: "text",
+          mappingType: "property",
+          writeOwner: "local",
+          readOnly: 0,
+          createdAt: now,
+          updatedAt: now,
+        },
+      ]);
+
+    const discovered = await runWithRequestContext({ userEmail: OWNER }, () =>
+      getContentDatabaseAction.run({ databaseId }),
+    );
+    if (!("items" in discovered) || !discovered.mutationContract) {
+      throw new Error("Expected a database mutation contract");
+    }
+    expect(
+      discovered.mutationContract.properties.find(
+        (property) => property.id === propertyIds.local,
+      ),
+    ).toMatchObject({ writable: true, sourceManaged: false });
+    expect(
+      discovered.items[0].properties.find(
+        (property) => property.definition.id === propertyIds.local,
+      ),
+    ).toMatchObject({ editable: true });
+    for (const key of ["source", "derived", "read_only"] as const) {
+      expect(
+        discovered.mutationContract.properties.find(
+          (property) => property.id === propertyIds[key],
+        ),
+      ).toMatchObject({ writable: false, sourceManaged: true });
+      expect(
+        discovered.items[0].properties.find(
+          (property) => property.definition.id === propertyIds[key],
+        ),
+      ).toMatchObject({ editable: false });
+    }
+
+    const documentDetail = await runWithRequestContext(
+      { userEmail: OWNER },
+      () =>
+        getDocumentAction.run({
+          id: rows[0].documentId,
+          databaseId,
+          databaseDocumentId,
+        }),
+    );
+    const propertyPanel = await runWithRequestContext(
+      { userEmail: OWNER },
+      () =>
+        listDocumentPropertiesAction.run({
+          documentId: rows[0].documentId,
+          databaseId,
+        }),
+    );
+    for (const response of [documentDetail, propertyPanel]) {
+      expect(
+        response.properties.find(
+          (property) => property.definition.id === propertyIds.local,
+        ),
+      ).toMatchObject({ editable: true });
+      for (const key of ["source", "derived", "read_only"] as const) {
+        expect(
+          response.properties.find(
+            (property) => property.definition.id === propertyIds[key],
+          ),
+        ).toMatchObject({ editable: false });
+      }
+    }
+
+    const guardedResult = await runWithRequestContext(
+      { userEmail: OWNER },
+      () =>
+        updateDatabaseItemAction.run({
+          target: discovered.mutationContract!.target,
+          expectedSchemaRevision: discovered.mutationContract!.schemaRevision,
+          idempotencyKey: nextId("local_field_update"),
+          itemId: discovered.items[0].id,
+          documentId: discovered.items[0].document.id,
+          expectedRowRevision: discovered.items[0].rowRevision!,
+          propertyValues: { [propertyIds.local]: "Saved by guarded update" },
+        }),
+    );
+    expect(guardedResult.receipt.readback.propertyValues).toMatchObject({
+      [propertyIds.local]: "Saved by guarded update",
+    });
+
+    const localResult = await runWithRequestContext({ userEmail: OWNER }, () =>
+      setDocumentPropertyAction.run({
+        documentId: rows[0].documentId,
+        databaseId,
+        propertyId: propertyIds.local,
+        value: "Saved locally",
+      }),
+    );
+    expect(
+      localResult.properties.find(
+        (property) => property.definition.id === propertyIds.local,
+      ),
+    ).toMatchObject({ value: "Saved locally", editable: true });
+
+    for (const key of ["source", "derived", "read_only"] as const) {
+      await expect(
+        runWithRequestContext({ userEmail: OWNER }, () =>
+          setDocumentPropertyAction.run({
+            documentId: rows[0].documentId,
+            databaseId,
+            propertyId: propertyIds[key],
+            value: "Rejected write",
+          }),
+        ),
+      ).rejects.toMatchObject({ errorCode: "PROPERTY_NOT_WRITABLE" });
+    }
+
+    expect(
+      await getDb()
+        .select({
+          propertyId: schema.documentPropertyValues.propertyId,
+          valueJson: schema.documentPropertyValues.valueJson,
+        })
+        .from(schema.documentPropertyValues)
+        .where(
+          eq(schema.documentPropertyValues.documentId, rows[0].documentId),
+        ),
+    ).toEqual([
+      {
+        propertyId: propertyIds.local,
+        valueJson: JSON.stringify("Saved locally"),
+      },
+    ]);
+  });
+
   it("serializes a racing source association before membership removal", async () => {
     const { databaseId, rows } = await createDatabaseWithRows(1);
     const now = new Date().toISOString();
diff --git a/templates/content/actions/database-row-links.test.ts b/templates/content/actions/database-row-links.test.ts
new file mode 100644
index 00000000000..c641340f807
--- /dev/null
+++ b/templates/content/actions/database-row-links.test.ts
@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+
+import type { ContentDatabaseRowMutationResult } from "../shared/api.js";
+import addDatabaseItem from "./add-database-item.js";
+import updateDatabaseItem from "./update-database-item.js";
+import upsertDatabaseItemByKey from "./upsert-database-item-by-key.js";
+
+const result = {
+  receipt: {
+    target: {
+      databaseId: "database & one",
+      databaseDocumentId: "database/page",
+    },
+    row: { documentId: "row/page" },
+  },
+} as unknown as ContentDatabaseRowMutationResult;
+
+describe("database row action links", () => {
+  it.each([
+    ["add-database-item", addDatabaseItem],
+    ["update-database-item", updateDatabaseItem],
+    ["upsert-database-item-by-key", upsertDatabaseItemByKey],
+  ])("preserves membership context for %s", (_name, action) => {
+    expect(typeof action.link).toBe("function");
+    const link = (action.link as Function)({ args: {}, result });
+    const url = new URL(link.url, "http://content.test");
+
+    expect(url.pathname).toBe("/_agent-native/open");
+    expect(url.searchParams.get("view")).toBe("editor");
+    expect(url.searchParams.get("documentId")).toBe("row/page");
+    expect(url.searchParams.get("databaseId")).toBe("database & one");
+    expect(url.searchParams.get("databaseDocumentId")).toBe("database/page");
+  });
+});
diff --git a/templates/content/actions/database-setup-mcp.db.test.ts b/templates/content/actions/database-setup-mcp.db.test.ts
new file mode 100644
index 00000000000..e2bb3d5f097
--- /dev/null
+++ b/templates/content/actions/database-setup-mcp.db.test.ts
@@ -0,0 +1,967 @@
+import { rmSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  loadActionsFromStaticRegistry,
+  runFrameworkReleaseMigrations,
+  runWithRequestContext,
+} from "@agent-native/core/server";
+import { and, eq } from "drizzle-orm";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+import {
+  createMCPServerForRequest,
+  type MCPCallerIdentity,
+  type MCPConfig,
+} from "../../../packages/core/src/mcp/build-server.js";
+
+const requireFromCore = createRequire(
+  new URL("../../../packages/core/package.json", import.meta.url),
+);
+const [{ Client }, { InMemoryTransport }] = await Promise.all([
+  import(requireFromCore.resolve("@modelcontextprotocol/client")),
+  import(requireFromCore.resolve("@modelcontextprotocol/server")),
+]);
+type MCPClient = InstanceType<typeof Client>;
+
+// guard:allow-unscoped — isolated test database verifies the external MCP protocol boundary.
+const databasePath = join(
+  tmpdir(),
+  `content-setup-mcp-${process.pid}-${Date.now()}.pglite`,
+);
+const databaseUrl =
+  process.env.CONTENT_SETUP_POSTGRES_URL ?? `pglite:${databasePath}`;
+const owner = "mcp-setup-owner@example.com";
+const outsider = "mcp-setup-outsider@example.com";
+const sessions: Array<{
+  client: MCPClient;
+  server: Awaited<ReturnType<typeof createMCPServerForRequest>>;
+}> = [];
+
+let actions: MCPConfig["actions"];
+let getDb: typeof import("../server/db/index.js").getDb;
+let schema: typeof import("../server/db/schema.js");
+let ownerClient: MCPClient;
+let secondOwnerClient: MCPClient;
+let outsiderClient: MCPClient;
+
+function callerIdentity(userEmail: string): MCPCallerIdentity {
+  return {
+    userEmail,
+    orgDomain: undefined,
+    oauthScopes: ["mcp:read", "mcp:write"],
+  };
+}
+
+async function connect(userEmail: string) {
+  const server = await createMCPServerForRequest(
+    {
+      name: "Content",
+      appId: "content",
+      description: "Agent-Native Content",
+      version: "1.0.0-test",
+      actions,
+      productionActions: actions,
+      builtinCrossAppTools: false,
+      externalAgents: { writes: "allowlisted" },
+    },
+    callerIdentity(userEmail),
+    {
+      origin: "http://content.test",
+      transport: "http",
+      fullSurface: true,
+      inlineMcpApps: false,
+    },
+  );
+  const [clientTransport, serverTransport] =
+    InMemoryTransport.createLinkedPair();
+  const client = new Client({
+    name: "content-database-setup-test",
+    version: "1.0.0",
+  });
+  await Promise.all([
+    client.connect(clientTransport),
+    server.connect(serverTransport),
+  ]);
+  sessions.push({ client, server });
+  return client;
+}
+
+type ProtocolResult = Awaited<ReturnType<MCPClient["callTool"]>>;
+
+function resultText(result: ProtocolResult): string {
+  return (
+    result.content.find(
+      (
+        entry,
+      ): entry is Extract<(typeof result.content)[number], { type: "text" }> =>
+        entry.type === "text",
+    )?.text ?? ""
+  );
+}
+
+async function callJson<T extends Record<string, unknown>>(
+  client: MCPClient,
+  name: string,
+  args: Record<string, unknown>,
+): Promise<T> {
+  const result = await client.callTool({ name, arguments: args });
+  expect(result.isError, resultText(result)).not.toBe(true);
+  if (
+    result.structuredContent &&
+    typeof result.structuredContent === "object"
+  ) {
+    return result.structuredContent as T;
+  }
+  return JSON.parse(resultText(result)) as T;
+}
+
+async function callError(
+  client: MCPClient,
+  name: string,
+  args: Record<string, unknown>,
+) {
+  const result = await client.callTool({ name, arguments: args });
+  expect(result.isError).toBe(true);
+  return resultText(result);
+}
+
+beforeAll(async () => {
+  if (
+    databaseUrl.startsWith("postgres") &&
+    !new URL(databaseUrl).pathname.includes("test")
+  ) {
+    throw new Error(
+      "CONTENT_SETUP_POSTGRES_URL must be an isolated test database",
+    );
+  }
+  process.env.DATABASE_URL = databaseUrl;
+  const database = await import("../server/db/index.js");
+  getDb = database.getDb;
+  schema = database.schema;
+  if (databaseUrl.startsWith("postgres")) {
+    await runFrameworkReleaseMigrations(undefined);
+  }
+  await (await import("../server/plugins/db.js")).default(undefined as never);
+  const { provisionContentSpaces } = await import("./_content-spaces.js");
+  await runWithRequestContext({ userEmail: owner }, () =>
+    provisionContentSpaces(getDb(), owner),
+  );
+  await runWithRequestContext({ userEmail: outsider }, () =>
+    provisionContentSpaces(getDb(), outsider),
+  );
+  const { default: actionModules } =
+    await import("../.generated/actions-registry.js");
+  actions = loadActionsFromStaticRegistry(actionModules);
+  [ownerClient, secondOwnerClient, outsiderClient] = await Promise.all([
+    connect(owner),
+    connect(owner),
+    connect(outsider),
+  ]);
+}, 120_000);
+
+afterAll(async () => {
+  await Promise.all(
+    sessions.flatMap(({ client, server }) => [client.close(), server.close()]),
+  );
+  if (!databaseUrl.startsWith("postgres")) {
+    rmSync(databasePath, { recursive: true, force: true });
+  }
+});
+
+describe("ordinary database setup through external MCP", () => {
+  it("discovers and invokes the authenticated setup, row, read-back, replay, denial, and cleanup story", async () => {
+    const listed = await ownerClient.listTools();
+    const toolByName = new Map(listed.tools.map((tool) => [tool.name, tool]));
+    const requiredTools = [
+      "list-content-spaces",
+      "create-content-database",
+      "configure-document-property",
+      "update-content-database-view",
+      "describe-content-database",
+      "get-content-database",
+      "get-content-database-source",
+      "add-database-item",
+      "update-database-item",
+      "upsert-database-item-by-key",
+      "delete-content-database",
+      "restore-content-database",
+      "list-trashed-content-databases",
+    ];
+    expect([...toolByName.keys()]).toEqual(
+      expect.arrayContaining(requiredTools),
+    );
+    expect([...toolByName.keys()]).not.toEqual(
+      expect.arrayContaining([
+        "attach-content-database-source",
+        "bind-content-database-source-field",
+        "change-content-database-source-role",
+        "add-content-database-source-field-property",
+      ]),
+    );
+
+    for (const name of requiredTools) {
+      expect(toolByName.get(name)?.inputSchema.type, name).toBe("object");
+    }
+    const propertySchema = JSON.stringify(
+      toolByName.get("configure-document-property")?.inputSchema,
+    );
+    expect(propertySchema).toContain("expectedSchemaRevision");
+    expect(propertySchema).toContain("databaseDocumentId");
+    expect(propertySchema).not.toContain("authorityScope");
+    expect(propertySchema).not.toContain("sourceId");
+    const viewSchema = JSON.stringify(
+      toolByName.get("update-content-database-view")?.inputSchema,
+    );
+    expect(viewSchema).toContain("expectedConfigurationRevision");
+    expect(viewSchema).toContain("frozenThroughColumnId");
+    expect(viewSchema).not.toContain("activeViewId");
+    const sourceSchema = JSON.stringify(
+      toolByName.get("get-content-database-source")?.inputSchema,
+    );
+    expect(sourceSchema).toContain('\"statusOnly\"');
+    expect(sourceSchema).toContain('\"const\":true');
+
+    const spaces = await callJson<{
+      spaces: Array<{
+        id: string;
+        canCreateDatabase: boolean;
+      }>;
+    }>(ownerClient, "list-content-spaces", {});
+    const space = spaces.spaces.find(
+      (candidate) => candidate.canCreateDatabase,
+    );
+    expect(space).toBeDefined();
+
+    const createInput = {
+      spaceId: space!.id,
+      title: "MCP-DB-QA-protocol Campaign tracker",
+      description: "Protocol integration fixture",
+      idempotencyKey: "mcp-create-campaign-tracker",
+    };
+    const created = await callJson<any>(
+      ownerClient,
+      "create-content-database",
+      createInput,
+    );
+    const replayedCreate = await callJson<any>(
+      ownerClient,
+      "create-content-database",
+      createInput,
+    );
+    expect(replayedCreate.database.id).toBe(created.database.id);
+    expect(replayedCreate.receipt.receiptId).toBe(created.receipt.receiptId);
+    expect(replayedCreate.receipt.idempotency.result).toBe("replayed");
+    expect(created.receipt.readback).toEqual({ verified: true });
+
+    const { queryAuditEvents } = await import("@agent-native/core/audit");
+    const createAuditEvents = await queryAuditEvents(
+      { userEmail: owner },
+      {
+        action: "create-content-database",
+        targetType: "content-database",
+        targetId: created.database.id,
+      },
+    );
+    expect(createAuditEvents).toHaveLength(2);
+    const appliedAudit = createAuditEvents.find((event) =>
+      event.summary?.startsWith("create-content-database;"),
+    );
+    const replayAudit = createAuditEvents.find((event) =>
+      event.summary?.startsWith("Verified earlier operation;"),
+    );
+    expect(appliedAudit?.summary).toContain(
+      `receipt ${created.receipt.receiptId}`,
+    );
+    expect(appliedAudit?.summary).toContain(
+      `schema ${created.receipt.revisions.schemaBefore ?? "none"} -> ${created.receipt.revisions.schemaAfter}`,
+    );
+    expect(appliedAudit?.summary).toContain(
+      `configuration ${created.receipt.revisions.configurationBefore ?? "none"} -> ${created.receipt.revisions.configurationAfter}`,
+    );
+    expect(replayAudit?.summary).toContain(
+      `Verified earlier operation; receipt ${created.receipt.receiptId}`,
+    );
+    for (const event of createAuditEvents) {
+      expect(event.input).toBeNull();
+      expect(event.summary).not.toContain(createInput.title);
+      expect(event.summary).not.toContain(createInput.description);
+      expect(event.summary).not.toContain(createInput.idempotencyKey);
+    }
+
+    const target = {
+      spaceId: space!.id,
+      databaseId: created.database.id as string,
+      databaseDocumentId: created.database.documentId as string,
+    };
+    const denied = await callError(outsiderClient, "delete-content-database", {
+      target,
+      expectedConfigurationRevision:
+        created.receipt.revisions.configurationAfter,
+      idempotencyKey: "outsider-delete",
+    });
+    expect(denied).not.toContain(created.receipt.receiptId);
+
+    const described = await callJson<any>(
+      ownerClient,
+      "describe-content-database",
+      { databaseId: target.databaseId },
+    );
+    expect(described.database).toMatchObject({
+      id: target.databaseId,
+      documentId: target.databaseDocumentId,
+      spaceId: target.spaceId,
+      title: createInput.title,
+    });
+
+    const rejectedLegacyCreate = await callError(
+      ownerClient,
+      "create-content-database",
+      {
+        documentId: target.databaseDocumentId,
+        title: "Legacy create shape",
+      },
+    );
+    expect(rejectedLegacyCreate).toMatch(/invalid|required|unrecognized/i);
+    const rejectedSourceOverride = await callError(
+      ownerClient,
+      "create-content-database",
+      {
+        spaceId: target.spaceId,
+        title: "Source override",
+        idempotencyKey: "reject-create-source-override",
+        sourceId: "source-not-allowed",
+      },
+    );
+    expect(rejectedSourceOverride).toMatch(/invalid|unrecognized/i);
+    const afterRejectedCreates = await callJson<any>(
+      ownerClient,
+      "describe-content-database",
+      { databaseId: target.databaseId },
+    );
+    expect(afterRejectedCreates.database).toMatchObject({
+      id: target.databaseId,
+      documentId: target.databaseDocumentId,
+      title: createInput.title,
+    });
+
+    const rejectedLegacyProperty = await callError(
+      ownerClient,
+      "configure-document-property",
+      {
+        documentId: target.databaseDocumentId,
+        name: "Legacy property",
+        type: "text",
+      },
+    );
+    expect(rejectedLegacyProperty).toMatch(/invalid|required|unrecognized/i);
+
+    const rejectedProperty = await callError(
+      ownerClient,
+      "configure-document-property",
+      {
+        target,
+        expectedSchemaRevision: described.mutationContract.schemaRevision,
+        idempotencyKey: "reject-source-shaped-property",
+        operation: "create",
+        definition: {
+          name: "Managed status",
+          type: "status",
+          sourceId: "source-not-allowed",
+        },
+      },
+    );
+    expect(rejectedProperty).toMatch(/invalid|expected/i);
+
+    const campaignKey = await callJson<any>(
+      ownerClient,
+      "configure-document-property",
+      {
+        target,
+        expectedSchemaRevision: described.mutationContract.schemaRevision,
+        idempotencyKey: "create-campaign-key",
+        operation: "create",
+        definition: {
+          name: "Campaign key",
+          type: "text",
+          naturalKey: true,
+        },
+      },
+    );
+    const status = await callJson<any>(
+      ownerClient,
+      "configure-document-property",
+      {
+        target,
+        expectedSchemaRevision: campaignKey.receipt.revisions.schemaAfter,
+        idempotencyKey: "create-status",
+        operation: "create",
+        definition: {
+          name: "Status",
+          type: "status",
+          options: [
+            { id: "status-draft", name: "Draft", color: "gray" },
+            { id: "status-ready", name: "Ready", color: "green" },
+          ],
+        },
+      },
+    );
+    expect(
+      status.value.options.options.map((option: any) => option.id),
+    ).toEqual(["status-draft", "status-ready"]);
+
+    const publishDateInput = {
+      target,
+      expectedSchemaRevision: status.receipt.revisions.schemaAfter,
+      idempotencyKey: "create-publish-date-concurrently",
+      operation: "create",
+      definition: { name: "Publish date", type: "date" },
+    };
+    const concurrentProperties = await Promise.all([
+      callJson<any>(
+        ownerClient,
+        "configure-document-property",
+        publishDateInput,
+      ),
+      callJson<any>(
+        secondOwnerClient,
+        "configure-document-property",
+        publishDateInput,
+      ),
+    ]);
+    expect(concurrentProperties[0].value.id).toBe(
+      concurrentProperties[1].value.id,
+    );
+    expect(
+      concurrentProperties
+        .map((result) => result.receipt.idempotency.result)
+        .sort(),
+    ).toEqual(["applied", "replayed"]);
+    const staleProperty = await callError(
+      secondOwnerClient,
+      "configure-document-property",
+      {
+        target,
+        expectedSchemaRevision: status.receipt.revisions.schemaAfter,
+        idempotencyKey: "reject-stale-schema-intent",
+        operation: "create",
+        definition: { name: "Stale schema", type: "text" },
+      },
+    );
+    expect(staleProperty).toContain("schema changed");
+
+    const beforeView = await callJson<any>(
+      ownerClient,
+      "get-content-database",
+      { databaseId: target.databaseId, limit: 100, offset: 0 },
+    );
+    const rejectedLegacyViewReplacement = await callError(
+      ownerClient,
+      "update-content-database-view",
+      {
+        databaseId: target.databaseId,
+        viewConfig: JSON.parse(
+          JSON.stringify(beforeView.database.viewConfig),
+        ) as Record<string, unknown>,
+      },
+    );
+    expect(rejectedLegacyViewReplacement).toMatch(
+      /invalid|required|unrecognized/i,
+    );
+    const viewInput = {
+      target,
+      expectedSchemaRevision: beforeView.mutationContract.schemaRevision,
+      expectedConfigurationRevision: beforeView.configurationRevision,
+      idempotencyKey: "create-ready-drafts-view-concurrently",
+      operation: "create",
+      view: {
+        name: "Ready drafts",
+        type: "table",
+        config: {
+          propertyOrderIds: [campaignKey.value.id, status.value.id],
+          tableColumnOrderIds: ["name", campaignKey.value.id, status.value.id],
+          filters: [
+            {
+              key: status.value.id,
+              label: "Status",
+              operator: "contains",
+              value: "status-ready",
+            },
+          ],
+          rowDensity: "compact",
+          openPagesIn: "preview",
+        },
+      },
+    };
+    const concurrentViews = await Promise.all([
+      callJson<any>(ownerClient, "update-content-database-view", viewInput),
+      callJson<any>(
+        secondOwnerClient,
+        "update-content-database-view",
+        viewInput,
+      ),
+    ]);
+    expect(concurrentViews[0].value.id).toBe(concurrentViews[1].value.id);
+    expect(
+      concurrentViews.map((result) => result.receipt.idempotency.result).sort(),
+    ).toEqual(["applied", "replayed"]);
+    const view = concurrentViews[0];
+    const staleView = await callError(
+      secondOwnerClient,
+      "update-content-database-view",
+      {
+        target,
+        expectedSchemaRevision: beforeView.mutationContract.schemaRevision,
+        expectedConfigurationRevision: beforeView.configurationRevision,
+        idempotencyKey: "reject-stale-view-intent",
+        operation: "update",
+        viewId: view.value.id,
+        patch: { wrapCells: true },
+      },
+    );
+    expect(staleView).toContain("configuration changed");
+    expect(view.receipt.viewId).toBe(view.value.id);
+    expect(view.receipt.url).toContain(`viewId=${view.value.id}`);
+
+    const shareId = "mcp-setup-collaborator-share";
+    await getDb().insert(schema.documentShares).values({
+      id: shareId,
+      resourceId: target.databaseDocumentId,
+      principalType: "user",
+      principalId: outsider,
+      role: "editor",
+      createdBy: owner,
+      createdAt: new Date().toISOString(),
+    });
+    const beforeCollaboratorMutation = await callJson<any>(
+      outsiderClient,
+      "get-content-database",
+      { databaseId: target.databaseId, limit: 100, offset: 0 },
+    );
+    const collaboratorInput = {
+      target,
+      expectedSchemaRevision:
+        beforeCollaboratorMutation.mutationContract.schemaRevision,
+      idempotencyKey: "collaborator-replay-after-revocation",
+      operation: "create",
+      definition: { name: "Collaborator note", type: "text" },
+    };
+    const collaboratorMutation = await callJson<any>(
+      outsiderClient,
+      "configure-document-property",
+      collaboratorInput,
+    );
+    const collaboratorReplay = await callJson<any>(
+      outsiderClient,
+      "configure-document-property",
+      collaboratorInput,
+    );
+    expect(collaboratorReplay.receipt.receiptId).toBe(
+      collaboratorMutation.receipt.receiptId,
+    );
+    expect(collaboratorReplay.receipt.idempotency.result).toBe("replayed");
+    await getDb()
+      .update(schema.documentShares)
+      .set({ role: "viewer" })
+      .where(eq(schema.documentShares.id, shareId));
+    const viewerReplay = await callError(
+      outsiderClient,
+      "configure-document-property",
+      collaboratorInput,
+    );
+    expect(viewerReplay).not.toContain(collaboratorMutation.receipt.receiptId);
+    await getDb()
+      .delete(schema.documentShares)
+      .where(
+        and(
+          eq(schema.documentShares.id, shareId),
+          eq(schema.documentShares.principalId, outsider),
+        ),
+      );
+    const revokedReplay = await callError(
+      outsiderClient,
+      "configure-document-property",
+      collaboratorInput,
+    );
+    expect(revokedReplay).not.toContain(collaboratorMutation.receipt.receiptId);
+
+    const sourceStatus = await callJson<any>(
+      ownerClient,
+      "get-content-database-source",
+      { databaseId: target.databaseId, statusOnly: true },
+    );
+    expect(sourceStatus).toMatchObject({
+      database: { id: target.databaseId },
+      mode: "local",
+      source: null,
+    });
+    expect(sourceStatus).not.toHaveProperty("rows");
+    expect(sourceStatus).not.toHaveProperty("changeSets");
+
+    const beforeRow = await callJson<any>(ownerClient, "get-content-database", {
+      databaseId: target.databaseId,
+      limit: 100,
+      offset: 0,
+    });
+    expect(beforeRow.mutationContract.target).toMatchObject(target);
+    expect(beforeRow.items).toHaveLength(0);
+
+    const addInput = {
+      target,
+      expectedSchemaRevision: beforeRow.mutationContract.schemaRevision,
+      idempotencyKey: "create-campaign-row",
+      title: "September launch",
+      propertyEntries: [
+        {
+          propertyId: campaignKey.value.id,
+          propertyType: "text",
+          value: "launch-2026-09",
+        },
+        {
+          propertyId: status.value.id,
+          propertyType: "status",
+          value: "status-draft",
+        },
+      ],
+    };
+    const rejectedLegacyAdd = await callError(
+      ownerClient,
+      "add-database-item",
+      {
+        ...addInput,
+        idempotencyKey: "reject-legacy-add-property-values",
+        propertyValues: {
+          [campaignKey.value.id]: "legacy-campaign-key",
+        },
+      },
+    );
+    expect(rejectedLegacyAdd).toMatch(/invalid|unrecognized/i);
+    const added = await callJson<any>(
+      ownerClient,
+      "add-database-item",
+      addInput,
+    );
+    const replayedAdd = await callJson<any>(
+      ownerClient,
+      "add-database-item",
+      addInput,
+    );
+    expect(replayedAdd.receipt.row).toEqual(added.receipt.row);
+    expect(replayedAdd.receipt.idempotency.result).toBe("replayed");
+    expect(added.receipt.row.urlPath).toContain(
+      `databaseId=${target.databaseId}`,
+    );
+    expect(added.receipt.row.urlPath).toContain(
+      `databaseDocumentId=${target.databaseDocumentId}`,
+    );
+
+    const addedRead = await callJson<any>(ownerClient, "get-content-database", {
+      databaseId: target.databaseId,
+      limit: 100,
+      offset: 0,
+    });
+    const addedItem = addedRead.items.find(
+      (item: any) => item.id === added.receipt.row.itemId,
+    );
+    expect(addedItem.document.id).toBe(added.receipt.row.documentId);
+    expect(addedItem.rowRevision).toBe(added.receipt.row.rowRevision);
+
+    const rejectedLegacyUpdate = await callError(
+      ownerClient,
+      "update-database-item",
+      {
+        target,
+        expectedSchemaRevision: addedRead.mutationContract.schemaRevision,
+        expectedRowRevision: addedItem.rowRevision,
+        idempotencyKey: "reject-legacy-update-property-values",
+        itemId: addedItem.id,
+        documentId: addedItem.document.id,
+        propertyEntries: [
+          {
+            propertyId: status.value.id,
+            propertyType: "status",
+            value: "status-ready",
+          },
+        ],
+        propertyValues: { [status.value.id]: "status-ready" },
+      },
+    );
+    expect(rejectedLegacyUpdate).toMatch(/invalid|unrecognized/i);
+    const rejectedLegacyUpsert = await callError(
+      ownerClient,
+      "upsert-database-item-by-key",
+      {
+        target,
+        expectedSchemaRevision: addedRead.mutationContract.schemaRevision,
+        expectedRowRevision: addedItem.rowRevision,
+        idempotencyKey: "reject-legacy-upsert-property-values",
+        keyValue: "launch-2026-09",
+        propertyEntries: [
+          {
+            propertyId: status.value.id,
+            propertyType: "status",
+            value: "status-ready",
+          },
+        ],
+        propertyValues: { [status.value.id]: "status-ready" },
+      },
+    );
+    expect(rejectedLegacyUpsert).toMatch(/invalid|unrecognized/i);
+
+    const updated = await callJson<any>(ownerClient, "update-database-item", {
+      target,
+      expectedSchemaRevision: addedRead.mutationContract.schemaRevision,
+      expectedRowRevision: addedItem.rowRevision,
+      idempotencyKey: "ready-campaign-row",
+      itemId: addedItem.id,
+      documentId: addedItem.document.id,
+      propertyEntries: [
+        {
+          propertyId: status.value.id,
+          propertyType: "status",
+          value: "status-ready",
+        },
+      ],
+    });
+    expect(updated.receipt.row.itemId).toBe(added.receipt.row.itemId);
+    expect(updated.receipt.row.documentId).toBe(added.receipt.row.documentId);
+
+    const sourceId = "mcp-setup-source";
+    const now = new Date().toISOString();
+    await getDb()
+      .insert(schema.contentDatabaseSources)
+      .values({
+        id: sourceId,
+        ownerEmail: owner,
+        databaseId: target.databaseId,
+        sourceType: "mock-local",
+        sourceName: "Protocol source",
+        sourceTable: "campaigns",
+        capabilitiesJson: JSON.stringify({ canRefresh: true }),
+        metadataJson: JSON.stringify({
+          primaryKey: "id",
+          connectionId: "private-connection-metadata",
+          notes: "private-source-notes",
+        }),
+        lastError: "private provider failure detail",
+        createdAt: now,
+        updatedAt: now,
+      });
+    await getDb()
+      .insert(schema.contentDatabaseSourceRows)
+      .values({
+        id: "mcp-setup-source-row",
+        ownerEmail: owner,
+        sourceId,
+        databaseItemId: added.receipt.row.itemId,
+        documentId: added.receipt.row.documentId,
+        sourceRowId: "provider-row-1",
+        sourceQualifiedId: "campaigns:provider-row-1",
+        sourceDisplayKey: "September launch",
+        sourceValuesJson: JSON.stringify({
+          internalPayload: "must be omitted",
+        }),
+        createdAt: now,
+        updatedAt: now,
+      });
+    await getDb()
+      .insert(schema.contentDatabaseSourceChangeSets)
+      .values({
+        id: "mcp-setup-source-change",
+        ownerEmail: owner,
+        sourceId,
+        databaseItemId: added.receipt.row.itemId,
+        documentId: added.receipt.row.documentId,
+        summary: "Private change-set detail",
+        fieldChangesJson: JSON.stringify([
+          { propertyId: status.value.id, proposedValue: "status-ready" },
+        ]),
+        createdAt: now,
+        updatedAt: now,
+      });
+    const sourceBackedStatus = await callJson<any>(
+      ownerClient,
+      "get-content-database-source",
+      { databaseId: target.databaseId },
+    );
+    expect(sourceBackedStatus).toMatchObject({
+      database: { id: target.databaseId },
+      mode: "source-backed",
+      source: {
+        id: sourceId,
+        rows: [],
+        changeSets: [],
+        projection: { rows: "omitted", changeSets: "omitted" },
+        lastError: "Source reports an error; inspect its settings in Content.",
+      },
+    });
+    expect(sourceBackedStatus.source.metadata).not.toHaveProperty(
+      "connectionId",
+    );
+    expect(sourceBackedStatus.source.metadata).not.toHaveProperty("notes");
+
+    const outsiderSpaces = await callJson<{
+      spaces: Array<{ id: string; canCreateDatabase: boolean }>;
+    }>(outsiderClient, "list-content-spaces", {});
+    const outsiderSpace = outsiderSpaces.spaces.find(
+      (candidate) => candidate.canCreateDatabase,
+    );
+    expect(outsiderSpace).toBeDefined();
+    const inaccessibleSourceTitle = "Private source target";
+    const inaccessibleSource = await callJson<any>(
+      outsiderClient,
+      "create-content-database",
+      {
+        spaceId: outsiderSpace!.id,
+        title: inaccessibleSourceTitle,
+        idempotencyKey: "create-inaccessible-source-target",
+      },
+    );
+    await getDb()
+      .update(schema.contentDatabaseSources)
+      .set({
+        sourceType: "local-table",
+        sourceTable: inaccessibleSource.database.id,
+        updatedAt: new Date().toISOString(),
+      })
+      .where(eq(schema.contentDatabaseSources.id, sourceId));
+    const inaccessibleSourceError = await callError(
+      ownerClient,
+      "get-content-database-source",
+      { databaseId: target.databaseId, statusOnly: true },
+    );
+    expect(inaccessibleSourceError).toContain("SOURCE_UNAVAILABLE");
+    expect(inaccessibleSourceError).not.toContain(
+      inaccessibleSource.database.id,
+    );
+    expect(inaccessibleSourceError).not.toContain(inaccessibleSourceTitle);
+    await getDb()
+      .update(schema.contentDatabaseSources)
+      .set({
+        sourceType: "mock-local",
+        sourceTable: "campaigns",
+        updatedAt: new Date().toISOString(),
+      })
+      .where(eq(schema.contentDatabaseSources.id, sourceId));
+
+    const filteredRead = await callJson<any>(
+      ownerClient,
+      "get-content-database",
+      {
+        databaseId: target.databaseId,
+        limit: 100,
+        offset: 0,
+        tableQuery: {
+          search: "",
+          filters: [
+            {
+              key: status.value.id,
+              label: "Status",
+              operator: "contains",
+              value: "status-ready",
+            },
+          ],
+          sorts: [],
+          filterMode: "and",
+        },
+      },
+    );
+    expect(filteredRead.items.map((item: any) => item.id)).toEqual([
+      added.receipt.row.itemId,
+    ]);
+
+    const rejectedLegacyDelete = await callError(
+      ownerClient,
+      "delete-content-database",
+      { databaseId: target.databaseId },
+    );
+    expect(rejectedLegacyDelete).toMatch(/invalid|required/i);
+    const afterRejectedDelete = await callJson<any>(
+      ownerClient,
+      "get-content-database",
+      { databaseId: target.databaseId, limit: 100, offset: 0 },
+    );
+    expect(afterRejectedDelete.available).not.toBe(false);
+
+    const trashed = await callJson<any>(
+      ownerClient,
+      "delete-content-database",
+      {
+        target,
+        expectedConfigurationRevision: filteredRead.configurationRevision,
+        idempotencyKey: "trash-campaign-tracker",
+      },
+    );
+    expect(trashed.receipt.outcome).toBe("trashed");
+    const trashRead = await callJson<any>(
+      ownerClient,
+      "list-trashed-content-databases",
+      {},
+    );
+    expect(
+      trashRead.databases.filter(
+        (database: any) => database.databaseId === target.databaseId,
+      ),
+    ).toHaveLength(1);
+
+    const rejectedLegacyRestore = await callError(
+      ownerClient,
+      "restore-content-database",
+      { databaseId: target.databaseId },
+    );
+    expect(rejectedLegacyRestore).toMatch(/invalid|required/i);
+    const trashAfterRejectedRestore = await callJson<any>(
+      ownerClient,
+      "list-trashed-content-databases",
+      {},
+    );
+    expect(
+      trashAfterRejectedRestore.databases.filter(
+        (database: any) => database.databaseId === target.databaseId,
+      ),
+    ).toHaveLength(1);
+
+    const restored = await callJson<any>(
+      ownerClient,
+      "restore-content-database",
+      {
+        target,
+        expectedConfigurationRevision:
+          trashed.receipt.revisions.configurationAfter,
+        idempotencyKey: "restore-campaign-tracker",
+      },
+    );
+    expect(restored.receipt.outcome).toBe("restored");
+    const restoredRead = await callJson<any>(
+      ownerClient,
+      "get-content-database",
+      { databaseId: target.databaseId, limit: 100, offset: 0 },
+    );
+    expect(restoredRead.items[0]).toMatchObject({
+      id: added.receipt.row.itemId,
+      document: { id: added.receipt.row.documentId },
+    });
+    expect(
+      restoredRead.database.viewConfig.views.some(
+        (candidate: any) => candidate.id === view.value.id,
+      ),
+    ).toBe(true);
+
+    await callJson<any>(ownerClient, "delete-content-database", {
+      target,
+      expectedConfigurationRevision: restoredRead.configurationRevision,
+      idempotencyKey: "trash-campaign-tracker-final",
+    });
+    const unavailable = await callJson<any>(
+      ownerClient,
+      "get-content-database",
+      { databaseId: target.databaseId, limit: 100, offset: 0 },
+    );
+    expect(unavailable).toMatchObject({
+      available: false,
+      databaseId: target.databaseId,
+    });
+  }, 90_000);
+});
diff --git a/templates/content/actions/database-setup.db.test.ts b/templates/content/actions/database-setup.db.test.ts
new file mode 100644
index 00000000000..1940f880084
--- /dev/null
+++ b/templates/content/actions/database-setup.db.test.ts
@@ -0,0 +1,304 @@
+import { rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  runFrameworkReleaseMigrations,
+  runWithRequestContext,
+} from "@agent-native/core/server";
+import { and, eq } from "drizzle-orm";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+// guard:allow-unscoped — isolated test database verifies receipt atomicity and permission fixtures.
+const path = join(
+  tmpdir(),
+  `content-setup-${process.pid}-${Date.now()}.pglite`,
+);
+const databaseUrl = process.env.CONTENT_SETUP_POSTGRES_URL ?? `pglite:${path}`;
+const runId = Date.now();
+const owner = `setup-owner-${runId}@example.com`;
+const outsider = `setup-outsider-${runId}@example.com`;
+let getDb: typeof import("../server/db/index.js").getDb;
+let schema: typeof import("../server/db/schema.js");
+let create: typeof import("./create-content-database.js").default;
+let read: typeof import("./get-content-database.js").default;
+let describeDatabase: typeof import("./describe-content-database.js").default;
+let trash: typeof import("./delete-content-database.js").default;
+let restore: typeof import("./restore-content-database.js").default;
+let listSpaces: typeof import("./list-content-spaces.js").default;
+let spaceId: string;
+const as = <T>(email: string, run: () => Promise<T>) =>
+  runWithRequestContext({ userEmail: email }, run);
+
+beforeAll(async () => {
+  if (
+    databaseUrl.startsWith("postgres") &&
+    !new URL(databaseUrl).pathname.includes("test")
+  )
+    throw new Error(
+      "CONTENT_SETUP_POSTGRES_URL must be an isolated test database",
+    );
+  process.env.DATABASE_URL = databaseUrl;
+  const db = await import("../server/db/index.js");
+  getDb = db.getDb;
+  schema = db.schema;
+  if (databaseUrl.startsWith("postgres"))
+    await runFrameworkReleaseMigrations(undefined);
+  await (await import("../server/plugins/db.js")).default(undefined as never);
+  create = (await import("./create-content-database.js")).default;
+  read = (await import("./get-content-database.js")).default;
+  describeDatabase = (await import("./describe-content-database.js")).default;
+  trash = (await import("./delete-content-database.js")).default;
+  restore = (await import("./restore-content-database.js")).default;
+  listSpaces = (await import("./list-content-spaces.js")).default;
+  await as(owner, () =>
+    import("./_content-spaces.js").then((m) =>
+      m.provisionContentSpaces(getDb(), owner),
+    ),
+  );
+  const spaces = await as(owner, () => listSpaces.run({}));
+  spaceId = spaces.spaces[0].id;
+}, 120_000);
+
+afterAll(() => {
+  if (!databaseUrl.startsWith("postgres"))
+    rmSync(path, { recursive: true, force: true });
+});
+
+describe("ordinary database setup", () => {
+  it("preserves the UI optimistic Page identity through the shared reliable create path", async () => {
+    const newDocumentId = `optimistic-${runId}`;
+    const args = {
+      spaceId,
+      title: "UI table",
+      newDocumentId,
+      parentId: null,
+      idempotencyKey: newDocumentId,
+    };
+    const created = await as(owner, () => create.run(args));
+    const replayed = await as(owner, () => create.run(args));
+    expect(created.database.documentId).toBe(newDocumentId);
+    expect(replayed.database.id).toBe(created.database.id);
+    expect(replayed.receipt?.idempotency.result).toBe("replayed");
+    expect(create.tool.parameters?.properties).not.toHaveProperty(
+      "newDocumentId",
+    );
+  });
+  it("DB01–DB02 creates once across concurrent retries with exact scope and discoverable default view", async () => {
+    const args = {
+      spaceId,
+      title: "Campaign tracker",
+      idempotencyKey: "same-create",
+    };
+    const results = await Promise.all([
+      as(owner, () => create.run(args)),
+      as(owner, () => create.run(args)),
+    ]);
+    expect(results[0].database.id).toBe(results[1].database.id);
+    expect(results.map((r) => r.receipt!.idempotency.result).sort()).toEqual([
+      "applied",
+      "replayed",
+    ]);
+    const description = await as(owner, () =>
+      describeDatabase.run({ databaseId: results[0].database.id }),
+    );
+    expect(description).toMatchObject({
+      database: { spaceId, title: "Campaign tracker" },
+      setupContract: { canEditSchema: true, sourceComposition: "unsupported" },
+    });
+    expect(
+      "mutationContract" in description &&
+        description.mutationContract?.target.databaseId,
+    ).toBe(results[0].database.id);
+    expect(
+      "configurationRevision" in description &&
+        description.configurationRevision,
+    ).toBe(results[0].receipt!.revisions.configurationAfter);
+    expect(
+      results[0].properties.filter((p) => p.definition.type === "blocks"),
+    ).toHaveLength(1);
+    await expect(
+      as(owner, () => create.run({ ...args, title: "Different intent" })),
+    ).rejects.toMatchObject({ errorCode: "IDEMPOTENCY_KEY_REUSED" });
+  });
+
+  it("DB07 refuses other principals and rolls back a mismatched parent/space without an orphan claim", async () => {
+    await expect(
+      as(outsider, () =>
+        create.run({ spaceId, title: "Denied", idempotencyKey: "denied" }),
+      ),
+    ).rejects.toThrow();
+    const parent = await as(owner, () =>
+      create.run({ spaceId, title: "Parent", idempotencyKey: "parent" }),
+    );
+    await as(outsider, () =>
+      import("./_content-spaces.js").then((m) =>
+        m.provisionContentSpaces(getDb(), outsider),
+      ),
+    );
+    const foreign = await as(outsider, () => listSpaces.run({}));
+    await expect(
+      as(owner, () =>
+        create.run({
+          spaceId: foreign.spaces[0].id,
+          parentId: parent.database.documentId,
+          title: "Wrong space",
+          idempotencyKey: "bad-parent",
+        }),
+      ),
+    ).rejects.toThrow();
+    const claims = await getDb()
+      .select()
+      .from(schema.contentDatabaseSetupReceipts)
+      .where(
+        eq(schema.contentDatabaseSetupReceipts.idempotencyKey, "bad-parent"),
+      );
+    expect(claims).toHaveLength(0);
+    await expect(
+      as(outsider, () =>
+        create.run({ spaceId, title: "Parent", idempotencyKey: "parent" }),
+      ),
+    ).rejects.toThrow();
+  });
+
+  it("DB06/DB12 guards Trash and restore revisions, preserves identities and replays without mutation", async () => {
+    const created = await as(owner, () =>
+      create.run({
+        spaceId,
+        title: "Recoverable",
+        idempotencyKey: "recoverable",
+      }),
+    );
+    const target = {
+      spaceId,
+      databaseId: created.database.id,
+      databaseDocumentId: created.database.documentId,
+    };
+    const input = {
+      target,
+      expectedConfigurationRevision:
+        created.receipt!.revisions.configurationAfter,
+      idempotencyKey: "trash-once",
+    };
+    await expect(
+      as(owner, () =>
+        trash.run({ ...input, expectedConfigurationRevision: "stale" }),
+      ),
+    ).rejects.toMatchObject({ errorCode: "CONFIGURATION_REVISION_CONFLICT" });
+    const deleted = await as(owner, () => trash.run(input));
+    expect(deleted.receipt?.outcome).toBe("trashed");
+    expect(
+      (await as(owner, () => trash.run(input))).receipt?.idempotency.result,
+    ).toBe("replayed");
+    await expect(
+      as(owner, () => describeDatabase.run({ databaseId: target.databaseId })),
+    ).rejects.toThrow();
+    const restored = await as(owner, () =>
+      restore.run({
+        target,
+        expectedConfigurationRevision:
+          deleted.receipt!.revisions.configurationAfter,
+        idempotencyKey: "restore-once",
+      }),
+    );
+    expect(restored.receipt?.outcome).toBe("restored");
+    const fresh = await as(owner, () =>
+      read.run({ databaseId: target.databaseId }),
+    );
+    expect(fresh).toMatchObject({
+      database: {
+        id: target.databaseId,
+        documentId: target.databaseDocumentId,
+        title: "Recoverable",
+      },
+    });
+    const receipts = await getDb()
+      .select()
+      .from(schema.contentDatabaseSetupReceipts)
+      .where(
+        and(
+          eq(schema.contentDatabaseSetupReceipts.databaseId, target.databaseId),
+          eq(schema.contentDatabaseSetupReceipts.actorEmail, owner),
+        ),
+      );
+    expect(receipts).toHaveLength(3);
+    await expect(as(outsider, () => trash.run(input))).rejects.toThrow();
+  });
+
+  it("DB11 refuses an unreadable or incomplete durable receipt instead of applying creation again", async () => {
+    const args = {
+      spaceId,
+      title: "Receipt integrity",
+      idempotencyKey: "receipt-integrity",
+    };
+    const created = await as(owner, () => create.run(args));
+    await getDb()
+      .update(schema.contentDatabaseSetupReceipts)
+      .set({ resultJson: "invalid-json" })
+      .where(
+        eq(schema.contentDatabaseSetupReceipts.id, created.receipt!.receiptId),
+      );
+    await expect(as(owner, () => create.run(args))).rejects.toMatchObject({
+      errorCode: "RECEIPT_MISMATCH",
+    });
+    await getDb()
+      .update(schema.contentDatabaseSetupReceipts)
+      .set({ resultJson: null })
+      .where(
+        eq(schema.contentDatabaseSetupReceipts.id, created.receipt!.receiptId),
+      );
+    await expect(as(owner, () => create.run(args))).rejects.toMatchObject({
+      errorCode: "RECEIPT_MISMATCH",
+    });
+    const databases = await getDb()
+      .select()
+      .from(schema.contentDatabases)
+      .where(
+        and(
+          eq(schema.contentDatabases.spaceId, spaceId),
+          eq(schema.contentDatabases.title, args.title),
+        ),
+      );
+    expect(databases).toHaveLength(1);
+  });
+
+  it("DB11 refuses readable lifecycle receipts with a corrupted target or intent key", async () => {
+    const created = await as(owner, () =>
+      create.run({
+        spaceId,
+        title: "Exact receipt",
+        idempotencyKey: "exact-receipt-create",
+      }),
+    );
+    const target = {
+      spaceId,
+      databaseId: created.database.id,
+      databaseDocumentId: created.database.documentId,
+    };
+    const args = {
+      target,
+      expectedConfigurationRevision:
+        created.receipt!.revisions.configurationAfter,
+      idempotencyKey: "exact-receipt-trash",
+    };
+    const result = await as(owner, () => trash.run(args));
+    const [claim] = await getDb()
+      .select()
+      .from(schema.contentDatabaseSetupReceipts)
+      .where(
+        eq(schema.contentDatabaseSetupReceipts.id, result.receipt!.receiptId),
+      );
+    for (const field of ["spaceId", "databaseDocumentId", "key"]) {
+      const corrupted = JSON.parse(claim.resultJson!);
+      if (field === "key") corrupted.receipt.idempotency.key = "wrong-key";
+      else corrupted.receipt.target[field] = "wrong-target";
+      await getDb()
+        .update(schema.contentDatabaseSetupReceipts)
+        .set({ resultJson: JSON.stringify(corrupted) })
+        .where(eq(schema.contentDatabaseSetupReceipts.id, claim.id));
+      await expect(as(owner, () => trash.run(args))).rejects.toMatchObject({
+        errorCode: "RECEIPT_MISMATCH",
+      });
+    }
+  });
+});
diff --git a/templates/content/actions/delete-content-database.ts b/templates/content/actions/delete-content-database.ts
index a9d644e3311..2afc7f37909 100644
--- a/templates/content/actions/delete-content-database.ts
+++ b/templates/content/actions/delete-content-database.ts
@@ -5,6 +5,13 @@ import { z } from "zod";
 
 import { getDb } from "../server/db/index.js";
 import { assertContentDatabaseLifecycleAccess } from "./_content-database-lifecycle.js";
+import {
+  runDatabaseSetupMutation,
+  setupLifecycleSchema,
+  setupError,
+  refreshAfterSetup,
+  setupAuditSummary,
+} from "./_database-setup-mutation.js";
 import {
   lockDatabasesForTrash,
   trashDocumentSubtree,
@@ -12,11 +19,86 @@ import {
 
 export default defineAction({
   description:
-    "Soft-delete a content database without deleting its documents or rows.",
-  schema: z.object({
-    databaseId: z.string().describe("Content database ID"),
-  }),
-  run: async ({ databaseId }) => {
+    "Move one exact ordinary database to recoverable Trash using its fresh configuration revision and an idempotency key; preserve records for restoration and return a receipt.",
+  mcpTool: true,
+  mcpApp: { structuredContent: true },
+  agentInputSchema: setupLifecycleSchema,
+  schema: z.union([
+    setupLifecycleSchema,
+    z
+      .object({
+        databaseId: z.string().describe("Content database ID"),
+      })
+      .strict(),
+  ]),
+  audit: {
+    recordInputs: false,
+    target: (args) => ({
+      type: "content-database",
+      id: args.target?.databaseId ?? args.databaseId,
+      visibility: "private",
+    }),
+    summary: (_args, result) =>
+      setupAuditSummary(result, "Moved Content database to recoverable Trash"),
+  },
+  run: async (args, context) => {
+    if (context?.caller === "mcp") setupLifecycleSchema.parse(args);
+    if ("target" in args) {
+      const input = setupLifecycleSchema.parse(args);
+      const { database } = await assertContentDatabaseLifecycleAccess(
+        input.target.databaseId,
+      );
+      let lockedIds: ReadonlySet<string> | undefined;
+      const result = await runDatabaseSetupMutation({
+        operation: "delete-content-database",
+        input,
+        payload: input,
+        role: "admin",
+        includeDeleted: true,
+        lock: async (tx) => {
+          lockedIds = await lockDatabasesForTrash(
+            tx,
+            database.documentId,
+            database.ownerEmail,
+          );
+        },
+        apply: async (tx, context) => {
+          if (context.database.ownerDocumentId)
+            setupError(
+              "UNSUPPORTED_DATABASE",
+              "Use the owning page to manage an inline database.",
+              400,
+            );
+          const deletedAt =
+            context.database.deletedAt ?? new Date().toISOString();
+          const ids = context.database.deletedAt
+            ? []
+            : await trashDocumentSubtree(
+                tx,
+                context.database.documentId,
+                context.database.ownerEmail,
+                deletedAt,
+                lockedIds,
+              );
+          return {
+            outcome: context.database.deletedAt
+              ? ("unchanged" as const)
+              : ("trashed" as const),
+            value: {
+              databaseId: context.database.id,
+              documentId: context.database.documentId,
+              deletedAt,
+              affectedDocumentIds: ids.slice(0, 100),
+              affectedDocumentCount: ids.length,
+              affectedDocumentIdsComplete: ids.length <= 100,
+            },
+          };
+        },
+      });
+      await refreshAfterSetup(result.receipt);
+      return { success: true, ...result.value, receipt: result.receipt };
+    }
+    const { databaseId } = args;
     const { database } = await assertContentDatabaseLifecycleAccess(databaseId);
     if (database.systemRole) {
       throw new Error("System Content databases cannot be deleted");
diff --git a/templates/content/actions/describe-content-database.ts b/templates/content/actions/describe-content-database.ts
index 6daee3ce629..3621f3dc95e 100644
--- a/templates/content/actions/describe-content-database.ts
+++ b/templates/content/actions/describe-content-database.ts
@@ -9,6 +9,9 @@ import type {
   ContentDatabaseDescriptionResponse,
   ContentDatabaseUnavailableResponse,
 } from "../shared/api.js";
+import { getDatabaseMutationContract } from "./_database-row-mutation.js";
+import { getDatabaseSetupContract } from "./_database-setup-discovery.js";
+import { configurationRevision } from "./_database-setup-mutation.js";
 import { resolveContentDatabaseRead } from "./_database-utils.js";
 import {
   listPropertiesForDatabase,
@@ -81,7 +84,22 @@ export default defineAction({
       listPropertiesForDatabase(resolved.database.id),
       getDocumentContextPath(databaseDocument),
     ]);
+    const mutationContract = selected.spaceId
+      ? await getDatabaseMutationContract({
+          spaceId: selected.spaceId,
+          databaseId: selected.databaseId,
+          databaseDocumentId: selected.documentId,
+          authorityScope: resolved.database.orgId
+            ? { kind: "organization", id: resolved.database.orgId }
+            : { kind: "personal", id: resolved.database.ownerEmail },
+        })
+      : undefined;
     return {
+      configurationRevision: configurationRevision(resolved.database),
+      mutationContract,
+      setupContract: mutationContract
+        ? await getDatabaseSetupContract(resolved.database, mutationContract)
+        : undefined,
       database: serializeDatabase(
         { ...resolved.database, title: selected.title },
         selected.description,
diff --git a/templates/content/actions/get-content-database-source.ts b/templates/content/actions/get-content-database-source.ts
index 387bd2efeee..b9da9348ef0 100644
--- a/templates/content/actions/get-content-database-source.ts
+++ b/templates/content/actions/get-content-database-source.ts
@@ -1,4 +1,4 @@
-import { defineAction } from "@agent-native/core/action";
+import { ActionContractError, defineAction } from "@agent-native/core/action";
 import { resolveAccess } from "@agent-native/core/sharing";
 import { z } from "zod";
 
@@ -7,25 +7,104 @@ import {
   getContentDatabaseSourceSnapshot,
   resolveDatabaseForSourceMutation,
 } from "./_database-source-utils.js";
-import { serializeDatabase } from "./_property-utils.js";
+import { getDatabaseById, serializeDatabase } from "./_property-utils.js";
+
+const sourceStatusAgentSchema = z
+  .object({
+    statusOnly: z
+      .literal(true)
+      .default(true)
+      .describe(
+        "Return source status and mappings without row payloads or change-set details",
+      ),
+    databaseId: z
+      .string()
+      .min(1)
+      .optional()
+      .describe("Exact database ID from discovery"),
+    documentId: z
+      .string()
+      .min(1)
+      .optional()
+      .describe("Exact backing Page ID from discovery"),
+  })
+  .strict()
+  .refine(
+    (args) => Boolean(args.databaseId) !== Boolean(args.documentId),
+    "Provide exactly one databaseId or documentId",
+  );
 
 export default defineAction({
   description:
     "Get source-binding status for a content database, including local/no-source status, source metadata, field mappings, row identity, freshness, capabilities, and change sets.",
-  schema: z.object({
-    databaseId: z.string().optional().describe("Database ID"),
-    documentId: z.string().optional().describe("Database document/page ID"),
-  }),
+  mcpTool: true,
+  agentInputSchema: sourceStatusAgentSchema,
+  schema: z
+    .object({
+      statusOnly: z.boolean().optional(),
+      databaseId: z.string().optional().describe("Database ID"),
+      documentId: z.string().optional().describe("Database document/page ID"),
+    })
+    .strict(),
   http: { method: "GET" },
   readOnly: true,
-  run: async (args): Promise<ContentDatabaseSourceStatusResponse> => {
+  run: async (args, context): Promise<ContentDatabaseSourceStatusResponse> => {
+    if (context?.caller === "mcp") sourceStatusAgentSchema.parse(args);
     const database = await resolveDatabaseForSourceMutation(args);
-    if (!database) throw new Error("Database not found.");
+    if (!database)
+      throw new ActionContractError("Database not found.", {
+        errorCode: "DATABASE_NOT_FOUND",
+        statusCode: 404,
+      });
 
     const access = await resolveAccess("document", database.documentId);
-    if (!access) throw new Error(`Database "${database.id}" not found`);
+    if (!access)
+      throw new ActionContractError("Database not found.", {
+        errorCode: "DATABASE_NOT_FOUND",
+        statusCode: 404,
+      });
+    if (args.documentId && database.documentId !== args.documentId)
+      throw new ActionContractError("Database and backing Page do not match.", {
+        errorCode: "TARGET_MISMATCH",
+        statusCode: 409,
+      });
 
-    const source = await getContentDatabaseSourceSnapshot(database);
+    const snapshot = await getContentDatabaseSourceSnapshot(database);
+    if (snapshot?.sourceType === "local-table") {
+      const sourceDatabase = await getDatabaseById(snapshot.sourceTable);
+      if (
+        !sourceDatabase ||
+        !(await resolveAccess("document", sourceDatabase.documentId))
+      ) {
+        throw new ActionContractError(
+          "The linked source is unavailable or inaccessible. This database is still source-backed.",
+          { errorCode: "SOURCE_UNAVAILABLE", statusCode: 403 },
+        );
+      }
+    }
+    const source =
+      snapshot && (args.statusOnly || context?.caller === "mcp")
+        ? {
+            ...snapshot,
+            lastError: snapshot.lastError
+              ? "Source reports an error; inspect its settings in Content."
+              : null,
+            metadata: {
+              primaryKey: snapshot.metadata.primaryKey,
+              titleField: snapshot.metadata.titleField,
+              naturalKeyField: snapshot.metadata.naturalKeyField,
+              writeMode: snapshot.metadata.writeMode,
+              truthPolicy: snapshot.metadata.truthPolicy,
+              syncPolicy: snapshot.metadata.syncPolicy,
+            },
+            rows: [],
+            changeSets: [],
+            projection: {
+              rows: "omitted" as const,
+              changeSets: "omitted" as const,
+            },
+          }
+        : snapshot;
     return {
       database: serializeDatabase(database),
       mode: source ? "source-backed" : "local",
diff --git a/templates/content/actions/list-content-databases.db.test.ts b/templates/content/actions/list-content-databases.db.test.ts
index 2c38303be3e..318add1dc0f 100644
--- a/templates/content/actions/list-content-databases.db.test.ts
+++ b/templates/content/actions/list-content-databases.db.test.ts
@@ -646,13 +646,13 @@ describe("list-content-databases", () => {
             spaceId,
             databaseId: feedbackDatabaseId,
           }),
-        ).rejects.toThrow(/Not authorized for Content space/);
+        ).rejects.toThrow(/Content space not found/);
         await expect(
           listContentDatabasesAction.run({
             spaceId,
             includeSystemCollections: true,
           }),
-        ).rejects.toThrow(/Not authorized for Content space/);
+        ).rejects.toThrow(/Content space not found/);
       },
     );
   });
diff --git a/templates/content/actions/list-content-spaces.ts b/templates/content/actions/list-content-spaces.ts
index 5bb1ca080bd..d46a273e354 100644
--- a/templates/content/actions/list-content-spaces.ts
+++ b/templates/content/actions/list-content-spaces.ts
@@ -18,6 +18,7 @@ import {
 export default defineAction({
   description:
     "List Content spaces that are already provisioned and currently authorized for the signed-in user.",
+  mcpTool: true,
   schema: z.object({}),
   http: { method: "GET" },
   readOnly: true,
@@ -91,6 +92,7 @@ export default defineAction({
       filesDocumentId: string;
       orgId: string | null;
       role: string;
+      canCreateDatabase: boolean;
       catalogItemId: string;
       catalogDocumentId: string;
       catalogPosition: number;
@@ -119,6 +121,13 @@ export default defineAction({
         filesDocumentId,
         orgId: row.space.orgId,
         role,
+        canCreateDatabase:
+          !row.space.orgId ||
+          memberships.some(
+            (membership) =>
+              membership.orgId === row.space.orgId &&
+              ["owner", "admin", "member"].includes(membership.role),
+          ),
         catalogItemId: row.mapping.databaseItemId,
         catalogDocumentId: row.mapping.documentId,
         catalogPosition: row.item.position,
diff --git a/templates/content/actions/list-trashed-content-databases.ts b/templates/content/actions/list-trashed-content-databases.ts
index bff2a44ed5c..b23292504ba 100644
--- a/templates/content/actions/list-trashed-content-databases.ts
+++ b/templates/content/actions/list-trashed-content-databases.ts
@@ -6,15 +6,21 @@ import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import type { ListTrashedContentDatabasesResponse } from "../shared/api.js";
+import { configurationRevision } from "./_database-setup-mutation.js";
 
 export default defineAction({
   description:
     "List soft-deleted content databases the current user can access for the sidebar Trash surface.",
-  schema: z.object({}),
+  mcpTool: true,
+  schema: z.object({
+    limit: z.number().int().min(1).max(100).optional(),
+    offset: z.number().int().min(0).optional(),
+  }),
   http: { method: "GET" },
   readOnly: true,
-  run: async (): Promise<ListTrashedContentDatabasesResponse> => {
+  run: async (args, context): Promise<ListTrashedContentDatabasesResponse> => {
     const db = getDb();
+    const limit = args.limit ?? (context?.caller === "mcp" ? 100 : undefined);
     const hostDocuments = alias(schema.documents, "host_documents");
     const isBlockOwned = and(
       isNotNull(schema.contentDatabases.ownerDocumentId),
@@ -25,8 +31,9 @@ export default defineAction({
       isNull(schema.documents.parentId),
       ne(schema.documents.parentId, schema.contentDatabases.ownerDocumentId),
     );
-    const rows = await db
+    const query = db
       .select({
+        databaseRecord: schema.contentDatabases,
         databaseId: schema.contentDatabases.id,
         databaseTitle: schema.contentDatabases.title,
         documentId: schema.contentDatabases.documentId,
@@ -74,10 +81,22 @@ export default defineAction({
           ),
         ),
       )
-      .orderBy(desc(schema.contentDatabases.deletedAt));
+      .orderBy(
+        desc(schema.contentDatabases.deletedAt),
+        schema.contentDatabases.id,
+      );
+    const rows =
+      limit === undefined
+        ? await query
+        : await query.limit(limit + 1).offset(args.offset ?? 0);
+    const hasMore = limit !== undefined && rows.length > limit;
 
     return {
-      databases: rows.map((row) => ({
+      hasMore,
+      nextOffset: hasMore ? (args.offset ?? 0) + limit : null,
+      databases: rows.slice(0, limit ?? rows.length).map((row) => ({
+        spaceId: row.databaseRecord.spaceId,
+        configurationRevision: configurationRevision(row.databaseRecord),
         databaseId: row.databaseId,
         title:
           row.documentTitle?.trim() ||
diff --git a/templates/content/actions/mcp-action-contract.spec.ts b/templates/content/actions/mcp-action-contract.spec.ts
index ea5ed431354..b7edd217566 100644
--- a/templates/content/actions/mcp-action-contract.spec.ts
+++ b/templates/content/actions/mcp-action-contract.spec.ts
@@ -4,23 +4,30 @@ import { mcpToolInputSchema } from "../../../packages/core/src/mcp/tool-input-sc
 import addComment from "./add-comment.js";
 import addContentDatabaseSourceFieldProperty from "./add-content-database-source-field-property.js";
 import addDatabaseItem from "./add-database-item.js";
+import configureDocumentProperty from "./configure-document-property.js";
 import connectNotionStatus from "./connect-notion-status.js";
+import createContentDatabase from "./create-content-database.js";
 import createDocument from "./create-document.js";
 import deleteContentDatabase from "./delete-content-database.js";
 import describeContentDatabase from "./describe-content-database.js";
 import editDocument from "./edit-document.js";
+import getContentDatabaseSource from "./get-content-database-source.js";
 import getContentDatabase from "./get-content-database.js";
 import { resolveContentDatabaseReadLimit } from "./get-content-database.js";
 import getDocument from "./get-document.js";
 import listComments from "./list-comments.js";
 import listContentDatabases from "./list-content-databases.js";
+import listContentSpaces from "./list-content-spaces.js";
 import listDocuments from "./list-documents.js";
+import listTrashedContentDatabases from "./list-trashed-content-databases.js";
 import manageContentDatabaseMigration from "./manage-content-database-migration.js";
 import migrateContentDatabaseRows from "./migrate-content-database-rows.js";
 import navigate from "./navigate.js";
 import refreshList from "./refresh-list.js";
+import restoreContentDatabase from "./restore-content-database.js";
 import searchDocuments from "./search-documents.js";
 import updateComment from "./update-comment.js";
+import updateContentDatabaseView from "./update-content-database-view.js";
 import updateDatabaseItem from "./update-database-item.js";
 import updateDatabaseItems from "./update-database-items.js";
 import updateDocument from "./update-document.js";
@@ -29,6 +36,14 @@ import viewScreen from "./view-screen.js";
 
 describe("Content action-owned agent catalogs", () => {
   const directMcpActions = {
+    "create-content-database": createContentDatabase,
+    "configure-document-property": configureDocumentProperty,
+    "update-content-database-view": updateContentDatabaseView,
+    "list-content-spaces": listContentSpaces,
+    "get-content-database-source": getContentDatabaseSource,
+    "delete-content-database": deleteContentDatabase,
+    "restore-content-database": restoreContentDatabase,
+    "list-trashed-content-databases": listTrashedContentDatabases,
     "list-documents": listDocuments,
     "search-documents": searchDocuments,
     "get-document": getDocument,
@@ -50,7 +65,6 @@ describe("Content action-owned agent catalogs", () => {
   const deferredDatabaseActions = {
     "add-content-database-source-field-property":
       addContentDatabaseSourceFieldProperty,
-    "delete-content-database": deleteContentDatabase,
     "manage-content-database-migration": manageContentDatabaseMigration,
   };
 
@@ -163,7 +177,7 @@ describe("Content action-owned agent catalogs", () => {
     expect(updateDatabaseItems.schema.safeParse([]).success).toBe(false);
   });
 
-  it("keeps schema, destructive, and migration actions out of compact MCP discovery", () => {
+  it("keeps source composition and destructive migration actions out of compact MCP discovery", () => {
     for (const action of Object.values(deferredDatabaseActions)) {
       expect(action.mcpTool).not.toBe(true);
     }
diff --git a/templates/content/actions/restore-content-database.ts b/templates/content/actions/restore-content-database.ts
index 75331730fbc..a2e548b843a 100644
--- a/templates/content/actions/restore-content-database.ts
+++ b/templates/content/actions/restore-content-database.ts
@@ -9,6 +9,14 @@ import {
   assertContentDatabaseLifecycleAccess,
   collectInlineDatabaseOwnerBlockIds,
 } from "./_content-database-lifecycle.js";
+import {
+  runDatabaseSetupMutation,
+  setupLifecycleSchema,
+  setupError,
+  refreshAfterSetup,
+  setupAuditSummary,
+} from "./_database-setup-mutation.js";
+import { lockDatabasesForTrash } from "./delete-document.js";
 import { restoreDocumentSubtree } from "./delete-document.js";
 import pullDocumentAction from "./pull-document.js";
 
@@ -35,11 +43,84 @@ async function shouldClearStaleInlineOwnership(args: {
 }
 
 export default defineAction({
-  description: "Restore a soft-deleted content database.",
-  schema: z.object({
-    databaseId: z.string().describe("Content database ID"),
-  }),
-  run: async ({ databaseId }) => {
+  description:
+    "Restore one exact ordinary database from recoverable Trash using its configuration revision and idempotency key; preserve Page, property and view identities and return a receipt.",
+  mcpTool: true,
+  mcpApp: { structuredContent: true },
+  agentInputSchema: setupLifecycleSchema,
+  schema: z.union([
+    setupLifecycleSchema,
+    z
+      .object({
+        databaseId: z.string().describe("Content database ID"),
+      })
+      .strict(),
+  ]),
+  audit: {
+    recordInputs: false,
+    target: (args) => ({
+      type: "content-database",
+      id: args.target?.databaseId ?? args.databaseId,
+      visibility: "private",
+    }),
+    summary: (_args, result) =>
+      setupAuditSummary(result, "Restored Content database from Trash"),
+  },
+  run: async (args, context) => {
+    if (context?.caller === "mcp") setupLifecycleSchema.parse(args);
+    if ("target" in args) {
+      const input = setupLifecycleSchema.parse(args);
+      const { database } = await assertContentDatabaseLifecycleAccess(
+        input.target.databaseId,
+      );
+      const result = await runDatabaseSetupMutation({
+        operation: "restore-content-database",
+        input,
+        payload: input,
+        role: "admin",
+        includeDeleted: true,
+        lock: (tx) =>
+          lockDatabasesForTrash(tx, database.documentId, database.ownerEmail),
+        apply: async (tx, context) => {
+          if (context.database.ownerDocumentId)
+            setupError(
+              "UNSUPPORTED_DATABASE",
+              "Use the owning page to restore an inline database.",
+              400,
+            );
+          if (
+            context.databaseDocument.trashedAt &&
+            context.databaseDocument.trashRootId !== context.database.documentId
+          )
+            setupError(
+              "PARENT_IN_TRASH",
+              "Restore the parent Trash item instead.",
+              400,
+            );
+          const ids = await restoreDocumentSubtree(
+            tx,
+            context.database.documentId,
+            context.database.ownerEmail,
+          );
+          return {
+            outcome: context.database.deletedAt
+              ? ("restored" as const)
+              : ("unchanged" as const),
+            value: {
+              databaseId: context.database.id,
+              documentId: context.database.documentId,
+              deletedAt: null,
+              affectedDocumentIds: ids.slice(0, 100),
+              affectedDocumentCount: ids.length,
+              affectedDocumentIdsComplete: ids.length <= 100,
+            },
+          };
+        },
+      });
+      await refreshAfterSetup(result.receipt);
+      return { success: true, ...result.value, receipt: result.receipt };
+    }
+    const { databaseId } = args;
     const ownership = await assertContentDatabaseLifecycleAccess(databaseId);
     const db = getDb();
     const now = new Date().toISOString();
diff --git a/templates/content/actions/set-document-property.ts b/templates/content/actions/set-document-property.ts
index d358c061c1d..a2456ce9179 100644
--- a/templates/content/actions/set-document-property.ts
+++ b/templates/content/actions/set-document-property.ts
@@ -1,3 +1,4 @@
+import { ActionContractError } from "@agent-native/core";
 import { defineAction } from "@agent-native/core/action";
 import { assertAccess } from "@agent-native/core/sharing";
 import { and, eq, isNull, ne } from "drizzle-orm";
@@ -13,6 +14,7 @@ import {
   parsePropertyOptions,
   type DocumentPropertyType,
 } from "../shared/properties.js";
+import { contentDatabaseSourceFieldsAllowLocalWrite } from "../shared/source-field-policy.js";
 import {
   lockPrimaryBlocksFields,
   persistBlocksFieldIdentity,
@@ -27,6 +29,41 @@ import {
   normalizedValueJson,
 } from "./_property-utils.js";
 
+async function assertPropertyWritableByRowMutation(
+  db: ReturnType<typeof getDb>,
+  databaseId: string,
+  definition: typeof schema.documentPropertyDefinitions.$inferSelect,
+) {
+  const sourceFields = await db
+    .select({
+      writeOwner: schema.contentDatabaseSourceFields.writeOwner,
+      readOnly: schema.contentDatabaseSourceFields.readOnly,
+    })
+    .from(schema.contentDatabaseSourceFields)
+    .innerJoin(
+      schema.contentDatabaseSources,
+      eq(
+        schema.contentDatabaseSources.id,
+        schema.contentDatabaseSourceFields.sourceId,
+      ),
+    )
+    .where(
+      and(
+        eq(schema.contentDatabaseSources.databaseId, databaseId),
+        eq(schema.contentDatabaseSourceFields.propertyId, definition.id),
+      ),
+    );
+  if (contentDatabaseSourceFieldsAllowLocalWrite(sourceFields)) return;
+  throw new ActionContractError(
+    `Property "${definition.name}" is not writable by database row mutations.`,
+    {
+      errorCode: "PROPERTY_NOT_WRITABLE",
+      details: { propertyId: definition.id, propertyType: definition.type },
+      statusCode: 400,
+    },
+  );
+}
+
 export default defineAction({
   description: "Set a Notion-style property value on a document.",
   publicAgent: {
@@ -106,6 +143,10 @@ export default defineAction({
         parsePropertyOptions(definition.optionsJson),
       );
       await db.transaction(async (tx) => {
+        await lockContentDatabaseMutation(
+          tx as unknown as ReturnType<typeof getDb>,
+          database.id,
+        );
         const primaryBlocksFields = await lockPrimaryBlocksFields(
           tx as unknown as ReturnType<typeof getDb>,
           documentId,
@@ -137,6 +178,11 @@ export default defineAction({
             "Property type changed before the operation completed.",
           );
         }
+        await assertPropertyWritableByRowMutation(
+          tx as unknown as ReturnType<typeof getDb>,
+          database.id,
+          lockedDefinition,
+        );
         target = blocksStorageTarget(
           parsePropertyOptions(lockedDefinition.optionsJson),
         );
@@ -289,6 +335,11 @@ export default defineAction({
       if (isComputedPropertyType(lockedType)) {
         throw new Error("Computed properties cannot be edited.");
       }
+      await assertPropertyWritableByRowMutation(
+        tx as unknown as ReturnType<typeof getDb>,
+        database.id,
+        lockedDefinition,
+      );
       const isNaturalKey = lockedDatabase.naturalKeyPropertyId === propertyId;
       if (isNaturalKey) {
         let parsed: unknown;
@@ -298,8 +349,9 @@ export default defineAction({
           parsed = null;
         }
         if (typeof parsed !== "string" || !parsed.trim()) {
-          throw new Error(
+          throw new ActionContractError(
             "A database natural key must remain a non-empty string.",
+            { errorCode: "INVALID_NATURAL_KEY", statusCode: 400 },
           );
         }
         const [existingNaturalKeyClaim] = await tx
@@ -319,8 +371,9 @@ export default defineAction({
           existingNaturalKeyClaim &&
           existingNaturalKeyClaim.keyValueJson !== valueJson
         ) {
-          throw new Error(
+          throw new ActionContractError(
             "A claimed database natural key cannot be changed. Create a new row instead.",
+            { errorCode: "NATURAL_KEY_IMMUTABLE", statusCode: 409 },
           );
         }
       }
diff --git a/templates/content/actions/update-content-database-view.ts b/templates/content/actions/update-content-database-view.ts
index a55fb5b98ef..59fa903fa37 100644
--- a/templates/content/actions/update-content-database-view.ts
+++ b/templates/content/actions/update-content-database-view.ts
@@ -1,5 +1,6 @@
 import { defineAction } from "@agent-native/core/action";
 import { writeAppState } from "@agent-native/core/application-state";
+import { buildDeepLink } from "@agent-native/core/server";
 import { assertAccess } from "@agent-native/core/sharing";
 import { and, eq, isNull } from "drizzle-orm";
 import { z } from "zod";
@@ -7,39 +8,53 @@ import { z } from "zod";
 import { getDb, schema } from "../server/db/index.js";
 import { withSavedTableColumnPresentation } from "../shared/database-table-columns.js";
 import { lockContentDatabaseMutation } from "./_content-database-mutation-lock.js";
+import {
+  refreshAfterSetup,
+  setupAuditSummary,
+  setupGuardSchema,
+} from "./_database-setup-mutation.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
+import {
+  runReplaceContentDatabaseViews,
+  runUpdateContentDatabaseView,
+  updateContentDatabaseViewAgentSchema,
+} from "./_database-view-setup.js";
 import {
   parseDatabaseViewConfig,
   serializeDatabaseViewConfig,
 } from "./_property-utils.js";
 
-const sortSchema = z.object({
-  key: z.string(),
-  label: z.string(),
-  direction: z.enum(["asc", "desc"]),
-});
+const sortSchema = z
+  .object({
+    key: z.string(),
+    label: z.string(),
+    direction: z.enum(["asc", "desc"]),
+  })
+  .strict();
 
-const filterSchema = z.object({
-  key: z.string(),
-  label: z.string(),
-  operator: z.enum([
-    "contains",
-    "equals",
-    "does_not_equal",
-    "greater_than",
-    "less_than",
-    "before",
-    "after",
-    "between",
-    "is_checked",
-    "is_unchecked",
-    "is_empty",
-    "is_not_empty",
-  ]),
-  value: z.string(),
-  filterGroupId: z.string().optional(),
-  parentFilterGroupId: z.string().optional(),
-});
+const filterSchema = z
+  .object({
+    key: z.string(),
+    label: z.string(),
+    operator: z.enum([
+      "contains",
+      "equals",
+      "does_not_equal",
+      "greater_than",
+      "less_than",
+      "before",
+      "after",
+      "between",
+      "is_checked",
+      "is_unchecked",
+      "is_empty",
+      "is_not_empty",
+    ]),
+    value: z.string(),
+    filterGroupId: z.string().optional(),
+    parentFilterGroupId: z.string().optional(),
+  })
+  .strict();
 
 const columnCalculationSchema = z.enum([
   "count_all",
@@ -61,53 +76,57 @@ const columnCalculationSchema = z.enum([
   "date_range",
 ]);
 
-const formQuestionSchema = z.object({
-  key: z.string().min(1),
-  enabled: z.boolean().default(true),
-  required: z.boolean().default(false),
-});
+const formQuestionSchema = z
+  .object({
+    key: z.string().min(1),
+    enabled: z.boolean().default(true),
+    required: z.boolean().default(false),
+  })
+  .strict();
 
-const viewSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  type: z
-    .enum([
-      "table",
-      "board",
-      "list",
-      "gallery",
-      "calendar",
-      "timeline",
-      "form",
-      "sidebar",
-    ])
-    .transform((type) => (type === "sidebar" ? "table" : type))
-    .default("table"),
-  sorts: z.array(sortSchema).default([]),
-  filters: z.array(filterSchema).default([]),
-  filterMode: z.enum(["and", "or"]).default("and"),
-  columnWidths: z.record(z.string(), z.number()).default({}),
-  groupByPropertyId: z.string().nullable().optional(),
-  datePropertyId: z.string().nullable().optional(),
-  endDatePropertyId: z.string().nullable().optional(),
-  hiddenPropertyIds: z.array(z.string()).default([]),
-  propertyOrderIds: z.array(z.string()).default([]),
-  tableColumnOrderIds: z.array(z.string()).optional(),
-  collapsedGroupIds: z.array(z.string()).default([]),
-  hideEmptyGroups: z.boolean().default(false),
-  calculations: z.record(z.string(), columnCalculationSchema).default({}),
-  wrapCells: z.boolean().default(false),
-  columnWrapOverrides: z.record(z.string().min(1), z.boolean()).optional(),
-  frozenThroughColumnId: z.string().min(1).nullable().optional(),
-  rowDensity: z.enum(["compact", "default", "comfortable"]).default("default"),
-  openPagesIn: z.enum(["preview", "full_page"]).default("preview"),
-  formQuestions: z.array(formQuestionSchema).default([]),
-});
+const viewSchema = z
+  .object({
+    id: z.string(),
+    name: z.string(),
+    type: z
+      .enum([
+        "table",
+        "board",
+        "list",
+        "gallery",
+        "calendar",
+        "timeline",
+        "form",
+        "sidebar",
+      ])
+      .transform((type) => (type === "sidebar" ? "table" : type))
+      .default("table"),
+    sorts: z.array(sortSchema).default([]),
+    filters: z.array(filterSchema).default([]),
+    filterMode: z.enum(["and", "or"]).default("and"),
+    columnWidths: z.record(z.string(), z.number()).default({}),
+    groupByPropertyId: z.string().nullable().optional(),
+    datePropertyId: z.string().nullable().optional(),
+    endDatePropertyId: z.string().nullable().optional(),
+    hiddenPropertyIds: z.array(z.string()).default([]),
+    propertyOrderIds: z.array(z.string()).default([]),
+    tableColumnOrderIds: z.array(z.string()).optional(),
+    collapsedGroupIds: z.array(z.string()).default([]),
+    hideEmptyGroups: z.boolean().default(false),
+    calculations: z.record(z.string(), columnCalculationSchema).default({}),
+    wrapCells: z.boolean().default(false),
+    columnWrapOverrides: z.record(z.string().min(1), z.boolean()).optional(),
+    frozenThroughColumnId: z.string().min(1).nullable().optional(),
+    rowDensity: z
+      .enum(["compact", "default", "comfortable"])
+      .default("default"),
+    openPagesIn: z.enum(["preview", "full_page"]).default("preview"),
+    formQuestions: z.array(formQuestionSchema).default([]),
+  })
+  .strict();
 
-export default defineAction({
-  description:
-    "Update saved database views, sorts, filters, property order, hidden properties, and view-specific settings for a content database.",
-  schema: z.object({
+const legacyUpdateContentDatabaseViewSchema = z
+  .object({
     databaseId: z.string().describe("Database ID"),
     viewConfig: z
       .object({
@@ -117,9 +136,53 @@ export default defineAction({
         filters: z.array(filterSchema).default([]),
         columnWidths: z.record(z.string(), z.number()).default({}),
       })
+      .strict()
       .describe("Saved database table view settings"),
-  }),
-  run: async ({ databaseId, viewConfig }) => {
+  })
+  .strict();
+
+const guardedViewReplacementSchema = setupGuardSchema
+  .extend({
+    operation: z.literal("replace"),
+    expectedConfigurationRevision: z.string().min(1),
+    viewConfig: legacyUpdateContentDatabaseViewSchema.shape.viewConfig,
+  })
+  .strict();
+
+export default defineAction({
+  description:
+    "Create one named ordinary table view or sparsely update one exact saved table view using stable property IDs, fresh schema and configuration revisions, and an idempotency key.",
+  mcpTool: true,
+  mcpApp: { structuredContent: true },
+  agentInputSchema: updateContentDatabaseViewAgentSchema,
+  schema: z.union([
+    updateContentDatabaseViewAgentSchema,
+    guardedViewReplacementSchema,
+    legacyUpdateContentDatabaseViewSchema,
+  ]),
+  audit: {
+    recordInputs: false,
+    target: (args) => ({
+      type: "content-database",
+      id: "operation" in args ? args.target.databaseId : args.databaseId,
+      visibility: "private",
+    }),
+    summary: (_args, result) =>
+      setupAuditSummary(result, "Updated Content database views"),
+  },
+  run: async (args, context) => {
+    if (context?.caller === "mcp") {
+      updateContentDatabaseViewAgentSchema.parse(args);
+    }
+    if ("operation" in args) {
+      const result =
+        args.operation === "replace"
+          ? await runReplaceContentDatabaseViews(args)
+          : await runUpdateContentDatabaseView(args);
+      await refreshAfterSetup(result.receipt);
+      return result;
+    }
+    const { databaseId, viewConfig } = args;
     const db = getDb();
     const [database] = await db
       .select({ documentId: schema.contentDatabases.documentId })
@@ -174,4 +237,26 @@ export default defineAction({
 
     return getContentDatabaseResponse(databaseId, { limit: 100, offset: 0 });
   },
+  link: ({ result }) => {
+    const receipt = (
+      result as {
+        receipt?: {
+          viewId?: string;
+          target?: { databaseDocumentId?: string };
+        };
+      } | null
+    )?.receipt;
+    const documentId = receipt?.target?.databaseDocumentId;
+    if (!documentId || !receipt?.viewId) return null;
+    return {
+      url: buildDeepLink({
+        app: "content",
+        view: "editor",
+        to: `/page/${encodeURIComponent(documentId)}?viewId=${encodeURIComponent(receipt.viewId)}`,
+        params: { documentId, viewId: receipt.viewId },
+      }),
+      label: "Open in Content",
+      view: "editor",
+    };
+  },
 });
diff --git a/templates/content/actions/update-database-item.ts b/templates/content/actions/update-database-item.ts
index 5cbe9c777ec..e525a14f3f4 100644
--- a/templates/content/actions/update-database-item.ts
+++ b/templates/content/actions/update-database-item.ts
@@ -38,13 +38,15 @@ const schema = databaseMutationEnvelopeSchema.extend({
   ),
 });
 const agentSchema = schema
-  .extend({ target: databaseMutationAgentTargetSchema })
-  .omit({ propertyValues: true });
+  .extend({ target: databaseMutationAgentTargetSchema.strict() })
+  .omit({ propertyValues: true })
+  .strict();
 
 export default defineAction({
   description:
     "Sparsely update one exact Content database row using identifiers and revisions copied from a fresh get-content-database read: item.id is the membership itemId, document.id is the distinct page documentId, and rowRevision is expectedRowRevision. Requires the fresh schema revision, preserves omitted properties, validates every provided non-Blocks property, and returns a verified idempotent receipt.",
   mcpTool: true,
+  mcpApp: { structuredContent: true },
   agentInputSchema: agentSchema,
   schema,
   http: { method: "PUT" },
@@ -63,16 +65,23 @@ export default defineAction({
         : "Updated Content database row";
     },
   },
-  run: (args) => updateDatabaseRow(canonicalizeDatabasePropertyInput(args)),
+  run: (args, context) => {
+    if (context?.caller === "mcp") agentSchema.parse(args);
+    return updateDatabaseRow(canonicalizeDatabasePropertyInput(args));
+  },
   link: ({ result }) => {
-    const documentId = (result as ContentDatabaseRowMutationResult | null)
-      ?.receipt.row.documentId;
-    if (!documentId) return null;
+    const receipt = (result as ContentDatabaseRowMutationResult | null)
+      ?.receipt;
+    if (!receipt) return null;
     return {
       url: buildDeepLink({
         app: "content",
         view: "editor",
-        params: { documentId },
+        params: {
+          documentId: receipt.row.documentId,
+          databaseId: receipt.target.databaseId,
+          databaseDocumentId: receipt.target.databaseDocumentId,
+        },
       }),
       label: "Open database row",
       view: "editor",
diff --git a/templates/content/actions/upsert-database-item-by-key.ts b/templates/content/actions/upsert-database-item-by-key.ts
index 559c8540c28..81f18282990 100644
--- a/templates/content/actions/upsert-database-item-by-key.ts
+++ b/templates/content/actions/upsert-database-item-by-key.ts
@@ -30,13 +30,15 @@ const schema = databaseMutationEnvelopeSchema.extend({
   ),
 });
 const agentSchema = schema
-  .extend({ target: databaseMutationAgentTargetSchema })
-  .omit({ propertyValues: true });
+  .extend({ target: databaseMutationAgentTargetSchema.strict() })
+  .omit({ propertyValues: true })
+  .strict();
 
 export default defineAction({
   description:
     "Create or sparsely update one Content database row by its configured natural key using the mutation target and schema revision from a fresh get-content-database read. Use expectedRowRevision null only to assert the key is absent and create; copy the matching item's fresh rowRevision to update. Preserves omitted properties and returns a verified idempotent receipt.",
   mcpTool: true,
+  mcpApp: { structuredContent: true },
   agentInputSchema: agentSchema,
   schema,
   audit: {
@@ -54,16 +56,23 @@ export default defineAction({
         : "Upserted Content database row by natural key";
     },
   },
-  run: (args) => upsertDatabaseRow(canonicalizeDatabasePropertyInput(args)),
+  run: (args, context) => {
+    if (context?.caller === "mcp") agentSchema.parse(args);
+    return upsertDatabaseRow(canonicalizeDatabasePropertyInput(args));
+  },
   link: ({ result }) => {
-    const documentId = (result as ContentDatabaseRowMutationResult | null)
-      ?.receipt.row.documentId;
-    if (!documentId) return null;
+    const receipt = (result as ContentDatabaseRowMutationResult | null)
+      ?.receipt;
+    if (!receipt) return null;
     return {
       url: buildDeepLink({
         app: "content",
         view: "editor",
-        params: { documentId },
+        params: {
+          documentId: receipt.row.documentId,
+          databaseId: receipt.target.databaseId,
+          databaseDocumentId: receipt.target.databaseDocumentId,
+        },
       }),
       label: "Open database row",
       view: "editor",
diff --git a/templates/content/app/components/editor/DocumentDatabase.tsx b/templates/content/app/components/editor/DocumentDatabase.tsx
index f8cab5c04f4..8f840ae04cb 100644
--- a/templates/content/app/components/editor/DocumentDatabase.tsx
+++ b/templates/content/app/components/editor/DocumentDatabase.tsx
@@ -8,12 +8,14 @@ export * from "./database/DatabaseView";
 interface DocumentDatabaseProps {
   document: Document;
   canEdit: boolean;
+  viewId?: string | null;
   onExportContextChange?: (context: DatabaseExportContext | null) => void;
 }
 
 export function DocumentDatabase({
   document,
   canEdit,
+  viewId,
   onExportContextChange,
 }: DocumentDatabaseProps) {
   const databaseId = document.database?.id;
@@ -24,6 +26,7 @@ export function DocumentDatabase({
       databaseId={databaseId}
       databaseDocumentId={document.id}
       canEdit={canEdit}
+      viewId={viewId}
       onExportContextChange={onExportContextChange}
     />
   );
diff --git a/templates/content/app/components/editor/DocumentEditor.layout.test.ts b/templates/content/app/components/editor/DocumentEditor.layout.test.ts
index 5a80ed6d29a..6118e12d893 100644
--- a/templates/content/app/components/editor/DocumentEditor.layout.test.ts
+++ b/templates/content/app/components/editor/DocumentEditor.layout.test.ts
@@ -23,11 +23,14 @@ import {
   positionAnchoredCommentCard,
   positionUnanchoredCommentCard,
   refreshUnchangedContentSaveWatermark,
+  refreshUnchangedTitleSaveWatermark,
   resizeDocumentTitleTextarea,
   shouldShowNewDocumentTypeChooser,
+  subscribeToAuthoritativeQuerySuccess,
   titleMatchConfirmsSave,
   updateAdditionalBlockContents,
   updateDocumentLoadFailureState,
+  utilityPanelAfterCommentFocusDismissal,
   visualEditorInstanceKey,
 } from "./DocumentEditor";
 import {
@@ -36,6 +39,12 @@ import {
 } from "./DocumentToolbar";
 
 describe("document editor layout", () => {
+  it("dismisses mobile comment focus without closing Info", () => {
+    expect(utilityPanelAfterCommentFocusDismissal("comments")).toBeNull();
+    expect(utilityPanelAfterCommentFocusDismissal("info")).toBe("info");
+    expect(utilityPanelAfterCommentFocusDismissal(null)).toBeNull();
+  });
+
   it("keeps the selected inline conversation visible after its last thread resolves", () => {
     expect(
       documentEditorShowsInlineComments({
@@ -314,6 +323,11 @@ describe("document editor layout", () => {
       errorUpdateCount: initial.errorUpdateCount,
       errorUpdatedAt: initial.errorUpdatedAt,
       isError: initial.isError,
+      authoritativeSuccess: {
+        queryIdentity: "document-a",
+        generation: 0,
+        errorUpdateCount: 0,
+      },
     });
     const unsubscribe = observer.subscribe(() => {});
 
@@ -339,6 +353,11 @@ describe("document editor layout", () => {
       errorUpdateCount: replacement.errorUpdateCount,
       errorUpdatedAt: replacement.errorUpdatedAt,
       isError: replacement.isError,
+      authoritativeSuccess: {
+        queryIdentity: "document-a",
+        generation: 0,
+        errorUpdateCount: 0,
+      },
     });
     expect(failure.failed).toBe(true);
     expect(
@@ -350,6 +369,11 @@ describe("document editor layout", () => {
         errorUpdateCount: replacement.errorUpdateCount,
         errorUpdatedAt: replacement.errorUpdatedAt,
         isError: replacement.isError,
+        authoritativeSuccess: {
+          queryIdentity: "document-a",
+          generation: 0,
+          errorUpdateCount: 0,
+        },
       }).failed,
     ).toBe(true);
 
@@ -360,6 +384,115 @@ describe("document editor layout", () => {
     });
   });
 
+  it("clears a latched load failure only after an authoritative fetch succeeds", () => {
+    const failed = {
+      documentId: "document-a",
+      queryIdentity: "document-a",
+      baselineErrorUpdateCount: 1,
+      baselineAuthoritativeSuccessGeneration: 0,
+      failed: true,
+    };
+    expect(
+      updateDocumentLoadFailureState({
+        previous: failed,
+        documentId: "document-a",
+        admitted: false,
+        dataUpdatedAt: 200,
+        errorUpdateCount: 1,
+        errorUpdatedAt: 100,
+        isError: false,
+        authoritativeSuccess: {
+          queryIdentity: "document-a",
+          generation: 0,
+          errorUpdateCount: 0,
+        },
+      }),
+    ).toBe(failed);
+
+    expect(
+      updateDocumentLoadFailureState({
+        previous: failed,
+        documentId: "document-a",
+        admitted: false,
+        dataUpdatedAt: 300,
+        errorUpdateCount: 1,
+        errorUpdatedAt: 100,
+        isError: false,
+        authoritativeSuccess: {
+          queryIdentity: "document-a",
+          generation: 1,
+          errorUpdateCount: 1,
+        },
+      }),
+    ).toEqual({
+      ...failed,
+      baselineAuthoritativeSuccessGeneration: 1,
+      failed: false,
+    });
+  });
+
+  it("resets the load-failure baseline when the document query context changes", () => {
+    expect(
+      updateDocumentLoadFailureState({
+        previous: {
+          documentId: "document-a",
+          queryIdentity: "context-a",
+          baselineErrorUpdateCount: 2,
+          baselineAuthoritativeSuccessGeneration: 3,
+          failed: true,
+        },
+        documentId: "document-a",
+        admitted: false,
+        dataUpdatedAt: 0,
+        errorUpdateCount: 0,
+        errorUpdatedAt: 0,
+        isError: false,
+        authoritativeSuccess: {
+          queryIdentity: "context-b",
+          generation: 0,
+          errorUpdateCount: 0,
+        },
+      }),
+    ).toEqual({
+      documentId: "document-a",
+      queryIdentity: "context-b",
+      baselineErrorUpdateCount: 0,
+      baselineAuthoritativeSuccessGeneration: 0,
+      failed: false,
+    });
+  });
+
+  it("distinguishes authoritative fetch success from manual cache writes", async () => {
+    const queryClient = new QueryClient();
+    const queryKey = ["action", "get-document", { id: "document-a" }];
+    const successes: number[] = [];
+    const unsubscribe = subscribeToAuthoritativeQuerySuccess(
+      queryClient,
+      queryKey,
+      (errorUpdateCount) => successes.push(errorUpdateCount),
+    );
+
+    await expect(
+      queryClient.fetchQuery({
+        queryKey,
+        queryFn: async () => {
+          throw new Error("unavailable");
+        },
+      }),
+    ).rejects.toThrow("unavailable");
+    expect(successes).toEqual([]);
+
+    queryClient.setQueryData(queryKey, { id: "document-a", title: "cached" });
+    expect(successes).toEqual([]);
+
+    await queryClient.fetchQuery({
+      queryKey,
+      queryFn: async () => ({ id: "document-a", title: "fetched" }),
+    });
+    expect(successes).toEqual([1]);
+    unsubscribe();
+  });
+
   it("does not admit settled cache-shaped data over a latched failure", () => {
     expect(
       documentEditorLoadState({
@@ -377,6 +510,23 @@ describe("document editor layout", () => {
     ).toEqual({ view: "error", admittedDocumentId: null });
   });
 
+  it("shows unavailable when an admitted document refetch settles with 404", () => {
+    expect(
+      documentEditorLoadState({
+        documentId: "document-a",
+        admittedDocumentId: "document-a",
+        hasDocument: true,
+        isDocumentCreationPending: false,
+        isFetchedAfterMount: true,
+        isFetching: false,
+        isError: true,
+        hasLoadFailure: false,
+        isManualRetrying: false,
+        error: { status: 404 },
+      }),
+    ).toEqual({ view: "unavailable", admittedDocumentId: null });
+  });
+
   it("waits for manual Retry to finish before admitting its success", () => {
     expect(
       documentEditorLoadState({
@@ -614,6 +764,37 @@ describe("document editor layout", () => {
     await expect(second).resolves.toBe("latest");
   });
 
+  it("keeps the first title edit writable after canonical creation advances the optimistic timestamp", () => {
+    const canonicalUpdatedAt = "2026-09-09T04:13:24.458Z";
+    const lastSaved = refreshUnchangedTitleSaveWatermark({
+      serverTitle: "",
+      serverUpdatedAt: canonicalUpdatedAt,
+      lastSaved: { title: "", updatedAt: "2026-09-09T04:13:24.400Z" },
+    });
+    expect(lastSaved).toEqual({ title: "", updatedAt: canonicalUpdatedAt });
+    expect(
+      metadataUpdatesWithPendingTitle({}, "Personal recovery", lastSaved.title),
+    ).toEqual({ title: "Personal recovery" });
+  });
+
+  it("does not confirm an optimistic or externally changed title as the saved baseline", () => {
+    const lastSaved = { title: "", updatedAt: "2026-09-09T04:13:24.400Z" };
+    expect(
+      refreshUnchangedTitleSaveWatermark({
+        serverTitle: "Unsaved local title",
+        serverUpdatedAt: "2026-09-09T04:13:24.458Z",
+        lastSaved,
+      }),
+    ).toBe(lastSaved);
+    expect(
+      refreshUnchangedTitleSaveWatermark({
+        serverTitle: "",
+        serverUpdatedAt: "2026-09-09T04:13:24.300Z",
+        lastSaved,
+      }),
+    ).toBe(lastSaved);
+  });
+
   it("advances the content CAS base across metadata-only row updates", () => {
     expect(
       refreshUnchangedContentSaveWatermark({
@@ -879,6 +1060,10 @@ describe("document editor layout", () => {
       new URL("./DocumentInfoPanel.tsx", import.meta.url),
       { encoding: "utf8" },
     );
+    const properties = readFileSync(
+      new URL("./DocumentProperties.tsx", import.meta.url),
+      { encoding: "utf8" },
+    );
 
     expect(source).toContain("<DocumentInfoPanel");
     expect(source).toContain("{!isDatabasePage ? (");
@@ -887,6 +1072,21 @@ describe("document editor layout", () => {
     );
     expect(infoPanel).toContain("<DescriptionField");
     expect(infoPanel).toContain("<DocumentProperties");
+    expect(source).toContain("ref={setUtilityPanelSheetContainer}");
+    expect(source).toContain("utilityPanelSheetContainer,");
+    expect(infoPanel).toContain("popoverContainer={popoverContainer}");
+    expect(properties).toMatch(
+      /<PropertyValuePopover[\s\S]*?container=\{popoverContainer\}/,
+    );
+    expect(properties).toMatch(
+      /<PropertyManagementPopover[\s\S]*?popoverContainer=\{popoverContainer\}/,
+    );
+    expect(properties).toMatch(
+      /<HiddenPropertiesMenu[\s\S]*?popoverContainer=\{popoverContainer\}/,
+    );
+    expect(properties).toMatch(
+      /<AddProperty[\s\S]*?popoverContainer=\{popoverContainer\}/,
+    );
     expect(infoPanel).toContain(
       "databaseId={databaseId ?? document.databaseMembership.databaseId}",
     );
@@ -1173,10 +1373,14 @@ describe("document editor layout", () => {
     );
     expect(source).toContain("data-[state=closed]:duration-[260ms]");
     expect(source).toContain("data-[state=open]:ease-[var(--ease-drawer)]");
-    expect(source).not.toContain("{showUtilityPanelSheet ? (");
     expect(source).toContain(
-      "renderUtilityPanelContent(lastUtilityPanel, true)",
+      'target.closest("[data-radix-popper-content-wrapper]")',
     );
+    expect(source).toContain(
+      "utilityPanelSheetContainer?.contains(nestedPopper)",
+    );
+    expect(source).not.toContain("{showUtilityPanelSheet ? (");
+    expect(source).toContain("utilityPanelSheetContainer,");
     expect(source).toContain("showDesktopCommentsHistory");
     expect(source).toContain("data-comments-history-rail");
     expect(source).toContain("commentsHistoryRailMounted");
diff --git a/templates/content/app/components/editor/DocumentEditor.tsx b/templates/content/app/components/editor/DocumentEditor.tsx
index b111c3d4615..58fe0fa6eb2 100644
--- a/templates/content/app/components/editor/DocumentEditor.tsx
+++ b/templates/content/app/components/editor/DocumentEditor.tsx
@@ -27,7 +27,11 @@ import {
   IconX,
 } from "@tabler/icons-react";
 import { IconLock } from "@tabler/icons-react";
-import { useQueryClient } from "@tanstack/react-query";
+import {
+  hashKey,
+  type QueryClient,
+  useQueryClient,
+} from "@tanstack/react-query";
 import {
   useCallback,
   useEffect,
@@ -186,6 +190,7 @@ interface DocumentEditorProps {
   documentId: string;
   databaseId?: string | null;
   databaseDocumentId?: string | null;
+  viewId?: string | null;
 }
 
 export interface PageEditorSession {
@@ -235,6 +240,22 @@ export function titleMatchConfirmsSave(args: {
   );
 }
 
+export function refreshUnchangedTitleSaveWatermark(args: {
+  serverTitle: string;
+  serverUpdatedAt: string | null;
+  lastSaved: FieldSaveWatermark;
+}): FieldSaveWatermark {
+  if (
+    args.serverTitle !== args.lastSaved.title ||
+    !args.serverUpdatedAt ||
+    (args.lastSaved.updatedAt &&
+      args.serverUpdatedAt <= args.lastSaved.updatedAt)
+  ) {
+    return args.lastSaved;
+  }
+  return { ...args.lastSaved, updatedAt: args.serverUpdatedAt };
+}
+
 export function refreshUnchangedContentSaveWatermark(args: {
   serverContent: string;
   serverUpdatedAt: string | null;
@@ -344,12 +365,14 @@ export function DocumentEditor({
   documentId,
   databaseId,
   databaseDocumentId,
+  viewId,
 }: DocumentEditorProps) {
   return (
     <PageEditorSurface
       documentId={documentId}
       databaseId={databaseId}
       databaseDocumentId={databaseDocumentId}
+      viewId={viewId}
       host="page"
     />
   );
@@ -370,6 +393,7 @@ export function PageEditorSurface({
   documentId,
   databaseId,
   databaseDocumentId,
+  viewId,
   host,
   onSessionChange,
   onDelete,
@@ -392,6 +416,14 @@ export function PageEditorSurface({
   } = documentQuery;
   const navigate = useNavigate();
   const queryClient = useQueryClient();
+  const documentQueryKeyValue = documentQueryKey(documentId, {
+    databaseId,
+    databaseDocumentId,
+  });
+  const authoritativeSuccess = useAuthoritativeQuerySuccess(
+    queryClient,
+    documentQueryKeyValue,
+  );
   const [manualRetryDocumentId, setManualRetryDocumentId] = useState<
     string | null
   >(null);
@@ -407,6 +439,7 @@ export function PageEditorSurface({
     errorUpdateCount,
     errorUpdatedAt,
     isError,
+    authoritativeSuccess,
   });
   loadFailureRef.current = loadFailure;
   const loadState = documentEditorLoadState({
@@ -437,7 +470,9 @@ export function PageEditorSurface({
       });
       loadFailureRef.current = {
         documentId,
+        queryIdentity: authoritativeSuccess.queryIdentity,
         baselineErrorUpdateCount: errorUpdateCount,
+        baselineAuthoritativeSuccessGeneration: authoritativeSuccess.generation,
         failed: false,
       };
       await documentQuery.refetch();
@@ -489,6 +524,7 @@ export function PageEditorSurface({
         document={document}
         databaseId={databaseId}
         databaseDocumentId={databaseDocumentId}
+        viewId={viewId}
         host={host}
         onSessionChange={onSessionChange}
         onDelete={onDelete}
@@ -558,10 +594,19 @@ export function documentEditorLoadState({
   const activeAdmittedDocumentId =
     admittedDocumentId === documentId ? admittedDocumentId : null;
 
-  if (
-    hasDocument &&
-    (isDocumentCreationPending || activeAdmittedDocumentId === documentId)
-  ) {
+  if (hasDocument && isDocumentCreationPending) {
+    return {
+      view: "editor" as const,
+      admittedDocumentId: documentId,
+    };
+  }
+  if (!isFetching && isError && isDocumentLoadUnavailableError(error)) {
+    return {
+      view: "unavailable" as const,
+      admittedDocumentId: null,
+    };
+  }
+  if (hasDocument && activeAdmittedDocumentId === documentId) {
     return {
       view: "editor" as const,
       admittedDocumentId: documentId,
@@ -590,10 +635,69 @@ export function documentEditorLoadState({
 
 type DocumentLoadFailureState = {
   documentId: string;
+  queryIdentity: string;
   baselineErrorUpdateCount: number;
+  baselineAuthoritativeSuccessGeneration: number;
   failed: boolean;
 };
 
+export type AuthoritativeQuerySuccess = {
+  queryIdentity: string;
+  generation: number;
+  errorUpdateCount: number;
+};
+
+export function subscribeToAuthoritativeQuerySuccess(
+  queryClient: QueryClient,
+  queryKey: readonly unknown[],
+  onSuccess: (errorUpdateCount: number) => void,
+) {
+  const queryHash = hashKey(queryKey);
+  return queryClient.getQueryCache().subscribe((event) => {
+    if (
+      event.type === "updated" &&
+      event.query.queryHash === queryHash &&
+      event.action.type === "success" &&
+      event.action.manual !== true
+    ) {
+      onSuccess(event.query.state.errorUpdateCount);
+    }
+  });
+}
+
+function useAuthoritativeQuerySuccess(
+  queryClient: QueryClient,
+  queryKey: readonly unknown[],
+): AuthoritativeQuerySuccess {
+  const queryHash = hashKey(queryKey);
+  const [success, setSuccess] = useState({
+    queryHash,
+    generation: 0,
+    errorUpdateCount: 0,
+  });
+
+  useEffect(
+    () =>
+      subscribeToAuthoritativeQuerySuccess(
+        queryClient,
+        queryKey,
+        (errorUpdateCount) => {
+          setSuccess((current) => ({
+            queryHash,
+            generation:
+              current.queryHash === queryHash ? current.generation + 1 : 1,
+            errorUpdateCount,
+          }));
+        },
+      ),
+    [queryClient, queryHash],
+  );
+
+  return success.queryHash === queryHash
+    ? { ...success, queryIdentity: queryHash }
+    : { queryIdentity: queryHash, generation: 0, errorUpdateCount: 0 };
+}
+
 export function updateDocumentLoadFailureState({
   previous,
   documentId,
@@ -602,6 +706,7 @@ export function updateDocumentLoadFailureState({
   errorUpdateCount,
   errorUpdatedAt,
   isError,
+  authoritativeSuccess,
 }: {
   previous: DocumentLoadFailureState | null;
   documentId: string;
@@ -610,18 +715,41 @@ export function updateDocumentLoadFailureState({
   errorUpdateCount: number;
   errorUpdatedAt: number;
   isError: boolean;
+  authoritativeSuccess: AuthoritativeQuerySuccess;
 }): DocumentLoadFailureState {
-  if (previous?.documentId !== documentId) {
+  if (
+    previous?.documentId !== documentId ||
+    previous.queryIdentity !== authoritativeSuccess.queryIdentity
+  ) {
     return {
       documentId,
+      queryIdentity: authoritativeSuccess.queryIdentity,
       baselineErrorUpdateCount: errorUpdateCount,
+      baselineAuthoritativeSuccessGeneration: authoritativeSuccess.generation,
       failed:
         isError || (errorUpdateCount > 0 && errorUpdatedAt > dataUpdatedAt),
     };
   }
+  if (
+    !isError &&
+    authoritativeSuccess.generation >
+      previous.baselineAuthoritativeSuccessGeneration &&
+    authoritativeSuccess.errorUpdateCount >= errorUpdateCount
+  ) {
+    return {
+      ...previous,
+      baselineErrorUpdateCount: errorUpdateCount,
+      baselineAuthoritativeSuccessGeneration: authoritativeSuccess.generation,
+      failed: false,
+    };
+  }
   if (admitted || previous.failed) return previous;
   return errorUpdateCount > previous.baselineErrorUpdateCount
-    ? { ...previous, failed: true }
+    ? {
+        ...previous,
+        baselineAuthoritativeSuccessGeneration: authoritativeSuccess.generation,
+        failed: true,
+      }
     : previous;
 }
 
@@ -698,6 +826,7 @@ interface DocumentEditorBodyProps {
   document: Document;
   databaseId?: string | null;
   databaseDocumentId?: string | null;
+  viewId?: string | null;
   host: "page" | "preview";
   onSessionChange?: (session: PageEditorSession | null) => void;
   onDelete?: () => Promise<void>;
@@ -868,6 +997,12 @@ export function documentEditorShowsInlineComments(args: {
   );
 }
 
+export function utilityPanelAfterCommentFocusDismissal(
+  utilityPanel: DocumentUtilityPanel,
+): DocumentUtilityPanel {
+  return utilityPanel === "comments" ? null : utilityPanel;
+}
+
 export function documentEditorTitleRegionClassName(
   hasDatabase: boolean,
   host: "page" | "preview" = "page",
@@ -1107,6 +1242,7 @@ function PageEditorSessionBody({
   document: incomingDocument,
   databaseId,
   databaseDocumentId,
+  viewId,
   host,
   onSessionChange,
   onDelete,
@@ -1702,7 +1838,14 @@ function PageEditorSessionBody({
     if (isLinkedLocalSourceDocument) return;
     const serverTitle = document.title;
     const lastSaved = lastSavedTitleRef.current;
-    if (serverTitle === lastSaved.title) return;
+    if (serverTitle === lastSaved.title) {
+      lastSavedTitleRef.current = refreshUnchangedTitleSaveWatermark({
+        serverTitle,
+        serverUpdatedAt: document.updatedAt ?? null,
+        lastSaved,
+      });
+      return;
+    }
     const adopt =
       localTitle === lastSaved.title ||
       (titleExternalIsNewer && !titleFocusedRef.current);
@@ -2877,6 +3020,8 @@ function PageEditorSessionBody({
   const [utilityPanel, setUtilityPanel] = useState<DocumentUtilityPanel>(null);
   const [lastUtilityPanel, setLastUtilityPanel] =
     useState<Exclude<DocumentUtilityPanel, null>>("comments");
+  const [utilityPanelSheetContainer, setUtilityPanelSheetContainer] =
+    useState<HTMLElement | null>(null);
   const [commentsBrowseOpen, setCommentsBrowseOpen] = useState(false);
   const [commentsHistoryRailMounted, setCommentsHistoryRailMounted] =
     useState(false);
@@ -3023,7 +3168,7 @@ function PageEditorSessionBody({
     clearCommentFocus();
     if (!hasUtilityRailSpace) {
       setCommentsBrowseOpen(false);
-      setUtilityPanel(null);
+      setUtilityPanel(utilityPanelAfterCommentFocusDismissal);
     }
   }, [clearCommentFocus, hasUtilityRailSpace]);
 
@@ -3473,6 +3618,7 @@ function PageEditorSessionBody({
   const renderUtilityPanelContent = (
     panel: Exclude<DocumentUtilityPanel, null>,
     inSheet = false,
+    popoverContainer?: HTMLElement | null,
   ) => {
     const utilityPanelTitle =
       panel === "info" ? t("editor.toolbar.info") : t("comments.title");
@@ -3530,6 +3676,7 @@ function PageEditorSessionBody({
             databaseId={databaseId}
             databaseDocumentId={databaseDocumentId}
             canEdit={editorCanEdit}
+            popoverContainer={popoverContainer}
             onSaveDescription={(description) =>
               persistDocumentUpdates({ description })
             }
@@ -3903,6 +4050,7 @@ function PageEditorSessionBody({
                     <DocumentDatabase
                       document={document}
                       canEdit={canEdit}
+                      viewId={viewId}
                       onExportContextChange={handleDatabaseExportContextChange}
                     />
                   </div>
@@ -4212,9 +4360,23 @@ function PageEditorSessionBody({
           }}
         >
           <SheetContent
+            ref={setUtilityPanelSheetContainer}
             side="right"
             className="flex min-h-0 w-[min(26rem,calc(100vw-1rem))] flex-col overflow-hidden p-0 data-[state=closed]:duration-[260ms] data-[state=open]:duration-[260ms] data-[state=closed]:ease-[var(--ease-drawer)] data-[state=open]:ease-[var(--ease-drawer)]"
             aria-describedby={undefined}
+            onEscapeKeyDown={(event) => {
+              const target = event.target;
+              const nestedPopper =
+                target instanceof Element
+                  ? target.closest("[data-radix-popper-content-wrapper]")
+                  : null;
+              if (
+                nestedPopper &&
+                utilityPanelSheetContainer?.contains(nestedPopper)
+              ) {
+                event.preventDefault();
+              }
+            }}
           >
             <SheetHeader className="sr-only">
               <SheetTitle>
@@ -4225,11 +4387,19 @@ function PageEditorSessionBody({
             </SheetHeader>
             {lastUtilityPanel === "comments" ? (
               <CommentHistoryScrollContainer className="min-h-0 min-w-0 flex-1 overflow-x-hidden overflow-y-auto">
-                {renderUtilityPanelContent(lastUtilityPanel, true)}
+                {renderUtilityPanelContent(
+                  lastUtilityPanel,
+                  true,
+                  utilityPanelSheetContainer,
+                )}
               </CommentHistoryScrollContainer>
             ) : (
               <div className="min-h-0 min-w-0 flex-1 overflow-x-hidden overflow-y-auto">
-                {renderUtilityPanelContent(lastUtilityPanel, true)}
+                {renderUtilityPanelContent(
+                  lastUtilityPanel,
+                  true,
+                  utilityPanelSheetContainer,
+                )}
               </div>
             )}
           </SheetContent>
diff --git a/templates/content/app/components/editor/DocumentInfoPanel.tsx b/templates/content/app/components/editor/DocumentInfoPanel.tsx
index d7246316584..e56476ddaf1 100644
--- a/templates/content/app/components/editor/DocumentInfoPanel.tsx
+++ b/templates/content/app/components/editor/DocumentInfoPanel.tsx
@@ -23,6 +23,7 @@ interface DocumentInfoPanelProps {
   databaseId?: string | null;
   databaseDocumentId?: string | null;
   canEdit: boolean;
+  popoverContainer?: HTMLElement | null;
   onSaveDescription: (description: string) => Promise<unknown>;
 }
 
@@ -33,6 +34,7 @@ export function DocumentInfoPanel({
   databaseId,
   databaseDocumentId,
   canEdit,
+  popoverContainer,
   onSaveDescription,
 }: DocumentInfoPanelProps) {
   const t = useT();
@@ -113,6 +115,7 @@ export function DocumentInfoPanel({
             databaseDocumentId ?? document.databaseMembership.databaseDocumentId
           }
           canEdit={canEdit}
+          popoverContainer={popoverContainer}
         />
       ) : null}
     </div>
diff --git a/templates/content/app/components/editor/DocumentProperties.tsx b/templates/content/app/components/editor/DocumentProperties.tsx
index 7e3c8917d06..994bb52cafb 100644
--- a/templates/content/app/components/editor/DocumentProperties.tsx
+++ b/templates/content/app/components/editor/DocumentProperties.tsx
@@ -170,6 +170,7 @@ interface DocumentPropertiesProps {
   databaseDocumentId: string | null;
   canEdit: boolean;
   popoversPortalled?: boolean;
+  popoverContainer?: HTMLElement | null;
 }
 
 export const TYPE_ICONS: Record<DocumentPropertyType, Icon> = {
@@ -848,6 +849,7 @@ export function DocumentProperties({
   databaseDocumentId,
   canEdit,
   popoversPortalled = true,
+  popoverContainer,
 }: DocumentPropertiesProps) {
   const t = useT();
   const { data, isLoading } = useDocumentProperties(documentId, databaseId);
@@ -895,6 +897,7 @@ export function DocumentProperties({
               canEditValues={canEditValues}
               canManageSchema={canManageSchema}
               popoversPortalled={popoversPortalled}
+              popoverContainer={popoverContainer}
               t={t}
             />
           ))}
@@ -903,18 +906,22 @@ export function DocumentProperties({
 
       {loaded && canManageSchema && hiddenProperties.length > 0 ? (
         <HiddenPropertiesMenu
+          databaseDocumentId={databaseDocumentId ?? documentId}
           documentId={documentId}
           databaseId={databaseId}
           properties={hiddenProperties}
+          popoverContainer={popoverContainer}
           t={t}
         />
       ) : null}
 
       {loaded && canManageSchema && databaseId ? (
         <AddProperty
+          databaseDocumentId={databaseDocumentId ?? documentId}
           documentId={documentId}
           databaseId={databaseId}
           popoversPortalled={popoversPortalled}
+          popoverContainer={popoverContainer}
         />
       ) : null}
     </div>
@@ -932,16 +939,24 @@ function isPropertyVisible(property: DocumentProperty) {
 
 function HiddenPropertiesMenu({
   documentId,
+  databaseDocumentId = documentId,
   databaseId,
   properties,
+  popoverContainer,
   t,
 }: {
   documentId: string;
+  databaseDocumentId?: string;
   databaseId: string;
   properties: DocumentProperty[];
+  popoverContainer?: HTMLElement | null;
   t: TFunction;
 }) {
-  const configure = useConfigureDocumentProperty(documentId, databaseId);
+  const configure = useConfigureDocumentProperty(
+    documentId,
+    databaseId,
+    databaseDocumentId,
+  );
 
   async function showProperty(property: DocumentProperty) {
     await configure.mutateAsync({
@@ -968,7 +983,11 @@ function HiddenPropertiesMenu({
           </span>
         </button>
       </DropdownMenuTrigger>
-      <DropdownMenuContent align="start" className="w-72">
+      <DropdownMenuContent
+        align="start"
+        className="w-72"
+        container={popoverContainer}
+      >
         {properties.map((property) => {
           const Icon = TYPE_ICONS[property.definition.type];
           return (
@@ -1002,6 +1021,7 @@ function PropertyRow({
   canEditValues,
   canManageSchema,
   popoversPortalled,
+  popoverContainer,
   t,
 }: {
   property: DocumentProperty;
@@ -1010,6 +1030,7 @@ function PropertyRow({
   canEditValues: boolean;
   canManageSchema: boolean;
   popoversPortalled: boolean;
+  popoverContainer?: HTMLElement | null;
   t: TFunction;
 }) {
   const Icon = TYPE_ICONS[property.definition.type];
@@ -1023,10 +1044,12 @@ function PropertyRow({
     <div className="grid min-h-8 grid-cols-[120px_minmax(0,1fr)] sm:grid-cols-[160px_minmax(0,1fr)] items-start gap-3 rounded px-1 py-1 text-sm hover:bg-muted/40">
       {canManageSchema && !property.definition.systemRole ? (
         <PropertyManagementPopover
+          databaseDocumentId={databaseDocumentId}
           property={property}
           documentId={documentId}
           databaseId={property.definition.databaseId!}
           icon={Icon}
+          popoverContainer={popoverContainer}
         />
       ) : (
         <div className="flex min-w-0 items-center gap-2 text-muted-foreground">
@@ -1056,6 +1079,7 @@ function PropertyRow({
           documentId={documentId}
           databaseDocumentId={databaseDocumentId}
           portalled={popoversPortalled}
+          container={popoverContainer}
         >
           {value}
         </PropertyValuePopover>
@@ -1089,6 +1113,7 @@ export function propertyTypeForSourceFieldType(
 export function PropertyManagementPopover({
   property,
   documentId,
+  databaseDocumentId = documentId,
   databaseId,
   icon: Icon,
   triggerClassName,
@@ -1105,9 +1130,11 @@ export function PropertyManagementPopover({
   onMoveRight,
   onHide,
   hideDisabled,
+  popoverContainer,
 }: {
   property: DocumentProperty;
   documentId: string;
+  databaseDocumentId?: string;
   databaseId: string;
   icon: Icon;
   triggerClassName?: string;
@@ -1124,6 +1151,7 @@ export function PropertyManagementPopover({
   onMoveRight?: () => void | Promise<void>;
   onHide?: () => void | Promise<void>;
   hideDisabled?: boolean;
+  popoverContainer?: HTMLElement | null;
 }) {
   const t = useT();
   const hasColumnMenu = !!(
@@ -1141,7 +1169,11 @@ export function PropertyManagementPopover({
   const quickFilters = databaseQuickFilterOptionsForColumn(
     property.definition.type,
   );
-  const configure = useConfigureDocumentProperty(documentId, databaseId);
+  const configure = useConfigureDocumentProperty(
+    documentId,
+    databaseId,
+    databaseDocumentId,
+  );
   const duplicate = useDuplicateDocumentProperty(documentId, databaseId);
   const remove = useDeleteDocumentProperty(documentId, databaseId);
   const { data: propertiesData } = useDocumentProperties(
@@ -1458,6 +1490,7 @@ export function PropertyManagementPopover({
           ref={menuContentRef}
           align="start"
           collisionPadding={12}
+          container={popoverContainer}
           className="relative z-[300] w-72 max-h-[var(--radix-dropdown-menu-content-available-height)] overflow-y-auto"
         >
           {view === "quick" && hasColumnMenu ? (
@@ -1480,7 +1513,10 @@ export function PropertyManagementPopover({
                   <IconFilter className="mr-2 size-4 text-muted-foreground" />
                   {t("database.filter")}
                 </DropdownMenuSubTrigger>
-                <DropdownMenuSubContent className="z-[310] w-56">
+                <DropdownMenuSubContent
+                  className="z-[310] w-56"
+                  container={popoverContainer}
+                >
                   {quickFilters.map((quickFilter) => (
                     <DropdownMenuItem
                       key={quickFilter.operator}
@@ -1525,7 +1561,10 @@ export function PropertyManagementPopover({
                   <IconArrowsSort className="mr-2 size-4 text-muted-foreground" />
                   {t("database.sort")}
                 </DropdownMenuSubTrigger>
-                <DropdownMenuSubContent className="z-[310] w-56">
+                <DropdownMenuSubContent
+                  className="z-[310] w-56"
+                  container={popoverContainer}
+                >
                   <DropdownMenuItem
                     onSelect={(event) => {
                       event.preventDefault();
@@ -1673,7 +1712,10 @@ export function PropertyManagementPopover({
                     {t(`editor.propertyTypes.${property.definition.type}`)}
                   </span>
                 </DropdownMenuSubTrigger>
-                <DropdownMenuSubContent className="z-[310] max-h-80 w-56 overflow-auto">
+                <DropdownMenuSubContent
+                  className="z-[310] max-h-80 w-56 overflow-auto"
+                  container={popoverContainer}
+                >
                   {CREATABLE_DOCUMENT_PROPERTY_TYPES.map((propertyType) => {
                     const TypeIcon = TYPE_ICONS[propertyType];
                     const selected = property.definition.type === propertyType;
@@ -1712,7 +1754,10 @@ export function PropertyManagementPopover({
                     )}
                   </span>
                 </DropdownMenuSubTrigger>
-                <DropdownMenuSubContent className="z-[310] w-56">
+                <DropdownMenuSubContent
+                  className="z-[310] w-56"
+                  container={popoverContainer}
+                >
                   {DOCUMENT_PROPERTY_VISIBILITIES.map((visibility) => (
                     <DropdownMenuItem
                       key={visibility}
@@ -1752,6 +1797,7 @@ export function PropertyManagementPopover({
                             key={option.id}
                             option={option}
                             disabled={configure.isPending}
+                            popoverContainer={popoverContainer}
                             onRename={(name) =>
                               void renameOption(option.id, name)
                             }
@@ -1843,7 +1889,10 @@ export function PropertyManagementPopover({
                           <IconPlus className="mr-1.5 size-3.5 text-muted-foreground" />
                           {t("database.bindAFieldFromASource")}
                         </DropdownMenuSubTrigger>
-                        <DropdownMenuSubContent className="z-[310] max-h-80 w-64 overflow-auto">
+                        <DropdownMenuSubContent
+                          className="z-[310] max-h-80 w-64 overflow-auto"
+                          container={popoverContainer}
+                        >
                           {bindableSourceFields.map(
                             ({ source: src, field }) => (
                               <DropdownMenuItem
@@ -1974,6 +2023,7 @@ function PropertyOptionSettingsRow({
   onDescriptionChange,
   onColorChange,
   onRemove,
+  popoverContainer,
 }: {
   option: DocumentPropertyOption;
   disabled: boolean;
@@ -1981,6 +2031,7 @@ function PropertyOptionSettingsRow({
   onDescriptionChange: (description: string) => void;
   onColorChange: (color: DocumentPropertyOptionColor) => void;
   onRemove: () => void;
+  popoverContainer?: HTMLElement | null;
 }) {
   const t = useT();
   const [draftName, setDraftName] = useState(option.name);
@@ -2045,7 +2096,10 @@ function PropertyOptionSettingsRow({
               className={cn("block size-3 rounded-full", optionClass(option))}
             />
           </DropdownMenuSubTrigger>
-          <DropdownMenuSubContent className="z-[310] w-44">
+          <DropdownMenuSubContent
+            className="z-[310] w-44"
+            container={popoverContainer}
+          >
             {OPTION_COLORS.map((color) => (
               <DropdownMenuItem
                 key={color}
@@ -2128,12 +2182,14 @@ export function PropertyValuePopover({
   databaseDocumentId = documentId,
   children,
   portalled = true,
+  container,
 }: {
   property: DocumentProperty;
   documentId: string;
   databaseDocumentId?: string;
   children: React.ReactNode;
   portalled?: boolean;
+  container?: HTMLElement | null;
 }) {
   const t = useT();
   const [open, setOpen] = useState(false);
@@ -2151,7 +2207,12 @@ export function PropertyValuePopover({
           {children}
         </button>
       </PopoverTrigger>
-      <PopoverContent align="start" portalled={portalled} className="w-80 p-2">
+      <PopoverContent
+        align="start"
+        portalled={portalled}
+        container={container}
+        className="w-80 p-2"
+      >
         <PropertyValueEditor
           property={property}
           documentId={documentId}
@@ -3296,10 +3357,12 @@ function OptionValueEditor({
 
 export function AddProperty({
   documentId,
+  databaseDocumentId = documentId,
   databaseId,
   variant = "default",
   label,
   popoversPortalled = true,
+  popoverContainer,
   source,
   sources,
   onConnectSource,
@@ -3307,10 +3370,12 @@ export function AddProperty({
   onOpenRequestHandled,
 }: {
   documentId: string;
+  databaseDocumentId?: string;
   databaseId: string;
   variant?: "default" | "header" | "icon";
   label?: string;
   popoversPortalled?: boolean;
+  popoverContainer?: HTMLElement | null;
   source?: ContentDatabaseSource | null;
   sources?: ContentDatabaseSource[];
   onConnectSource?: () => void;
@@ -3318,7 +3383,11 @@ export function AddProperty({
   onOpenRequestHandled?: (requestId: number) => void;
 }) {
   const t = useT();
-  const configure = useConfigureDocumentProperty(documentId, databaseId);
+  const configure = useConfigureDocumentProperty(
+    documentId,
+    databaseId,
+    databaseDocumentId,
+  );
   const addSourceFieldProperty =
     useAddContentDatabaseSourceFieldProperty(documentId);
   const [open, setOpen] = useState(false);
@@ -3511,6 +3580,7 @@ export function AddProperty({
         align={variant === "default" ? "start" : "end"}
         collisionPadding={12}
         portalled={popoversPortalled}
+        container={popoverContainer}
         className={cn(
           "relative z-[300] w-80 p-2",
           sourceHandoffClosing &&
diff --git a/templates/content/app/components/editor/database/DatabaseView.error-toasts.test.tsx b/templates/content/app/components/editor/database/DatabaseView.error-toasts.test.tsx
index ad73887ac64..c0e0df01e3f 100644
--- a/templates/content/app/components/editor/database/DatabaseView.error-toasts.test.tsx
+++ b/templates/content/app/components/editor/database/DatabaseView.error-toasts.test.tsx
@@ -676,31 +676,31 @@ describe("DatabaseView UI regressions", () => {
       settingsButton?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
     });
 
-    const sourcesRow = findButtonByText(container, "Sources");
+    const sourcesRow = findButtonByText(document.body, "Sources");
     expect(sourcesRow).toBeTruthy();
     await act(async () => {
       sourcesRow?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
     });
 
-    const builderRow = findButtonByText(container, "Builder");
+    const builderRow = findButtonByText(document.body, "Builder");
     expect(builderRow).toBeTruthy();
     await act(async () => {
       builderRow?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
     });
 
-    const spaceRow = findButtonByText(container, "Test Space");
+    const spaceRow = findButtonByText(document.body, "Test Space");
     expect(spaceRow).toBeTruthy();
     await act(async () => {
       spaceRow?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
     });
 
-    const modelRow = findButtonByText(container, "Article");
+    const modelRow = findButtonByText(document.body, "Article");
     expect(modelRow).toBeTruthy();
     await act(async () => {
       modelRow?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
     });
 
-    const attachButton = findButtonByText(container, "Attach");
+    const attachButton = findButtonByText(document.body, "Attach");
     expect(attachButton).toBeTruthy();
 
     await act(async () => {
@@ -720,8 +720,8 @@ describe("DatabaseView UI regressions", () => {
     // nav stack should still be on the model leaf (its Attach button and the
     // model's display name are still showing), not reset back to the Sources
     // root.
-    expect(findButtonByText(container, "Attach")).toBeTruthy();
-    expect(container.textContent).toContain("Article");
+    expect(findButtonByText(document.body, "Attach")).toBeTruthy();
+    expect(document.body.textContent).toContain("Article");
   });
 
   it("shows a toast and keeps the source picker retryable when adding another item source fails", async () => {
@@ -762,7 +762,7 @@ describe("DatabaseView UI regressions", () => {
     await renderDatabaseView();
 
     await act(async () => {
-      findButtonByText(container, "Add property")?.click();
+      findButtonByText(document.body, "Add property")?.click();
     });
     await act(async () => {
       findButtonByText(
@@ -771,17 +771,17 @@ describe("DatabaseView UI regressions", () => {
       )?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Builder")?.click();
+      findButtonByText(document.body, "Builder")?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Test Space")?.click();
+      findButtonByText(document.body, "Test Space")?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Article")?.click();
+      findButtonByText(document.body, "Article")?.click();
     });
     await act(async () => {
       findButtonByText(
-        container,
+        document.body,
         messagesByLocale["en-US"].database.addMoreItemsToThisList,
       )?.click();
       await Promise.resolve();
@@ -793,7 +793,7 @@ describe("DatabaseView UI regressions", () => {
       failedToAttachSource,
       expect.objectContaining({ description: "second attach failed" }),
     );
-    expect(container.textContent).toContain("Article");
+    expect(document.body.textContent).toContain("Article");
     expect(
       document.body.querySelector(
         'input[aria-label="editor.properties.searchPropertyTypes"]',
@@ -805,7 +805,7 @@ describe("DatabaseView UI regressions", () => {
     await renderDatabaseView();
 
     await act(async () => {
-      findButtonByText(container, "Add property")?.click();
+      findButtonByText(document.body, "Add property")?.click();
     });
     const connectSource = findButtonByText(
       document.body,
@@ -816,7 +816,7 @@ describe("DatabaseView UI regressions", () => {
     await act(async () => {
       connectSource?.click();
     });
-    expect(container.textContent).toContain("Sources");
+    expect(document.body.textContent).toContain("Sources");
     expect(
       document.body.querySelector(
         'input[aria-label="editor.properties.searchPropertyTypes"]',
@@ -824,13 +824,13 @@ describe("DatabaseView UI regressions", () => {
     ).toBeNull();
 
     await act(async () => {
-      container
+      document.body
         .querySelector<HTMLButtonElement>(
           `[aria-label="${messagesByLocale["en-US"].database.closeDatabaseSettings}"]`,
         )
         ?.click();
     });
-    expect(container.textContent).not.toContain("Connected sources");
+    expect(document.body.textContent).not.toContain("Connected sources");
     expect(
       document.body.querySelector(
         'input[aria-label="editor.properties.searchPropertyTypes"]',
@@ -842,7 +842,7 @@ describe("DatabaseView UI regressions", () => {
     await renderDatabaseView();
 
     await act(async () => {
-      findButtonByText(container, "Add property")?.click();
+      findButtonByText(document.body, "Add property")?.click();
     });
     const searchInput = document.body.querySelector<HTMLInputElement>(
       'input[aria-label="editor.properties.searchPropertyTypes"]',
@@ -862,7 +862,7 @@ describe("DatabaseView UI regressions", () => {
       await Promise.resolve();
     });
 
-    expect(container.textContent).toContain("Sources");
+    expect(document.body.textContent).toContain("Sources");
     expect(
       document.body.querySelector(
         'input[aria-label="editor.properties.searchPropertyTypes"]',
@@ -893,18 +893,18 @@ describe("DatabaseView UI regressions", () => {
         )?.click();
       });
 
-      expect(container.textContent).toContain("Sources");
+      expect(document.body.textContent).toContain("Sources");
       await act(async () => {
-        findButtonByText(container, "Builder")?.click();
+        findButtonByText(document.body, "Builder")?.click();
       });
       await act(async () => {
-        findButtonByText(container, "Test Space")?.click();
+        findButtonByText(document.body, "Test Space")?.click();
       });
       await act(async () => {
-        findButtonByText(container, "Article")?.click();
+        findButtonByText(document.body, "Article")?.click();
       });
       await act(async () => {
-        findButtonByText(container, "Attach")?.click();
+        findButtonByText(document.body, "Attach")?.click();
         await Promise.resolve();
         await Promise.resolve();
       });
@@ -928,7 +928,7 @@ describe("DatabaseView UI regressions", () => {
     await renderDatabaseView();
 
     await act(async () => {
-      findButtonByText(container, "Add property")?.click();
+      findButtonByText(document.body, "Add property")?.click();
     });
     await act(async () => {
       findButtonByText(
@@ -937,20 +937,20 @@ describe("DatabaseView UI regressions", () => {
       )?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Builder")?.click();
+      findButtonByText(document.body, "Builder")?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Test Space")?.click();
+      findButtonByText(document.body, "Test Space")?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Article")?.click();
+      findButtonByText(document.body, "Article")?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Attach")?.click();
+      findButtonByText(document.body, "Attach")?.click();
       await Promise.resolve();
     });
 
-    expect(container.textContent).not.toContain("Database settings");
+    expect(document.body.textContent).not.toContain("Database settings");
     expect(attachSourceMutation.mutateAsync).toHaveBeenCalledTimes(1);
 
     await act(async () => {
@@ -986,7 +986,7 @@ describe("DatabaseView UI regressions", () => {
     await renderDatabaseView();
 
     await act(async () => {
-      findButtonByText(container, "Add property")?.click();
+      findButtonByText(document.body, "Add property")?.click();
     });
     await act(async () => {
       findButtonByText(
@@ -995,22 +995,22 @@ describe("DatabaseView UI regressions", () => {
       )?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Builder")?.click();
+      findButtonByText(document.body, "Builder")?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Test Space")?.click();
+      findButtonByText(document.body, "Test Space")?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Article")?.click();
+      findButtonByText(document.body, "Article")?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Attach")?.click();
+      findButtonByText(document.body, "Attach")?.click();
       await Promise.resolve();
       await Promise.resolve();
     });
 
-    expect(container.textContent).toContain("Article");
-    expect(findButtonByText(container, "Attach")).toBeTruthy();
+    expect(document.body.textContent).toContain("Article");
+    expect(findButtonByText(document.body, "Attach")).toBeTruthy();
     expect(toastErrorMock).toHaveBeenCalledWith(failedToAttachSource, {
       description: "Builder attach failed",
     });
@@ -1021,7 +1021,7 @@ describe("DatabaseView UI regressions", () => {
     await renderDatabaseView();
 
     await act(async () => {
-      findButtonByText(container, "Add property")?.click();
+      findButtonByText(document.body, "Add property")?.click();
     });
     await act(async () => {
       findButtonByText(
@@ -1030,25 +1030,25 @@ describe("DatabaseView UI regressions", () => {
       )?.click();
     });
     await act(async () => {
-      container
+      document.body
         .querySelector<HTMLButtonElement>('[aria-label="Back"]')
         ?.click();
     });
 
     await act(async () => {
-      findButtonByText(container, "Sources")?.click();
+      findButtonByText(document.body, "Sources")?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Builder")?.click();
+      findButtonByText(document.body, "Builder")?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Test Space")?.click();
+      findButtonByText(document.body, "Test Space")?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Article")?.click();
+      findButtonByText(document.body, "Article")?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Attach")?.click();
+      findButtonByText(document.body, "Attach")?.click();
       await Promise.resolve();
       await Promise.resolve();
     });
@@ -1115,7 +1115,7 @@ describe("DatabaseView UI regressions", () => {
     await renderDatabaseView();
 
     await act(async () => {
-      findButtonByText(container, "Add property")?.click();
+      findButtonByText(document.body, "Add property")?.click();
     });
     await act(async () => {
       findButtonByText(
@@ -1124,30 +1124,30 @@ describe("DatabaseView UI regressions", () => {
       )?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Builder")?.click();
+      findButtonByText(document.body, "Builder")?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Test Space")?.click();
+      findButtonByText(document.body, "Test Space")?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Article")?.click();
+      findButtonByText(document.body, "Article")?.click();
     });
 
     await act(async () => {
-      findButtonByText(container, "Attach")?.click();
+      findButtonByText(document.body, "Attach")?.click();
       await Promise.resolve();
       await Promise.resolve();
     });
 
     expect(attachSourceMutation.mutateAsync).toHaveBeenCalledTimes(1);
-    expect(
-      document.body.querySelector(
-        'input[aria-label="editor.properties.searchPropertyTypes"]',
-      ),
-    ).toBeTruthy();
+    const reopenedPropertySearch = document.body.querySelector(
+      'input[aria-label="editor.properties.searchPropertyTypes"]',
+    );
+    expect(reopenedPropertySearch).toBeTruthy();
+    expect(document.activeElement).toBe(reopenedPropertySearch);
     expect(document.body.textContent).toContain("editor.properties.fromSource");
     expect(document.body.textContent).toContain("Author");
-    expect(container.textContent).not.toContain("Connected sources");
+    expect(document.body.textContent).not.toContain("Connected sources");
 
     await act(async () => {
       findButtonByText(
@@ -1156,17 +1156,17 @@ describe("DatabaseView UI regressions", () => {
       )?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Builder")?.click();
+      findButtonByText(document.body, "Builder")?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Test Space")?.click();
+      findButtonByText(document.body, "Test Space")?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Author model")?.click();
+      findButtonByText(document.body, "Author model")?.click();
     });
     await act(async () => {
       findButtonByText(
-        container,
+        document.body,
         messagesByLocale["en-US"].database.addMoreItemsToThisList,
       )?.click();
       await Promise.resolve();
@@ -1234,7 +1234,7 @@ describe("DatabaseView UI regressions", () => {
     await renderDatabaseView();
 
     await act(async () => {
-      findButtonByText(container, "Add property")?.click();
+      findButtonByText(document.body, "Add property")?.click();
     });
     await act(async () => {
       findButtonByText(
@@ -1243,11 +1243,11 @@ describe("DatabaseView UI regressions", () => {
       )?.click();
     });
     await act(async () => {
-      findButtonByText(container, "Authors")?.click();
+      findButtonByText(document.body, "Authors")?.click();
     });
     await act(async () => {
       findButtonByText(
-        container,
+        document.body,
         messagesByLocale["en-US"].database.addAsItems,
       )?.click();
       await Promise.resolve();
@@ -1258,7 +1258,7 @@ describe("DatabaseView UI regressions", () => {
       failedToAttachSource,
       expect.objectContaining({ description: "role change failed" }),
     );
-    expect(container.textContent).toContain("Authors");
+    expect(document.body.textContent).toContain("Authors");
     expect(
       document.body.querySelector(
         'input[aria-label="editor.properties.searchPropertyTypes"]',
@@ -1268,7 +1268,7 @@ describe("DatabaseView UI regressions", () => {
     changeSourceRoleMutation.mutateAsync.mockResolvedValue(databaseResponse);
     await act(async () => {
       findButtonByText(
-        container,
+        document.body,
         messagesByLocale["en-US"].database.addAsItems,
       )?.click();
       await Promise.resolve();
@@ -1286,7 +1286,7 @@ describe("DatabaseView UI regressions", () => {
         'input[aria-label="editor.properties.searchPropertyTypes"]',
       ),
     ).toBeTruthy();
-    expect(container.textContent).not.toContain("Connected sources");
+    expect(document.body.textContent).not.toContain("Connected sources");
   });
 
   it("removes the confirmed selection snapshot without clearing newer selections", async () => {
diff --git a/templates/content/app/components/editor/database/DatabaseView.save-recovery.test.ts b/templates/content/app/components/editor/database/DatabaseView.save-recovery.test.ts
index fbbf5c1ccb7..6fc4c1dcb58 100644
--- a/templates/content/app/components/editor/database/DatabaseView.save-recovery.test.ts
+++ b/templates/content/app/components/editor/database/DatabaseView.save-recovery.test.ts
@@ -1,6 +1,8 @@
+import type { ContentDatabaseResponse } from "@shared/api";
 import { describe, expect, it } from "vitest";
 
 import {
+  contentDatabaseViewSaveRequest,
   createDatabaseView,
   defaultDatabaseViewConfig,
   databaseViewConfigWithSavedQueryState,
@@ -69,3 +71,112 @@ describe("failed table presentation saves", () => {
     expect(result.views[0].sorts).toEqual(current.views[0].sorts);
   });
 });
+
+function databaseResponse({
+  id = "qa",
+  spaceId = "space-1",
+  systemRole = null,
+}: {
+  id?: string;
+  spaceId?: string | null;
+  systemRole?: string | null;
+} = {}): ContentDatabaseResponse {
+  return {
+    database: {
+      id,
+      documentId: `${id}-page`,
+      spaceId,
+      systemRole,
+      title: "QA",
+      viewConfig: defaultDatabaseViewConfig(),
+      createdAt: "2026-09-09T00:00:00.000Z",
+      updatedAt: "2026-09-09T00:00:00.000Z",
+    },
+    properties: [],
+    items: [],
+    source: null,
+  };
+}
+
+const guardedRevision = {
+  databaseId: "qa",
+  target: {
+    spaceId: "space-1",
+    databaseId: "qa",
+    databaseDocumentId: "qa-page",
+  },
+  schemaRevision: "schema-1",
+  configurationRevision: "configuration-1",
+};
+
+describe("database view save compatibility", () => {
+  it.each([
+    { systemRole: "files", spaceId: "space-1" },
+    { systemRole: null, spaceId: null },
+  ])(
+    "uses the legacy action contract for an explicitly unsupported database class",
+    ({ systemRole, spaceId }) => {
+      const viewConfig = defaultDatabaseViewConfig();
+      viewConfig.views[0] = {
+        ...viewConfig.views[0],
+        type: "calendar",
+        datePropertyId: "publish-date",
+        endDatePropertyId: "publish-end",
+      };
+
+      expect(
+        contentDatabaseViewSaveRequest({
+          data: databaseResponse({ systemRole, spaceId }),
+          databaseId: "qa",
+          revision: null,
+          idempotencyKey: "intent-1",
+          viewConfig,
+        }),
+      ).toEqual({ databaseId: "qa", viewConfig });
+    },
+  );
+
+  it("keeps ordinary scoped databases on the revision-guarded contract", () => {
+    const viewConfig = defaultDatabaseViewConfig();
+    expect(
+      contentDatabaseViewSaveRequest({
+        data: databaseResponse(),
+        databaseId: "qa",
+        revision: guardedRevision,
+        idempotencyKey: "intent-1",
+        viewConfig,
+      }),
+    ).toEqual({
+      operation: "replace",
+      target: guardedRevision.target,
+      expectedSchemaRevision: "schema-1",
+      expectedConfigurationRevision: "configuration-1",
+      idempotencyKey: "intent-1",
+      viewConfig,
+    });
+  });
+
+  it("refuses an ordinary scoped save when its guarded contract is missing", () => {
+    expect(() =>
+      contentDatabaseViewSaveRequest({
+        data: databaseResponse(),
+        databaseId: "qa",
+        revision: null,
+        idempotencyKey: "intent-1",
+        viewConfig: defaultDatabaseViewConfig(),
+      }),
+    ).toThrow("Database view save contract is unavailable");
+  });
+
+  it("refuses a queued save when the loaded database has changed", () => {
+    expect(() =>
+      contentDatabaseViewSaveRequest({
+        data: databaseResponse({ id: "new-database", spaceId: null }),
+        databaseId: "old-database",
+        revision: null,
+        idempotencyKey: "intent-1",
+        viewConfig: defaultDatabaseViewConfig(),
+      }),
+    ).toThrow("Database view save context is unavailable");
+  });
+});
diff --git a/templates/content/app/components/editor/database/DatabaseView.test.ts b/templates/content/app/components/editor/database/DatabaseView.test.ts
index ff6db70a014..33f3ffefc57 100644
--- a/templates/content/app/components/editor/database/DatabaseView.test.ts
+++ b/templates/content/app/components/editor/database/DatabaseView.test.ts
@@ -12,6 +12,7 @@ import { describe, expect, it } from "vitest";
 
 import {
   acquireDatabaseSourceOperation,
+  createDatabaseViewSaveQueue,
   databaseBuilderBulkUpdateSource,
   databaseBuilderHydrationSourceForItem,
   databaseBulkEditableProperties,
@@ -67,8 +68,19 @@ import {
   previewDraftNeedsConflict,
   previewDraftMissingCasRecovery,
   preparedBuilderReviewMatches,
+  requestedDatabaseViewId,
 } from "./DatabaseView";
 
+describe("database view deep-link selection", () => {
+  it("prefers the explicit route view without changing the saved default", () => {
+    expect(requestedDatabaseViewId(" ready-drafts ", "default")).toBe(
+      "ready-drafts",
+    );
+    expect(requestedDatabaseViewId(null, " default ")).toBe("default");
+    expect(requestedDatabaseViewId("   ", null)).toBeNull();
+  });
+});
+
 describe("database source page projections", () => {
   it("does not present page-scoped review counts as complete", () => {
     expect(
@@ -1618,3 +1630,29 @@ describe("Database bulk multi-select edit helpers", () => {
     });
   });
 });
+
+describe("createDatabaseViewSaveQueue", () => {
+  it("constructs a queued save after the previous receipt updates revisions", async () => {
+    const enqueue = createDatabaseViewSaveQueue();
+    let revision = "S0/C0";
+    const inputs: string[] = [];
+    let finishFirst!: () => void;
+    const firstResponse = new Promise<void>((resolve) => {
+      finishFirst = resolve;
+    });
+    const first = enqueue(async () => {
+      inputs.push(revision);
+      await firstResponse;
+      revision = "S1/C1";
+    });
+    const second = enqueue(async () => {
+      inputs.push(revision);
+      revision = "S2/C2";
+    });
+    await Promise.resolve();
+    expect(inputs).toEqual(["S0/C0"]);
+    finishFirst();
+    await Promise.all([first, second]);
+    expect(inputs).toEqual(["S0/C0", "S1/C1"]);
+  });
+});
diff --git a/templates/content/app/components/editor/database/DatabaseView.tsx b/templates/content/app/components/editor/database/DatabaseView.tsx
index 1c1a0873cd4..b03b6965ba6 100644
--- a/templates/content/app/components/editor/database/DatabaseView.tsx
+++ b/templates/content/app/components/editor/database/DatabaseView.tsx
@@ -200,6 +200,8 @@ import {
   useSuggestSourceJoinKey,
   useUpdateContentDatabasePersonalView,
   useUpdateContentDatabaseView,
+  type ContentDatabaseViewSaveRequest,
+  type ContentDatabaseViewSaveResponse,
   writeBuilderAttachPreviewToCache,
 } from "@/hooks/use-content-database";
 import {
@@ -299,12 +301,75 @@ export interface DatabaseViewProps {
   renderMode?: "page" | "inline";
   canEdit?: boolean;
   isActive?: boolean;
+  viewId?: string | null;
   onExportContextChange?: (context: DatabaseExportContext | null) => void;
 }
 
 const CONTENT_DATABASE_PAGE_SIZE = 100;
 const CONTENT_DATABASE_MAX_ITEM_LIMIT = 5_000;
 
+export function createDatabaseViewSaveQueue() {
+  let previous: Promise<unknown> = Promise.resolve();
+  return <T,>(save: () => Promise<T>): Promise<T> => {
+    const next = previous.then(save, save);
+    previous = next;
+    return next;
+  };
+}
+
+type DatabaseViewSetupRevision = {
+  databaseId: string;
+  target: {
+    spaceId: string;
+    databaseId: string;
+    databaseDocumentId: string;
+  };
+  schemaRevision: string;
+  configurationRevision: string;
+};
+
+export function contentDatabaseViewSaveRequest({
+  data,
+  databaseId,
+  revision,
+  idempotencyKey,
+  viewConfig,
+}: {
+  data: ContentDatabaseResponse | undefined;
+  databaseId: string;
+  revision: DatabaseViewSetupRevision | null;
+  idempotencyKey: string;
+  viewConfig: ContentDatabaseViewConfig;
+}): ContentDatabaseViewSaveRequest {
+  if (!data || data.database.id !== databaseId) {
+    throw new Error("Database view save context is unavailable");
+  }
+  if (data.database.systemRole != null || data.database.spaceId == null) {
+    return { databaseId, viewConfig };
+  }
+  if (
+    !revision ||
+    revision.databaseId !== databaseId ||
+    revision.target.databaseId !== databaseId
+  ) {
+    throw new Error("Database view save contract is unavailable");
+  }
+  return {
+    operation: "replace",
+    target: revision.target,
+    expectedSchemaRevision: revision.schemaRevision,
+    expectedConfigurationRevision: revision.configurationRevision,
+    idempotencyKey,
+    viewConfig,
+  };
+}
+
+function contentDatabaseViewSaveValue(
+  response: ContentDatabaseViewSaveResponse,
+) {
+  return "receipt" in response ? response.value : response.database.viewConfig;
+}
+
 export function databaseSearchExpandedItemLimit(
   searchQuery: string,
   currentLimit: number,
@@ -748,6 +813,7 @@ export function DatabaseView({
   renderMode = "page",
   canEdit = true,
   isActive,
+  viewId,
   onExportContextChange,
 }: DatabaseViewProps) {
   const { data: document } = useDocument(databaseDocumentId);
@@ -764,6 +830,7 @@ export function DatabaseView({
       renderMode={renderMode}
       canEdit={effectiveCanEdit}
       isActive={isActive ?? renderMode === "page"}
+      viewId={viewId}
       onExportContextChange={onExportContextChange}
     />
   );
@@ -777,6 +844,7 @@ function DatabaseTable({
   renderMode,
   canEdit,
   isActive,
+  viewId,
   onExportContextChange,
 }: {
   document: Document;
@@ -786,6 +854,7 @@ function DatabaseTable({
   renderMode: "page" | "inline";
   canEdit: boolean;
   isActive: boolean;
+  viewId?: string | null;
   onExportContextChange?: (context: DatabaseExportContext | null) => void;
 }) {
   const t = useT();
@@ -878,8 +947,10 @@ function DatabaseTable({
     renderMode,
   );
   const serializedSearchParams = searchParams.toString();
-  const requestedViewId =
-    searchParams.get(viewSelectionSearchParam)?.trim() || null;
+  const requestedViewId = requestedDatabaseViewId(
+    viewId,
+    searchParams.get(viewSelectionSearchParam),
+  );
   const personalViewDatabaseId = data?.database.id ?? null;
   const newDatabaseRowLabel = isWorkspaceCatalog
     ? t("sidebar.addWorkspace")
@@ -954,6 +1025,7 @@ function DatabaseTable({
   >(null);
   const [searchOpen, setSearchOpen] = useState(false);
   const [settingsOpen, setSettingsOpen] = useState(false);
+  const settingsTriggerRef = useRef<HTMLButtonElement | null>(null);
   const [preserveSourceNavigationOnClose, setPreserveSourceNavigationOnClose] =
     useState(false);
   const sourceHandoffActiveRef = useRef(false);
@@ -1068,6 +1140,9 @@ function DatabaseTable({
   const submittedViewRef = useRef<{ databaseId: string; key: string } | null>(
     null,
   );
+  const viewSetupRevisionRef = useRef<DatabaseViewSetupRevision | null>(null);
+  const databaseViewSaveDataRef = useRef(data);
+  databaseViewSaveDataRef.current = data;
 
   const [dateViewMonth, setDateViewMonth] = useState(() =>
     startOfMonth(new Date()),
@@ -1102,6 +1177,7 @@ function DatabaseTable({
   );
   const hydratedViewRef = useRef("");
   const hydratedDatabaseIdRef = useRef<string | null>(null);
+  const viewSaveQueueRef = useRef(createDatabaseViewSaveQueue());
   const saveViewTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const personalViewSaveTimerRef = useRef<ReturnType<typeof setTimeout> | null>(
     null,
@@ -1985,17 +2061,46 @@ function DatabaseTable({
     });
   }
 
+  const saveSharedDatabaseView = useCallback(
+    async (
+      expectedDatabaseId: string,
+      nextViewConfig: ContentDatabaseViewConfig,
+    ) => {
+      const request = contentDatabaseViewSaveRequest({
+        data: databaseViewSaveDataRef.current,
+        databaseId: expectedDatabaseId,
+        revision: viewSetupRevisionRef.current,
+        idempotencyKey: crypto.randomUUID(),
+        viewConfig: nextViewConfig,
+      });
+      const response = await updateView.mutateAsync(request);
+      if (
+        "receipt" in response &&
+        viewPersistenceRef.current.databaseId === expectedDatabaseId
+      ) {
+        const revision = viewSetupRevisionRef.current;
+        if (revision?.databaseId === expectedDatabaseId) {
+          viewSetupRevisionRef.current = {
+            ...revision,
+            schemaRevision: response.receipt.revisions.schemaAfter,
+            configurationRevision:
+              response.receipt.revisions.configurationAfter,
+          };
+        }
+      }
+      return contentDatabaseViewSaveValue(response);
+    },
+    [updateView.mutateAsync],
+  );
+
   async function savePersonalQueryForEveryone() {
     if (!databaseId) return;
-
     try {
-      const response = await updateView.mutateAsync({
-        databaseId,
-        viewConfig,
+      const response = await viewSaveQueueRef.current(async () => {
+        return saveSharedDatabaseView(databaseId, viewConfig);
       });
-      const nextViewConfig = normalizeClientDatabaseViewConfig(
-        response.database.viewConfig,
-      );
+      if (viewPersistenceRef.current.databaseId !== databaseId) return;
+      const nextViewConfig = normalizeClientDatabaseViewConfig(response);
       if (personalViewSaveTimerRef.current) {
         clearTimeout(personalViewSaveTimerRef.current);
         personalViewSaveTimerRef.current = null;
@@ -2592,6 +2697,19 @@ function DatabaseTable({
       data.database.id,
       reconciled.viewConfig,
     );
+    const mutationContract = data.mutationContract;
+    if (mutationContract && data.configurationRevision) {
+      const { authorityScope: _authorityScope, ...target } =
+        mutationContract.target;
+      viewSetupRevisionRef.current = {
+        databaseId: data.database.id,
+        target,
+        schemaRevision: mutationContract.schemaRevision,
+        configurationRevision: data.configurationRevision,
+      };
+    } else {
+      viewSetupRevisionRef.current = null;
+    }
     if (hydratedViewRef.current === nextKey) return;
     hydratedViewRef.current = nextKey;
     setSavedViewConfig(reconciled.savedViewConfig);
@@ -2609,6 +2727,8 @@ function DatabaseTable({
   }, [
     data?.database.id,
     data?.database.viewConfig,
+    data?.configurationRevision,
+    data?.mutationContract,
     personalView.data?.overrides,
     personalView.isLoading,
     requestedViewId,
@@ -2644,14 +2764,11 @@ function DatabaseTable({
     }
     saveViewTimerRef.current = setTimeout(() => {
       submittedViewRef.current = { databaseId, key: nextKey };
-      void updateView
-        .mutateAsync({ databaseId, viewConfig: sharedViewConfig })
-        .then(
+      void viewSaveQueueRef.current(async () => {
+        return saveSharedDatabaseView(databaseId, sharedViewConfig).then(
           (response) => {
             if (viewPersistenceRef.current.databaseId !== databaseId) return;
-            const nextViewConfig = normalizeClientDatabaseViewConfig(
-              response.database.viewConfig,
-            );
+            const nextViewConfig = normalizeClientDatabaseViewConfig(response);
             viewPersistenceRef.current.savedViewConfig = nextViewConfig;
             setSavedViewConfig(nextViewConfig);
             if (
@@ -2683,6 +2800,7 @@ function DatabaseTable({
             });
           },
         );
+      });
     }, 350);
     return () => {
       if (saveViewTimerRef.current) {
@@ -2694,8 +2812,8 @@ function DatabaseTable({
     databaseId,
     personalQueryDirty,
     personalView.data?.overrides,
+    saveSharedDatabaseView,
     savedViewConfig,
-    updateView.mutateAsync,
     viewConfig,
   ]);
 
@@ -2848,6 +2966,7 @@ function DatabaseTable({
             </Tooltip>
           ) : null}
           <Button
+            ref={settingsTriggerRef}
             type="button"
             variant="ghost"
             size="sm"
@@ -3351,6 +3470,7 @@ function DatabaseTable({
       />
 
       <DatabaseSettingsPanelSheet
+        triggerRef={settingsTriggerRef}
         open={settingsOpen}
         panel={settingsPanel}
         databaseId={databaseId}
@@ -7348,6 +7468,7 @@ function NotionLogoMark({ className }: { className?: string }) {
 
 function DatabaseSettingsPanelSheet({
   open,
+  triggerRef,
   panel,
   databaseId,
   documentId,
@@ -7386,6 +7507,7 @@ function DatabaseSettingsPanelSheet({
   onGroupsCollapsedChange,
 }: {
   open: boolean;
+  triggerRef: { current: HTMLButtonElement | null };
   panel: DatabaseSettingsPanel;
   databaseId: string;
   documentId: string;
@@ -7479,8 +7601,6 @@ function DatabaseSettingsPanelSheet({
     }
   }, [open, panel, preserveSourceNavigationOnClose]);
 
-  if (!open) return null;
-
   const title =
     panel === "main"
       ? "Database settings"
@@ -7497,107 +7617,135 @@ function DatabaseSettingsPanelSheet({
   };
 
   return (
-    <aside
-      className="fixed bottom-0 right-0 top-12 z-40 flex w-[320px] max-w-[calc(100vw-1rem)] flex-col border-l border-border bg-background shadow-[-12px_0_32px_rgba(15,23,42,0.06)]"
-      onClick={(event) => event.stopPropagation()}
-      onPointerDown={(event) => event.stopPropagation()}
+    <Sheet
+      open={open}
+      onOpenChange={(nextOpen) => {
+        if (!nextOpen) onClose();
+      }}
+      modal={false}
     >
-      <div className="flex h-11 shrink-0 items-center gap-2 border-b border-border/70 px-3">
-        {panel === "main" ? null : (
+      <SheetContent
+        side="right"
+        showOverlay={false}
+        showClose={false}
+        aria-describedby={undefined}
+        className="bottom-0 top-12 z-40 flex h-auto w-[320px] max-w-[calc(100vw-1rem)] flex-col gap-0 p-0 sm:max-w-[calc(100vw-1rem)]"
+        onInteractOutside={(event) => event.preventDefault()}
+        onCloseAutoFocus={(event) => {
+          event.preventDefault();
+          const activeElement = window.document.activeElement;
+          if (
+            activeElement instanceof HTMLElement &&
+            activeElement !== window.document.body &&
+            event.target instanceof HTMLElement &&
+            !event.target.contains(activeElement)
+          ) {
+            return;
+          }
+          triggerRef.current?.focus();
+        }}
+        onClick={(event) => event.stopPropagation()}
+        onPointerDown={(event) => event.stopPropagation()}
+      >
+        <div className="flex h-11 shrink-0 items-center gap-2 border-b border-border/70 px-3">
+          {panel === "main" ? null : (
+            <button
+              type="button"
+              aria-label="Back"
+              className="flex size-7 items-center justify-center rounded text-muted-foreground hover:bg-muted hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+              onClick={handleBack}
+            >
+              <IconArrowLeft className="size-4" />
+            </button>
+          )}
+          <SheetTitle className="min-w-0 flex-1 truncate text-sm font-semibold">
+            {title}
+          </SheetTitle>
           <button
             type="button"
-            aria-label="Back"
+            aria-label={dbText("closeDatabaseSettings")}
             className="flex size-7 items-center justify-center rounded text-muted-foreground hover:bg-muted hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
-            onClick={handleBack}
+            onClick={onClose}
           >
-            <IconArrowLeft className="size-4" />
+            <IconX className="size-4" />
           </button>
-        )}
-        <div className="min-w-0 flex-1 truncate text-sm font-semibold">
-          {title}
         </div>
-        <button
-          type="button"
-          aria-label={dbText("closeDatabaseSettings")}
-          className="flex size-7 items-center justify-center rounded text-muted-foreground hover:bg-muted hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
-          onClick={onClose}
-        >
-          <IconX className="size-4" />
-        </button>
-      </div>
-      <div className="min-h-0 flex-1 overflow-x-hidden overflow-y-auto p-3">
-        {panel === "main" ? (
-          <DatabaseSettingsMainPanel
-            activeView={activeView}
-            source={source}
-            sourceCount={sources.length || (source ? 1 : 0)}
-            propertyCount={properties.length}
-            hiddenCount={hiddenCount}
-            onPanelChange={onPanelChange}
-          />
-        ) : panel === "source" ? (
-          <DatabaseSettingsSourcePanel
-            source={source}
-            sources={sources}
-            databaseId={databaseId}
-            documentId={documentId}
-            isFilesDatabase={isFilesDatabase}
-            itemCount={items.length}
-            canEdit={canEdit}
-            canManage={canManage}
-            nav={sourceNavStack}
-            onNavPush={(step) => setSourceNavStack((stack) => [...stack, step])}
-            onNavReplace={setSourceNavStack}
-            onAttachBuilderSource={onAttachBuilderSource}
-            onFederateSource={onFederateSource}
-            onChangeSourceRole={onChangeSourceRole}
-            onDisconnectSecondary={(sourceId) => {
-              onDisconnectSecondary(sourceId);
-              setSourceNavStack([]);
-            }}
-            onRefreshSource={onRefreshSource}
-            onHydrateBuilderBodies={onHydrateBuilderBodies}
-            onDisconnectSource={onDisconnectSource}
-            onReviewBuilderUpdate={onReviewBuilderUpdate}
-            onSetBuilderLiveWrites={onSetBuilderLiveWrites}
-            sourceActionPending={sourceActionPending}
-            builderAttachPreviewPending={builderAttachPreview.isFetching}
-            sourcePendingOperations={sourcePendingOperations}
-          />
-        ) : panel === "layout" ? (
-          <DatabaseSettingsLayoutPanel
-            activeView={activeView}
-            properties={properties}
-            onViewTypeChange={onViewTypeChange}
-            onWrapCellsChange={onWrapCellsChange}
-            onOpenPagesInChange={onOpenPagesInChange}
-            onFormQuestionsChange={onFormQuestionsChange}
-          />
-        ) : panel === "property_visibility" ? (
-          <DatabaseSettingsPropertyVisibilityPanel
-            documentId={documentId}
-            databaseId={databaseId}
-            properties={properties}
-            activeView={activeView}
-            items={items}
-            source={source}
-            sources={sources}
-            hiddenCount={hiddenCount}
-            onPropertyHiddenChange={onPropertyHiddenChange}
-            onPropertiesHiddenChange={onPropertiesHiddenChange}
-          />
-        ) : panel === "group" ? (
-          <DatabaseSettingsGroupPanel
-            activeView={activeView}
-            properties={properties}
-            groupIds={groupIds}
-            onGroupByChange={onGroupByChange}
-            onHideEmptyGroupsChange={onHideEmptyGroupsChange}
-            onGroupsCollapsedChange={onGroupsCollapsedChange}
-          />
-        ) : null}
-      </div>
-    </aside>
+        <div className="min-h-0 flex-1 overflow-x-hidden overflow-y-auto p-3">
+          {panel === "main" ? (
+            <DatabaseSettingsMainPanel
+              activeView={activeView}
+              source={source}
+              sourceCount={sources.length || (source ? 1 : 0)}
+              propertyCount={properties.length}
+              hiddenCount={hiddenCount}
+              onPanelChange={onPanelChange}
+            />
+          ) : panel === "source" ? (
+            <DatabaseSettingsSourcePanel
+              source={source}
+              sources={sources}
+              databaseId={databaseId}
+              documentId={documentId}
+              isFilesDatabase={isFilesDatabase}
+              itemCount={items.length}
+              canEdit={canEdit}
+              canManage={canManage}
+              nav={sourceNavStack}
+              onNavPush={(step) =>
+                setSourceNavStack((stack) => [...stack, step])
+              }
+              onNavReplace={setSourceNavStack}
+              onAttachBuilderSource={onAttachBuilderSource}
+              onFederateSource={onFederateSource}
+              onChangeSourceRole={onChangeSourceRole}
+              onDisconnectSecondary={(sourceId) => {
+                onDisconnectSecondary(sourceId);
+                setSourceNavStack([]);
+              }}
+              onRefreshSource={onRefreshSource}
+              onHydrateBuilderBodies={onHydrateBuilderBodies}
+              onDisconnectSource={onDisconnectSource}
+              onReviewBuilderUpdate={onReviewBuilderUpdate}
+              onSetBuilderLiveWrites={onSetBuilderLiveWrites}
+              sourceActionPending={sourceActionPending}
+              builderAttachPreviewPending={builderAttachPreview.isFetching}
+              sourcePendingOperations={sourcePendingOperations}
+            />
+          ) : panel === "layout" ? (
+            <DatabaseSettingsLayoutPanel
+              activeView={activeView}
+              properties={properties}
+              onViewTypeChange={onViewTypeChange}
+              onWrapCellsChange={onWrapCellsChange}
+              onOpenPagesInChange={onOpenPagesInChange}
+              onFormQuestionsChange={onFormQuestionsChange}
+            />
+          ) : panel === "property_visibility" ? (
+            <DatabaseSettingsPropertyVisibilityPanel
+              documentId={documentId}
+              databaseId={databaseId}
+              properties={properties}
+              activeView={activeView}
+              items={items}
+              source={source}
+              sources={sources}
+              hiddenCount={hiddenCount}
+              onPropertyHiddenChange={onPropertyHiddenChange}
+              onPropertiesHiddenChange={onPropertiesHiddenChange}
+            />
+          ) : panel === "group" ? (
+            <DatabaseSettingsGroupPanel
+              activeView={activeView}
+              properties={properties}
+              groupIds={groupIds}
+              onGroupByChange={onGroupByChange}
+              onHideEmptyGroupsChange={onHideEmptyGroupsChange}
+              onGroupsCollapsedChange={onGroupsCollapsedChange}
+            />
+          ) : null}
+        </div>
+      </SheetContent>
+    </Sheet>
   );
 }
 
@@ -13310,6 +13458,13 @@ export function selectDatabaseView(
 
 export const DATABASE_VIEW_SELECTION_SEARCH_PARAM = "databaseViewId";
 
+export function requestedDatabaseViewId(
+  explicitViewId: string | null | undefined,
+  savedSelection: string | null | undefined,
+) {
+  return explicitViewId?.trim() || savedSelection?.trim() || null;
+}
+
 export function databaseViewSelectionSearchParam(
   databaseId: string,
   renderMode: "page" | "inline",
diff --git a/templates/content/app/components/sidebar/DocumentSidebar.tsx b/templates/content/app/components/sidebar/DocumentSidebar.tsx
index 3023078f160..e01f25081a4 100644
--- a/templates/content/app/components/sidebar/DocumentSidebar.tsx
+++ b/templates/content/app/components/sidebar/DocumentSidebar.tsx
@@ -74,6 +74,7 @@ import {
 } from "@/components/ui/tooltip";
 import {
   applyOptimisticItemToContentDatabase,
+  contentDatabaseCreationRequest,
   contentDatabaseByIdQueryKey,
   isContentDatabaseUnavailable,
   removeOptimisticItemFromContentDatabase,
@@ -1540,12 +1541,23 @@ export function DocumentSidebar({
       onNavigate?.();
 
       try {
-        const result = await createDatabase.mutateAsync({
-          newDocumentId: id,
-          parentId: parentId ?? null,
-          spaceId: parentId ? undefined : rootSpaceId,
-          title,
-        });
+        const parentFilesDocumentId = parentId
+          ? documents.find((document) => document.id === parentId)
+              ?.databaseMembership?.databaseDocumentId
+          : undefined;
+        const spaceId = parentFilesDocumentId
+          ? contentSpaces.find(
+              (space) => space.filesDocumentId === parentFilesDocumentId,
+            )?.id
+          : rootSpaceId;
+        const result = await createDatabase.mutateAsync(
+          contentDatabaseCreationRequest({
+            newDocumentId: id,
+            parentId: parentId ?? null,
+            spaceId,
+            title,
+          }),
+        );
         const nextId = result.database.documentId;
         if (nextId !== id) {
           queryClient.removeQueries(documentQueryFilter(id));
@@ -1577,6 +1589,7 @@ export function DocumentSidebar({
     },
     [
       createDatabase,
+      contentSpaces,
       documents,
       location.hash,
       location.pathname,
diff --git a/templates/content/app/hooks/content-action-refresh.ts b/templates/content/app/hooks/content-action-refresh.ts
index ce653ff83d3..275e68ba0c6 100644
--- a/templates/content/app/hooks/content-action-refresh.ts
+++ b/templates/content/app/hooks/content-action-refresh.ts
@@ -81,6 +81,18 @@ const DATABASE_PRESENTATION_MUTATIONS = new Set([
   "update-content-database-personal-view",
 ]);
 
+const DATABASE_LIFECYCLE_MUTATIONS = new Set([
+  "delete-content-database",
+  "restore-content-database",
+]);
+
+const DATABASE_LIFECYCLE_QUERIES = new Set([
+  "list-content-databases",
+  "list-documents",
+  "list-trashed-content-databases",
+  "list-trashed-documents",
+]);
+
 const CONTENT_MUTATIONS = new Set([
   ...COMMENT_MUTATIONS,
   ...DOCUMENT_MUTATIONS,
@@ -135,6 +147,14 @@ function queryTargetsActiveDatabasePresentation(query: ActionQuery): boolean {
   );
 }
 
+function isDatabaseLifecycleQuery(query: ActionQuery): boolean {
+  return (
+    query.queryKey[0] === "action" &&
+    typeof query.queryKey[1] === "string" &&
+    DATABASE_LIFECYCLE_QUERIES.has(query.queryKey[1])
+  );
+}
+
 export function contentDocumentIdFromPathname(
   pathname: string,
 ): string | undefined {
@@ -156,6 +176,18 @@ export function contentActionInvalidatePredicate(
             ? args.documentId
             : undefined
         : undefined;
+    if (
+      (isDatabaseLifecycleQuery(query) ||
+        (isDatabaseQuery(query) && query.isActive?.() === true)) &&
+      events.some(
+        (event) =>
+          event.source === "action" &&
+          typeof event.key === "string" &&
+          DATABASE_LIFECYCLE_MUTATIONS.has(event.key),
+      )
+    ) {
+      return true;
+    }
     if (documentId === undefined) {
       return false;
     }
diff --git a/templates/content/app/hooks/use-content-database-view-mutation.test.ts b/templates/content/app/hooks/use-content-database-view-mutation.test.ts
index fe2709f28e5..44c5eb319ff 100644
--- a/templates/content/app/hooks/use-content-database-view-mutation.test.ts
+++ b/templates/content/app/hooks/use-content-database-view-mutation.test.ts
@@ -52,21 +52,42 @@ describe("useUpdateContentDatabaseView", () => {
     const options = useActionMutation.mock.calls[0][1];
     const olderContext = await options.onMutate();
     const newerContext = await options.onMutate();
-    const older = { database: { viewConfig: { activeViewId: "older" } } };
-    const newer = { database: { viewConfig: { activeViewId: "newer" } } };
+    const older = {
+      receipt: {
+        revisions: {
+          schemaAfter: "schema-older",
+          configurationAfter: "configuration-older",
+        },
+      },
+      value: { activeViewId: "older" },
+    };
+    const newer = {
+      receipt: {
+        revisions: {
+          schemaAfter: "schema-newer",
+          configurationAfter: "configuration-newer",
+        },
+      },
+      value: { activeViewId: "newer" },
+    };
+    const variables = {
+      target: { databaseId: "database-id" },
+    };
 
-    options.onSuccess(older, {}, olderContext);
-    options.onSettled(older, undefined, {}, olderContext);
+    options.onSuccess(older, variables, olderContext);
+    options.onSettled(older, undefined, variables, olderContext);
     expect(queryClient.setQueriesData).not.toHaveBeenCalled();
     expect(queryClient.invalidateQueries).not.toHaveBeenCalled();
 
-    options.onSuccess(newer, {}, newerContext);
+    options.onSuccess(newer, variables, newerContext);
     expect(queryClient.cancelQueries).toHaveBeenCalledTimes(2);
     expect(queryClient.setQueriesData).toHaveBeenCalledTimes(1);
 
     const [filter, updater] = queryClient.setQueriesData.mock.calls[0];
     const current = {
       database: { viewConfig: { activeViewId: "current" } },
+      configurationRevision: "configuration-current",
+      mutationContract: { schemaRevision: "schema-current" },
       items: [{ id: "row-1" }],
       properties: [{ definition: { id: "status" } }],
     };
@@ -78,10 +99,87 @@ describe("useUpdateContentDatabaseView", () => {
     );
     expect(updater(current)).toEqual({
       ...current,
-      database: newer.database,
+      configurationRevision: "configuration-newer",
+      mutationContract: { schemaRevision: "schema-newer" },
+      database: {
+        ...current.database,
+        viewConfig: newer.value,
+      },
     });
 
-    options.onSettled(newer, undefined, {}, newerContext);
-    expect(queryClient.invalidateQueries).toHaveBeenCalledTimes(1);
+    options.onSettled(newer, undefined, variables, newerContext);
+    expect(queryClient.invalidateQueries).toHaveBeenCalledTimes(2);
+    expect(queryClient.invalidateQueries).toHaveBeenLastCalledWith({
+      queryKey: [
+        "action",
+        "get-content-database",
+        { databaseId: "database-id" },
+      ],
+    });
+  });
+
+  it("writes a legacy canonical response to both caches and invalidates its database id", async () => {
+    const queryClient = {
+      cancelQueries: vi.fn(),
+      setQueryData: vi.fn(),
+      setQueriesData: vi.fn(),
+      invalidateQueries: vi.fn(),
+    };
+    useQueryClient.mockReturnValue(queryClient);
+    useActionMutation.mockImplementation((_name, options) => options);
+
+    useUpdateContentDatabaseView("database-page");
+    const options = useActionMutation.mock.calls[0][1];
+    const context = await options.onMutate();
+    const legacyResponse = {
+      database: {
+        id: "legacy-database",
+        documentId: "database-page",
+        title: "Legacy database",
+        systemRole: "files",
+        viewConfig: {
+          activeViewId: "calendar",
+          views: [
+            {
+              id: "calendar",
+              name: "Calendar",
+              type: "calendar",
+              datePropertyId: "publish-date",
+            },
+          ],
+        },
+        createdAt: "2026-09-09T00:00:00.000Z",
+        updatedAt: "2026-09-09T00:00:01.000Z",
+      },
+      properties: [],
+      items: [],
+      source: null,
+      sources: [],
+    };
+    const variables = {
+      databaseId: "legacy-database",
+      viewConfig: legacyResponse.database.viewConfig,
+    };
+
+    options.onSuccess(legacyResponse, variables, context);
+    expect(queryClient.setQueriesData).toHaveBeenCalledWith(
+      expect.objectContaining({
+        queryKey: ["action", "get-content-database"],
+      }),
+      legacyResponse,
+    );
+    expect(queryClient.setQueryData).toHaveBeenCalledWith(
+      ["action", "get-content-database", { databaseId: "legacy-database" }],
+      legacyResponse,
+    );
+
+    options.onSettled(legacyResponse, undefined, variables, context);
+    expect(queryClient.invalidateQueries).toHaveBeenLastCalledWith({
+      queryKey: [
+        "action",
+        "get-content-database",
+        { databaseId: "legacy-database" },
+      ],
+    });
   });
 });
diff --git a/templates/content/app/hooks/use-content-database.test.ts b/templates/content/app/hooks/use-content-database.test.ts
index 1c18ec12527..1f686bba46e 100644
--- a/templates/content/app/hooks/use-content-database.test.ts
+++ b/templates/content/app/hooks/use-content-database.test.ts
@@ -14,6 +14,7 @@ import {
   applyOptimisticSourceFieldPropertyToDatabaseResponse,
   applySourceFieldPropertyToDatabaseResponse,
   clearDeletedContentDatabaseFromCache,
+  contentDatabaseCreationRequest,
   contentDatabaseResponseCanSeedQuery,
   contentDatabaseItemsPageQueryKey,
   contentDatabaseConstrainedQueryFilter,
@@ -33,6 +34,49 @@ import {
 
 const createdAt = "2026-06-15T12:00:00.000Z";
 
+describe("contentDatabaseCreationRequest", () => {
+  it("uses the optimistic document id as the stable intent for an exact space", () => {
+    expect(
+      contentDatabaseCreationRequest({
+        newDocumentId: "database-page",
+        spaceId: "personal-space",
+        title: "Launches",
+      }),
+    ).toEqual({
+      newDocumentId: "database-page",
+      idempotencyKey: "database-page",
+      parentId: null,
+      spaceId: "personal-space",
+      title: "Launches",
+    });
+  });
+
+  it("preserves the exact space, parent, and title for a nested database", () => {
+    expect(
+      contentDatabaseCreationRequest({
+        newDocumentId: "nested-database",
+        parentId: "parent-page",
+        spaceId: "organization-space",
+        title: "Projects",
+      }),
+    ).toMatchObject({
+      parentId: "parent-page",
+      spaceId: "organization-space",
+      title: "Projects",
+    });
+  });
+
+  it("rejects creation when the exact space is unavailable", () => {
+    expect(() =>
+      contentDatabaseCreationRequest({
+        newDocumentId: "database-page",
+        spaceId: undefined,
+        title: "Launches",
+      }),
+    ).toThrow("Choose a Content space before creating a database");
+  });
+});
+
 describe("complete Content database discovery", () => {
   it("exhausts every bounded page before returning source-picker options", async () => {
     const databases = Array.from({ length: 101 }, (_, index) => ({
diff --git a/templates/content/app/hooks/use-content-database.ts b/templates/content/app/hooks/use-content-database.ts
index 67ae4e992aa..85f4c9c4ca1 100644
--- a/templates/content/app/hooks/use-content-database.ts
+++ b/templates/content/app/hooks/use-content-database.ts
@@ -53,7 +53,6 @@ import type {
   SubmitContentDatabaseFormResponse,
   SuggestSourceJoinKeyResponse,
   UpdateContentDatabasePersonalViewRequest,
-  UpdateContentDatabaseViewRequest,
   ValidateBuilderSourceExecutionRequest,
 } from "@shared/api";
 import type { Query, QueryClient } from "@tanstack/react-query";
@@ -781,6 +780,25 @@ export function useCreateContentDatabase(
   );
 }
 
+export function contentDatabaseCreationRequest(args: {
+  newDocumentId: string;
+  parentId?: string | null;
+  spaceId: string | undefined;
+  title: string;
+}): CreateDatabaseRequest {
+  const parentId = args.parentId ?? null;
+  if (!args.spaceId) {
+    throw new Error("Choose a Content space before creating a database");
+  }
+  return {
+    newDocumentId: args.newDocumentId,
+    idempotencyKey: args.newDocumentId,
+    parentId,
+    spaceId: args.spaceId,
+    title: args.title,
+  };
+}
+
 export function useCreateInlineContentDatabase(hostDocumentId: string | null) {
   const queryClient = useQueryClient();
   return useActionMutation<
@@ -1056,13 +1074,43 @@ export function useMoveDatabaseItem(documentId: string) {
   );
 }
 
+export type ContentDatabaseViewSaveResponse =
+  | ContentDatabaseResponse
+  | {
+      receipt: {
+        revisions: {
+          schemaAfter: string;
+          configurationAfter: string;
+        };
+      };
+      value: ContentDatabaseResponse["database"]["viewConfig"];
+    };
+
+export type ContentDatabaseViewSaveRequest =
+  | {
+      operation: "replace";
+      target: {
+        spaceId: string;
+        databaseId: string;
+        databaseDocumentId: string;
+      };
+      expectedSchemaRevision: string;
+      expectedConfigurationRevision: string;
+      idempotencyKey: string;
+      viewConfig: ContentDatabaseResponse["database"]["viewConfig"];
+    }
+  | {
+      databaseId: string;
+      viewConfig: ContentDatabaseResponse["database"]["viewConfig"];
+    };
+
 export function useUpdateContentDatabaseView(documentId: string) {
   const queryClient = useQueryClient();
   const mutationSequences =
     contentDatabaseViewMutationSequencesFor(queryClient);
   return useActionMutation<
-    ContentDatabaseResponse,
-    UpdateContentDatabaseViewRequest
+    ContentDatabaseViewSaveResponse,
+    ContentDatabaseViewSaveRequest
   >("update-content-database-view", {
     skipActionQueryInvalidation: true,
     scope: { id: `content-database-view:${documentId}` },
@@ -1072,25 +1120,44 @@ export function useUpdateContentDatabaseView(documentId: string) {
       await queryClient.cancelQueries(contentDatabaseQueryFilter(documentId));
       return { sequence };
     },
-    onSuccess: (data, _variables, context) => {
+    onSuccess: (data, variables, context) => {
       if (
         (context as { sequence?: number } | undefined)?.sequence !==
         mutationSequences.get(documentId)
       ) {
         return;
       }
+      if (!("receipt" in data)) {
+        writeContentDatabaseResponseToCache(queryClient, documentId, data);
+        queryClient.setQueryData(
+          contentDatabaseByIdQueryKey(data.database.id),
+          data,
+        );
+        return;
+      }
       queryClient.setQueriesData<ContentDatabaseResponse>(
         contentDatabaseQueryFilter(documentId),
         (current) =>
           current
             ? {
                 ...current,
-                database: data.database,
+                configurationRevision:
+                  data.receipt.revisions.configurationAfter,
+                mutationContract: current.mutationContract
+                  ? {
+                      ...current.mutationContract,
+                      schemaRevision: data.receipt.revisions.schemaAfter,
+                    }
+                  : current.mutationContract,
+                database: {
+                  ...current.database,
+                  viewConfig: data.value,
+                },
               }
             : current,
       );
     },
-    onSettled: (_data, _error, _variables, context) => {
+    onSettled: (_data, _error, variables, context) => {
       if (
         (context as { sequence?: number } | undefined)?.sequence !==
         mutationSequences.get(documentId)
@@ -1100,6 +1167,13 @@ export function useUpdateContentDatabaseView(documentId: string) {
       void queryClient.invalidateQueries(
         contentDatabaseQueryFilter(documentId),
       );
+      const databaseId =
+        "target" in variables
+          ? variables.target.databaseId
+          : variables.databaseId;
+      void queryClient.invalidateQueries({
+        queryKey: contentDatabaseByIdQueryKey(databaseId),
+      });
     },
   });
 }
diff --git a/templates/content/app/hooks/use-db-sync.spec.ts b/templates/content/app/hooks/use-db-sync.spec.ts
index fd2861992de..ab607c420c0 100644
--- a/templates/content/app/hooks/use-db-sync.spec.ts
+++ b/templates/content/app/hooks/use-db-sync.spec.ts
@@ -208,6 +208,65 @@ describe("contentActionInvalidatePredicate", () => {
     ).toBe(true);
   });
 
+  it.each(["/page/database-page", "/home", "/trash"])(
+    "refreshes document and Trash lists after external database lifecycle changes on %s",
+    (pathname) => {
+      const predicate = contentActionInvalidatePredicate(pathname);
+
+      for (const queryName of [
+        "list-content-databases",
+        "list-documents",
+        "list-trashed-content-databases",
+        "list-trashed-documents",
+      ]) {
+        const query = { queryKey: ["action", queryName, {}] };
+        expect(
+          predicate(query, [
+            { source: "action", key: "delete-content-database" },
+          ]),
+        ).toBe(true);
+        expect(
+          predicate(query, [
+            { source: "action", key: "restore-content-database" },
+          ]),
+        ).toBe(true);
+        expect(
+          predicate(query, [{ source: "action", key: "update-document" }]),
+        ).toBe(false);
+      }
+    },
+  );
+
+  it.each(["/home", "/settings", "/trash"])(
+    "refreshes active sidebar database reads after lifecycle changes on %s",
+    (pathname) => {
+      const predicate = contentActionInvalidatePredicate(pathname);
+      for (const queryName of [
+        "get-content-database",
+        "query-content-database-items",
+      ]) {
+        const query = {
+          queryKey: ["action", queryName, { databaseId: "files" }],
+          isActive: () => true,
+        };
+        for (const key of [
+          "delete-content-database",
+          "restore-content-database",
+        ]) {
+          expect(predicate(query, [{ source: "action", key }])).toBe(true);
+          expect(
+            predicate({ ...query, isActive: () => false }, [
+              { source: "action", key },
+            ]),
+          ).toBe(false);
+        }
+        expect(
+          predicate(query, [{ source: "action", key: "update-document" }]),
+        ).toBe(false);
+      }
+    },
+  );
+
   it("refreshes only the active personal-view query for personal presentation writes", () => {
     const predicate = contentActionInvalidatePredicate("/page/database-page");
     const personalViewQuery = {
diff --git a/templates/content/app/hooks/use-document-properties.test.ts b/templates/content/app/hooks/use-document-properties.test.ts
index c124fc88cb2..1db60db4add 100644
--- a/templates/content/app/hooks/use-document-properties.test.ts
+++ b/templates/content/app/hooks/use-document-properties.test.ts
@@ -22,6 +22,7 @@ vi.mock("sonner", () => ({
 
 import {
   documentPropertiesResponseMatchesScope,
+  useConfigureDocumentProperty,
   useSetDocumentProperty,
   useUpdateDatabaseItems,
 } from "./use-document-properties";
@@ -122,6 +123,355 @@ describe("useUpdateDatabaseItems", () => {
   });
 });
 
+describe("useConfigureDocumentProperty", () => {
+  beforeEach(() => {
+    useActionMutation.mockReset();
+    useActionQuery.mockReset();
+    useQueryClient.mockReset();
+  });
+
+  it("adapts a rendered ordinary option edit to the guarded setup contract", async () => {
+    const transportMutateAsync = vi.fn(async () => undefined);
+    const queryClient = {
+      getQueriesData: vi.fn(() => [
+        [
+          ["action", "get-content-database"],
+          {
+            database: { id: "database-1" },
+            mutationContract: {
+              target: {
+                authorityScope: { kind: "personal", id: "owner@test.dev" },
+                spaceId: "space-1",
+                databaseId: "database-1",
+                databaseDocumentId: "database-page-1",
+              },
+              schemaRevision: "schema-rendered",
+            },
+            properties: [
+              {
+                definition: {
+                  id: "status",
+                  databaseId: "database-1",
+                  name: "Status",
+                  description: "",
+                  type: "status",
+                  visibility: "always_show",
+                  systemRole: null,
+                  options: {
+                    options: [{ id: "draft", name: "Draft", color: "gray" }],
+                  },
+                },
+                value: null,
+                editable: true,
+              },
+            ],
+          },
+        ],
+      ]),
+      setQueriesData: vi.fn(),
+      invalidateQueries: vi.fn(),
+    };
+    useQueryClient.mockReturnValue(queryClient);
+    useActionMutation.mockReturnValue({
+      mutate: vi.fn(),
+      mutateAsync: transportMutateAsync,
+    });
+
+    const configure = useConfigureDocumentProperty(
+      "database-page-1",
+      "database-1",
+    );
+    await configure.mutateAsync({
+      id: "status",
+      documentId: "database-page-1",
+      name: "Workflow",
+      type: "status",
+      visibility: "always_show",
+      options: {
+        options: [
+          { id: "draft", name: "Drafting", color: "blue" },
+          { id: "ready", name: "Ready", color: "green" },
+        ],
+      },
+    });
+
+    expect(transportMutateAsync).toHaveBeenCalledWith(
+      {
+        operation: "update",
+        target: {
+          spaceId: "space-1",
+          databaseId: "database-1",
+          databaseDocumentId: "database-page-1",
+        },
+        expectedSchemaRevision: "schema-rendered",
+        idempotencyKey: expect.any(String),
+        propertyId: "status",
+        patch: {
+          name: "Workflow",
+          optionEdits: [
+            {
+              operation: "update",
+              optionId: "draft",
+              patch: { name: "Drafting", color: "blue" },
+            },
+            {
+              operation: "add",
+              option: { id: "ready", name: "Ready", color: "green" },
+            },
+            {
+              operation: "reorder",
+              optionIds: ["draft", "ready"],
+            },
+          ],
+        },
+      },
+      undefined,
+    );
+  });
+
+  it("uses the synchronous receipt cache for a second metadata edit before rerender", async () => {
+    const queryClient = new QueryClient();
+    useQueryClient.mockReturnValue(queryClient);
+    const key = [
+      "action",
+      "get-content-database",
+      { documentId: "database-page-1" },
+    ];
+    const definition = {
+      id: "text-1",
+      databaseId: "database-1",
+      name: "Name",
+      description: "",
+      type: "text",
+      visibility: "always_show",
+      systemRole: null,
+      options: null,
+    };
+    queryClient.setQueryData(key, {
+      database: { id: "database-1" },
+      mutationContract: {
+        target: {
+          spaceId: "space-1",
+          databaseId: "database-1",
+          databaseDocumentId: "database-page-1",
+        },
+        schemaRevision: "S0",
+      },
+      configurationRevision: "C0",
+      properties: [{ definition, value: null, editable: true }],
+      items: [],
+    });
+    let onSuccess!: (data: unknown) => void;
+    const transport = vi.fn(async (_input: unknown) => {
+      onSuccess({
+        value: { ...definition, name: "Renamed" },
+        receipt: { revisions: { schemaAfter: "S1", configurationAfter: "C1" } },
+      });
+    });
+    useActionMutation.mockImplementation((_name, options) => {
+      onSuccess = options.onSuccess;
+      return { mutateAsync: transport };
+    });
+    const configure = useConfigureDocumentProperty(
+      "database-page-1",
+      "database-1",
+    );
+    await configure.mutateAsync({
+      documentId: "database-page-1",
+      id: "text-1",
+      name: "Renamed",
+      type: "text",
+    });
+    await configure.mutateAsync({
+      documentId: "database-page-1",
+      id: "text-1",
+      name: "Renamed",
+      description: "Details",
+      type: "text",
+    });
+    expect(transport.mock.calls[0][0]).toMatchObject({
+      expectedSchemaRevision: "S0",
+    });
+    expect(transport.mock.calls[1][0]).toMatchObject({
+      expectedSchemaRevision: "S1",
+      patch: { description: "Details" },
+    });
+  });
+
+  it("preserves the legacy request for computed property editing", async () => {
+    const transportMutateAsync = vi.fn(async () => undefined);
+    useQueryClient.mockReturnValue({
+      getQueriesData: vi.fn(() => []),
+      setQueriesData: vi.fn(),
+      invalidateQueries: vi.fn(),
+    });
+    useActionMutation.mockReturnValue({
+      mutate: vi.fn(),
+      mutateAsync: transportMutateAsync,
+    });
+    const configure = useConfigureDocumentProperty(
+      "database-page-1",
+      "database-1",
+    );
+
+    await configure.mutateAsync({
+      id: "formula-1",
+      documentId: "database-page-1",
+      name: "Score",
+      type: "formula",
+      options: { formula: "1 + 1" },
+    });
+
+    expect(transportMutateAsync).toHaveBeenCalledWith(
+      {
+        id: "formula-1",
+        documentId: "database-page-1",
+        databaseId: "database-1",
+        name: "Score",
+        type: "formula",
+        options: { formula: "1 + 1" },
+      },
+      undefined,
+    );
+  });
+
+  it("rejects ordinary option removal without sending a legacy replacement", () => {
+    const transportMutateAsync = vi.fn(async () => undefined);
+    useQueryClient.mockReturnValue({
+      getQueriesData: vi.fn(() => [
+        [
+          ["action", "get-content-database"],
+          {
+            database: { id: "database-1" },
+            mutationContract: {
+              target: {
+                authorityScope: { kind: "personal", id: "owner@test.dev" },
+                spaceId: "space-1",
+                databaseId: "database-1",
+                databaseDocumentId: "database-page-1",
+              },
+              schemaRevision: "schema-rendered",
+            },
+            properties: [
+              {
+                definition: {
+                  id: "status",
+                  databaseId: "database-1",
+                  name: "Status",
+                  description: "",
+                  type: "status",
+                  visibility: "always_show",
+                  systemRole: null,
+                  options: {
+                    options: [
+                      { id: "draft", name: "Draft", color: "gray" },
+                      { id: "ready", name: "Ready", color: "green" },
+                    ],
+                  },
+                },
+                value: null,
+                editable: true,
+              },
+            ],
+          },
+        ],
+      ]),
+      setQueriesData: vi.fn(),
+      invalidateQueries: vi.fn(),
+    });
+    useActionMutation.mockReturnValue({
+      mutate: vi.fn(),
+      mutateAsync: transportMutateAsync,
+    });
+    const configure = useConfigureDocumentProperty(
+      "database-page-1",
+      "database-1",
+    );
+
+    expect(() =>
+      configure.mutateAsync({
+        id: "status",
+        documentId: "database-page-1",
+        name: "Status",
+        type: "status",
+        visibility: "always_show",
+        options: {
+          options: [{ id: "draft", name: "Draft", color: "gray" }],
+        },
+      }),
+    ).toThrow("Removing property options is unavailable");
+    expect(transportMutateAsync).not.toHaveBeenCalled();
+  });
+
+  it("sends an ordinary semantic no-op through schema CAS", async () => {
+    const transportMutateAsync = vi.fn(async () => undefined);
+    useQueryClient.mockReturnValue({
+      getQueriesData: vi.fn(() => [
+        [
+          ["action", "get-content-database"],
+          {
+            database: { id: "database-1" },
+            mutationContract: {
+              target: {
+                authorityScope: { kind: "personal", id: "owner@test.dev" },
+                spaceId: "space-1",
+                databaseId: "database-1",
+                databaseDocumentId: "database-page-1",
+              },
+              schemaRevision: "schema-rendered",
+            },
+            properties: [
+              {
+                definition: {
+                  id: "publish-date",
+                  databaseId: "database-1",
+                  name: "Publish date",
+                  description: "",
+                  type: "date",
+                  visibility: "always_show",
+                  systemRole: null,
+                  options: {},
+                },
+                value: null,
+                editable: true,
+              },
+            ],
+          },
+        ],
+      ]),
+      setQueriesData: vi.fn(),
+      invalidateQueries: vi.fn(),
+    });
+    useActionMutation.mockReturnValue({
+      mutate: vi.fn(),
+      mutateAsync: transportMutateAsync,
+    });
+    const configure = useConfigureDocumentProperty(
+      "database-page-1",
+      "database-1",
+    );
+
+    await configure.mutateAsync({
+      id: "publish-date",
+      documentId: "database-page-1",
+      name: "Publish date",
+      type: "date",
+      visibility: "always_show",
+      options: {},
+    });
+
+    expect(transportMutateAsync).toHaveBeenCalledWith(
+      expect.objectContaining({
+        operation: "update",
+        expectedSchemaRevision: "schema-rendered",
+        propertyId: "publish-date",
+        patch: { name: "Publish date" },
+      }),
+      undefined,
+    );
+  });
+});
+
 describe("useSetDocumentProperty", () => {
   beforeEach(() => {
     useActionMutation.mockReset();
diff --git a/templates/content/app/hooks/use-document-properties.ts b/templates/content/app/hooks/use-document-properties.ts
index 685ad2b12b3..8658fb067af 100644
--- a/templates/content/app/hooks/use-document-properties.ts
+++ b/templates/content/app/hooks/use-document-properties.ts
@@ -7,6 +7,8 @@ import type {
   ContentDatabaseItemsPageResponse,
   ContentDatabaseResponse,
   DeleteDocumentPropertyRequest,
+  DocumentPropertyDefinition,
+  DocumentPropertyOption,
   DocumentPropertiesResponse,
   DocumentPropertyValue,
   DuplicateDocumentPropertyRequest,
@@ -45,6 +47,176 @@ type SetDocumentPropertyOptions = {
   errorNotification?: "shared" | "caller";
 };
 
+type GuardedConfigurePropertyInput =
+  | {
+      operation: "create";
+      target: {
+        spaceId: string;
+        databaseId: string;
+        databaseDocumentId: string;
+      };
+      expectedSchemaRevision: string;
+      idempotencyKey: string;
+      definition: Record<string, unknown>;
+    }
+  | {
+      operation: "update";
+      target: {
+        spaceId: string;
+        databaseId: string;
+        databaseDocumentId: string;
+      };
+      expectedSchemaRevision: string;
+      idempotencyKey: string;
+      propertyId: string;
+      patch: Record<string, unknown>;
+    };
+
+type GuardedConfigurePropertyResult = {
+  receipt: {
+    revisions: { schemaAfter: string; configurationAfter: string };
+  };
+  value: DocumentPropertyDefinition & { naturalKey?: boolean };
+};
+
+const guardedOrdinaryPropertyTypes = new Set([
+  "text",
+  "number",
+  "select",
+  "multi_select",
+  "status",
+  "date",
+  "person",
+  "place",
+  "files_media",
+  "checkbox",
+  "url",
+  "email",
+  "phone",
+]);
+
+function guardedConfigurePropertyInput(
+  request: ConfigureDocumentPropertyRequest,
+  snapshot: ContentDatabaseResponse | undefined,
+): GuardedConfigurePropertyInput | ConfigureDocumentPropertyRequest {
+  const contract = snapshot?.mutationContract;
+  if (
+    !contract ||
+    contract.target.databaseId !== request.databaseId ||
+    !guardedOrdinaryPropertyTypes.has(request.type)
+  ) {
+    return request;
+  }
+  const { authorityScope: _authorityScope, ...target } = contract.target;
+  const guard = {
+    target,
+    expectedSchemaRevision: contract.schemaRevision,
+    idempotencyKey: crypto.randomUUID(),
+  };
+  const options = request.options?.options;
+  if (!request.id) {
+    if (
+      request.options?.formula !== undefined ||
+      request.options?.relation !== undefined ||
+      request.options?.rollup !== undefined
+    ) {
+      throw new Error(
+        "Ordinary properties cannot use computed property configuration.",
+      );
+    }
+    return {
+      ...guard,
+      operation: "create",
+      definition: {
+        name: request.name,
+        type: request.type,
+        ...(request.description === undefined
+          ? {}
+          : { description: request.description }),
+        ...(request.visibility === undefined
+          ? {}
+          : { visibility: request.visibility }),
+        ...(request.naturalKey === undefined
+          ? {}
+          : { naturalKey: request.naturalKey }),
+        ...(options === undefined ? {} : { options }),
+      },
+    };
+  }
+
+  const existing = snapshot.properties.find(
+    (property) => property.definition.id === request.id,
+  )?.definition;
+  if (!existing) {
+    throw new Error("The property is unavailable. Refresh before editing it.");
+  }
+  if (existing.type !== request.type) {
+    throw new Error(
+      "Property type changes are unavailable in ordinary database setup.",
+    );
+  }
+  const patch: Record<string, unknown> = {};
+  if (request.name !== existing.name) patch.name = request.name;
+  if (
+    request.description !== undefined &&
+    request.description !== existing.description
+  ) {
+    patch.description = request.description;
+  }
+  if (
+    request.visibility !== undefined &&
+    request.visibility !== existing.visibility
+  ) {
+    patch.visibility = request.visibility;
+  }
+  if (request.naturalKey !== undefined) patch.naturalKey = request.naturalKey;
+  if (options !== undefined) {
+    const current = existing.options.options ?? [];
+    const requestedIds = new Set(options.map((option) => option.id));
+    if (current.some((option) => !requestedIds.has(option.id))) {
+      throw new Error(
+        "Removing property options is unavailable because saved values may still reference them.",
+      );
+    }
+    const currentById = new Map(current.map((option) => [option.id, option]));
+    const optionEdits: Array<Record<string, unknown>> = [];
+    for (const option of options) {
+      const saved = currentById.get(option.id);
+      if (!saved) {
+        optionEdits.push({ operation: "add", option });
+        continue;
+      }
+      const optionPatch: Partial<DocumentPropertyOption> = {};
+      if (option.name !== saved.name) optionPatch.name = option.name;
+      if (option.color !== saved.color) optionPatch.color = option.color;
+      if (option.description !== saved.description) {
+        optionPatch.description = option.description;
+      }
+      if (Object.keys(optionPatch).length > 0) {
+        optionEdits.push({
+          operation: "update",
+          optionId: option.id,
+          patch: optionPatch,
+        });
+      }
+    }
+    if (options.some((option, index) => current[index]?.id !== option.id)) {
+      optionEdits.push({
+        operation: "reorder",
+        optionIds: options.map((option) => option.id),
+      });
+    }
+    if (optionEdits.length > 0) patch.optionEdits = optionEdits;
+  }
+  if (Object.keys(patch).length === 0) patch.name = existing.name;
+  return {
+    ...guard,
+    operation: "update",
+    propertyId: request.id,
+    patch,
+  };
+}
+
 const documentPropertyMutationSequences = new WeakMap<
   object,
   Map<string, number>
@@ -132,16 +304,69 @@ export function useConfigureDocumentProperty(
   databaseDocumentId = documentId,
 ) {
   const queryClient = useQueryClient();
+  const getSetupSnapshot = () =>
+    queryClient
+      .getQueriesData<ContentDatabaseResponse>(
+        contentDatabaseQueryFilter(databaseDocumentId),
+      )
+      .map(([, value]) => value)
+      .find((value) => value?.database.id === databaseId);
   const mutation = useActionMutation<
-    DocumentPropertiesResponse,
-    ConfigureDocumentPropertyRequest
+    DocumentPropertiesResponse | GuardedConfigurePropertyResult,
+    ConfigureDocumentPropertyRequest | GuardedConfigurePropertyInput
   >("configure-document-property", {
     skipActionQueryInvalidation: true,
     onSuccess: (data) => {
-      queryClient.setQueriesData<ContentDatabaseResponse>(
-        contentDatabaseQueryFilter(databaseDocumentId),
-        (current) => applyDocumentPropertiesToDatabaseResponse(current, data),
-      );
+      if ("receipt" in data) {
+        queryClient.setQueriesData<ContentDatabaseResponse>(
+          contentDatabaseQueryFilter(databaseDocumentId),
+          (current) => {
+            if (!current || current.database.id !== databaseId) return current;
+            const existing = current.properties.find(
+              (property) => property.definition.id === data.value.id,
+            );
+            const property = {
+              definition: data.value,
+              value: existing?.value ?? null,
+              editable: existing?.editable ?? true,
+              ...(existing?.blocksField
+                ? { blocksField: existing.blocksField }
+                : {}),
+            };
+            const properties = existing
+              ? current.properties.map((candidate) =>
+                  candidate.definition.id === data.value.id
+                    ? property
+                    : candidate,
+                )
+              : [...current.properties, property];
+            return {
+              ...current,
+              configurationRevision: data.receipt.revisions.configurationAfter,
+              mutationContract: current.mutationContract
+                ? {
+                    ...current.mutationContract,
+                    schemaRevision: data.receipt.revisions.schemaAfter,
+                  }
+                : current.mutationContract,
+              properties,
+              items: current.items.map((item) => ({
+                ...item,
+                properties: item.properties.map((candidate) =>
+                  candidate.definition.id === data.value.id
+                    ? { ...candidate, definition: data.value }
+                    : candidate,
+                ),
+              })),
+            };
+          },
+        );
+      } else {
+        queryClient.setQueriesData<ContentDatabaseResponse>(
+          contentDatabaseQueryFilter(databaseDocumentId),
+          (current) => applyDocumentPropertiesToDatabaseResponse(current, data),
+        );
+      }
       void queryClient.invalidateQueries({
         queryKey: documentPropertiesQueryKey(documentId, databaseId),
       });
@@ -151,7 +376,31 @@ export function useConfigureDocumentProperty(
       );
     },
   });
-  return withDatabaseScope(mutation, databaseId);
+  type ScopedVariables = Omit<ConfigureDocumentPropertyRequest, "databaseId">;
+  return {
+    ...mutation,
+    mutate: (variables: ScopedVariables, options?: unknown) =>
+      mutation.mutate(
+        guardedConfigurePropertyInput(
+          { ...variables, databaseId },
+          getSetupSnapshot(),
+        ),
+        options as never,
+      ),
+    mutateAsync: (variables: ScopedVariables, options?: unknown) =>
+      mutation.mutateAsync(
+        guardedConfigurePropertyInput(
+          { ...variables, databaseId },
+          getSetupSnapshot(),
+        ),
+        options as never,
+      ),
+  } as UseMutationResult<
+    DocumentPropertiesResponse | GuardedConfigurePropertyResult,
+    Error,
+    ScopedVariables,
+    unknown
+  >;
 }
 
 export function useSetDocumentProperty(
diff --git a/templates/content/app/routes/_app.page.$id.test.tsx b/templates/content/app/routes/_app.page.$id.test.tsx
new file mode 100644
index 00000000000..12b4bc95115
--- /dev/null
+++ b/templates/content/app/routes/_app.page.$id.test.tsx
@@ -0,0 +1,58 @@
+// @vitest-environment happy-dom
+
+import { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { MemoryRouter, Route, Routes } from "react-router";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const documentEditor = vi.fn((_props: unknown) => null);
+
+vi.mock("@agent-native/core/client/i18n", () => ({
+  useT: () => (key: string) => key,
+}));
+
+vi.mock("@/components/editor/DocumentEditor", () => ({
+  DocumentEditor: (props: unknown) => documentEditor(props),
+}));
+
+import DocumentPage from "./_app.page.$id";
+
+describe("document page route context", () => {
+  let container: HTMLDivElement;
+  let root: Root;
+
+  beforeEach(() => {
+    documentEditor.mockClear();
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+  });
+
+  afterEach(() => {
+    act(() => root.unmount());
+    container.remove();
+  });
+
+  it("passes database membership and named-view selectors to the editor", async () => {
+    await act(async () => {
+      root.render(
+        <MemoryRouter
+          initialEntries={[
+            "/page/database-page?databaseId=database-1&databaseDocumentId=database-page&viewId=ready-view",
+          ]}
+        >
+          <Routes>
+            <Route path="/page/:id" element={<DocumentPage />} />
+          </Routes>
+        </MemoryRouter>,
+      );
+    });
+
+    expect(documentEditor).toHaveBeenCalledWith({
+      documentId: "database-page",
+      databaseId: "database-1",
+      databaseDocumentId: "database-page",
+      viewId: "ready-view",
+    });
+  });
+});
diff --git a/templates/content/app/routes/_app.page.$id.tsx b/templates/content/app/routes/_app.page.$id.tsx
index d30dcbecdfa..d3b3089b24c 100644
--- a/templates/content/app/routes/_app.page.$id.tsx
+++ b/templates/content/app/routes/_app.page.$id.tsx
@@ -22,12 +22,14 @@ export default function DocumentPage() {
   const [searchParams] = useSearchParams();
   const databaseId = searchParams.get("databaseId");
   const databaseDocumentId = searchParams.get("databaseDocumentId");
+  const viewId = searchParams.get("viewId");
 
   return id ? (
     <DocumentEditor
       documentId={id}
       databaseId={databaseId}
       databaseDocumentId={databaseDocumentId}
+      viewId={viewId}
     />
   ) : (
     <div className="flex-1 flex items-center justify-center text-muted-foreground">
diff --git a/templates/content/changelog/2026-09-09-database-setup-ui-recovery.md b/templates/content/changelog/2026-09-09-database-setup-ui-recovery.md
new file mode 100644
index 00000000000..7f68ead84fd
--- /dev/null
+++ b/templates/content/changelog/2026-09-09-database-setup-ui-recovery.md
@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-09-09
+---
+
+First title edits no longer hit a stale-version conflict, open databases recover after agent Trash and restore actions, and database settings preserve keyboard focus when closing or returning to Add property. Source-managed database fields stay read-only in tables, page property editors, and agent actions, while local fields remain editable. Property editors stay inside mobile Info so edits can be saved without closing the panel.
diff --git a/templates/content/changelog/2026-09-09-ordinary-database-mcp-setup.md b/templates/content/changelog/2026-09-09-ordinary-database-mcp-setup.md
new file mode 100644
index 00000000000..370f7c49c1a
--- /dev/null
+++ b/templates/content/changelog/2026-09-09-ordinary-database-mcp-setup.md
@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-09-09
+---
+
+Connected agents can set up ordinary databases, configure fields and table views, and recover them from Trash with verified results.
diff --git a/templates/content/docs/product/capabilities/content.agent.action-parity.md b/templates/content/docs/product/capabilities/content.agent.action-parity.md
index b3a554d8640..00c477a26d0 100644
--- a/templates/content/docs/product/capabilities/content.agent.action-parity.md
+++ b/templates/content/docs/product/capabilities/content.agent.action-parity.md
@@ -25,9 +25,14 @@ proof_requirements:
     "Cross-surface UI, Action, agent-context, reload, and failure-state coverage",
     "Real-interface keyboard and assistive-technology workflow coverage",
   ]
-evidence: []
+evidence:
+  - "../../../actions/database-setup-mcp.db.test.ts"
+  - "../../../actions/database-setup.db.test.ts"
+  - "../../../actions/database-property-view-setup.db.test.ts"
+  - "../../../app/hooks/use-document-properties.test.ts"
+  - "../../../app/hooks/use-content-database-view-mutation.test.ts"
 superseded_by: null
-last_reviewed: "2026-07-29"
+last_reviewed: "2026-09-09"
 ---
 
 # Agent and UI parity
@@ -60,7 +65,9 @@ Given an Action succeeds through an agent, when the Page is opened, then it show
 
 ## Current evidence
 
-Existing Actions provide in-progress donor substrate, but per-capability parity evaluations and real-interface proof remain incomplete. This Capability remains `in_progress`.
+Ordinary database setup has a bounded shared contract: create an empty database, configure supported ordinary properties, save table views, edit rows, and move a database to Trash or restore it. MCP callers use explicit target identities, revision checks, and idempotency keys. Setup receipts include canonical read-back and links; UI property and view edits use the same guarded actions. Source reads expose scoped metadata, while source writes and computed-property configuration remain outside this contract.
+
+SDK integration tests exercise discovery, the setup lifecycle, concurrent retries, stale revisions, permission changes, source redaction, and rejection of legacy MCP payloads. Database tests cover PGlite and PostgreSQL; UI adapter tests cover canonical receipt updates and queued edits. These checks establish this bounded implementation, not deployed acceptance or complete parity across Content. Per-capability real-interface proof and broader parity evaluations remain incomplete. This Capability remains `in_progress`.
 
 ## Proof plan
 
diff --git a/templates/content/parity/matrix.md b/templates/content/parity/matrix.md
index 4172092bdc0..48e9ca3cbf7 100644
--- a/templates/content/parity/matrix.md
+++ b/templates/content/parity/matrix.md
@@ -8,7 +8,7 @@ This generated matrix tracks whether high-value Content UI operations use the sa
 | database.form-submissions                          | database    | Submit public database forms as new rows                                                                  | action-backed         | `submit-content-database-form`                                                                                                                                                                                                                                                                                                                                                                              | `app/components/editor/database/FormView.tsx`                                                                                                                                             | A validated form submission atomically creates a database row document and its editable property values.                                                                                                                                                                                  | -                                                                                                                                                                                                                                          | -                | P0             | covered       | `actions/submit-content-database-form.db.test.ts`                                                                                                                                                                                                                     | -                                | -                              |
 | database.lifecycle-and-trash                       | database    | Create, soft-delete, restore, list, and inspect content databases                                         | action-backed         | `create-content-database`, `create-inline-content-database`, `delete-content-database`, `describe-content-database`, `get-content-database`, `list-content-databases`, `list-trashed-content-databases`, `restore-content-database`                                                                                                                                                                         | `app/components/editor/SlashCommandMenu.tsx`, `app/hooks/use-content-database.ts`, `app/hooks/use-documents.ts`                                                                           | Database pages and database records are created, read, soft-deleted, restored, and listed.                                                                                                                                                                                                | -                                                                                                                                                                                                                                          | -                | P0             | covered       | `actions/content-database-lifecycle.db.test.ts`, `actions/list-content-databases.db.test.ts`, `server/plugins/agent-chat.spec.ts`, `../../packages/core/src/server/agent-chat/content-a2a-capabilities.spec.ts`                                                       | `database-source-scope`          | -                              |
 | database.private-preview-drafts                    | database    | Persist and reconcile a user's private database-page preview draft                                        | action-backed         | `get-preview-document-draft`, `update-preview-document-draft`                                                                                                                                                                                                                                                                                                                                               | `app/components/editor/database/DatabaseView.tsx`, `app/hooks/use-documents.ts`                                                                                                           | A user's private preview draft is read, saved, conflict-checked, or deleted without changing the shared database page until the normal save flow applies it.                                                                                                                              | These per-user editor-state actions are intentionally hidden from agent tools because preview drafts are a private UI recovery mechanism.                                                                                                  | -                | P1             | covered       | `actions/preview-document-draft.db.test.ts`                                                                                                                                                                                                                           | -                                | -                              |
-| database.properties-and-view-config                | database    | Configure properties, values, ordering, and saved views                                                   | action-backed         | `configure-document-property`, `delete-document-property`, `duplicate-document-property`, `get-content-database-personal-view`, `list-document-properties`, `reorder-document-property`, `set-document-property`, `update-content-database-personal-view`, `update-content-database-view`                                                                                                                   | `app/components/editor/DocumentProperties.tsx`, `app/components/editor/DocumentDatabase.tsx`, `app/components/editor/database/DatabaseView.tsx`, `app/hooks/use-document-properties.ts`   | Property schemas, property values, property order, filters, sorts, grouping, hidden columns, view type, and view settings are stored.                                                                                                                                                     | -                                                                                                                                                                                                                                          | -                | P0             | covered       | `actions/bind-content-database-source-field.db.test.ts`, `actions/content-database-source-actions.test.ts`, `actions/resync-content-database-source.db.test.ts`                                                                                                       | `database-source-scope`          | -                              |
+| database.properties-and-view-config                | database    | Configure properties, values, ordering, and saved views                                                   | action-backed         | `configure-document-property`, `delete-document-property`, `duplicate-document-property`, `get-content-database-personal-view`, `list-document-properties`, `reorder-document-property`, `set-document-property`, `update-content-database-personal-view`, `update-content-database-view`                                                                                                                   | `app/components/editor/DocumentProperties.tsx`, `app/components/editor/DocumentDatabase.tsx`, `app/components/editor/database/DatabaseView.tsx`, `app/hooks/use-document-properties.ts`   | Property schemas, property values, property order, filters, sorts, grouping, hidden columns, view type, and view settings are stored.                                                                                                                                                     | -                                                                                                                                                                                                                                          | -                | P0             | covered       | `actions/database-setup-mcp.db.test.ts`, `actions/bind-content-database-source-field.db.test.ts`, `actions/content-database-source-actions.test.ts`, `actions/resync-content-database-source.db.test.ts`                                                              | `database-source-scope`          | -                              |
 | database.rows                                      | database    | Add, duplicate, move, open, edit, and remove database rows                                                | action-backed         | `add-database-item`, `update-database-item`, `upsert-database-item-by-key`, `list-content-database-blocks`, `mutate-content-database-block`, `remove-database-items`, `duplicate-database-items`, `duplicate-database-item`, `update-database-items`, `migrate-content-database-rows`, `manage-content-database-migration`, `move-database-item`, `set-document-property`                                   | `app/components/editor/DocumentDatabase.tsx`, `app/components/editor/database/DatabaseView.tsx`                                                                                           | Database row memberships and ordering are created, duplicated, moved, edited, and removed without deleting the backing page; bounded migrations atomically update row bodies and properties through the same canonical data model.                                                        | -                                                                                                                                                                                                                                          | -                | P0             | covered       | `actions/database-row-batch-actions.db.test.ts`, `actions/upsert-database-item-by-key.db.test.ts`, `actions/migrate-content-database-rows.db.test.ts`, `actions/content-database-block-actions.db.test.ts`, `parity/__tests__/database-row-batch-reliability.test.ts` | `database-bulk-row-reliability`  | -                              |
 | database.table-query-page                          | database    | Query one constrained page while retaining database metadata                                              | action-backed         | `query-content-database-items`                                                                                                                                                                                                                                                                                                                                                                              | `app/components/editor/database/DatabaseView.tsx`, `app/hooks/use-content-database.ts`                                                                                                    | -                                                                                                                                                                                                                                                                                         | This UI-only bounded projection is intentionally hidden with agentTool: false; agents use get-content-database for the complete database contract.                                                                                         | -                | P0             | covered       | `actions/content-database-lifecycle.db.test.ts`, `app/hooks/use-content-database.test.ts`                                                                                                                                                                             | -                                | -                              |
 | editor.agent-assist-prompts                        | editor      | Ask AI from slash generation or comment context                                                           | client-assist         | -                                                                                                                                                                                                                                                                                                                                                                                                           | `app/components/editor/SlashCommandMenu.tsx`, `app/components/editor/CommentsSidebar.tsx`                                                                                                 | No direct durable mutation; the prompt asks the agent to use document actions when it decides to write.                                                                                                                                                                                   | -                                                                                                                                                                                                                                          | -                | P1             | none          | -                                                                                                                                                                                                                                                                     | -                                | -                              |
@@ -22,7 +22,7 @@ This generated matrix tracks whether high-value Content UI operations use the sa
 | sharing.document-discoverability-and-export        | sharing     | Share, hide from search, export, and reveal documents                                                     | action-backed         | `export-document`, `reveal-local-source-file`, `set-document-discoverability`, `share-local-file-document`                                                                                                                                                                                                                                                                                                  | `app/components/editor/DocumentToolbar.tsx`, `app/hooks/use-documents.ts`                                                                                                                 | Search discoverability, shareable copies, exports, and OS reveal requests are managed through Content actions.                                                                                                                                                                            | -                                                                                                                                                                                                                                          | -                | P0             | covered       | `actions/_local-file-documents.test.ts`                                                                                                                                                                                                                               | `local-file-source-truth`        | -                              |
 | sharing.os-reveal-local-source                     | sharing     | Reveal a local source file in the system file manager                                                     | host-only             | `reveal-local-source-file`                                                                                                                                                                                                                                                                                                                                                                                  | `app/components/editor/DocumentToolbar.tsx`, `actions/reveal-local-source-file.ts`                                                                                                        | -                                                                                                                                                                                                                                                                                         | OS reveal depends on trusted local host capabilities and should not spend agent tool surface or imply portable hosted behavior.                                                                                                            | -                | P2             | seeded        | -                                                                                                                                                                                                                                                                     | -                                | Local folder exception/docs PR |
 | sidebar.chrome-state                               | sidebar     | Collapse sections and resize the sidebar                                                                  | client-only-ephemeral | -                                                                                                                                                                                                                                                                                                                                                                                                           | `app/components/sidebar/DocumentSidebar.tsx`, `app/components/layout/Layout.tsx`                                                                                                          | -                                                                                                                                                                                                                                                                                         | -                                                                                                                                                                                                                                          | -                | P2             | none          | -                                                                                                                                                                                                                                                                     | -                                | -                              |
-| sidebar.document-tree-crud                         | sidebar     | Create, delete, move, favorite, list, search, and open pages                                              | action-backed         | `create-document`, `clone-creative-context-document`, `delete-document`, `get-document`, `list-trashed-documents`, `list-documents`, `move-document`, `permanently-delete-document`, `restore-document`, `search-documents`, `update-document`                                                                                                                                                              | `app/components/sidebar/DocumentSidebar.tsx`, `app/components/sidebar/DocumentTreeItem.tsx`, `app/components/editor/DocumentToolbar.tsx`, `app/hooks/use-documents.ts`                    | Document tree rows and document metadata are created, updated, deleted, moved, searched, or read.                                                                                                                                                                                         | -                                                                                                                                                                                                                                          | -                | P0             | covered       | `actions/content-database-lifecycle.db.test.ts`, `actions/_local-file-documents.test.ts`                                                                                                                                                                              | `document-search-edit`           | -                              |
+| sidebar.document-tree-crud                         | sidebar     | Create, delete, move, favorite, list, search, and open pages                                              | action-backed         | `create-document`, `clone-creative-context-document`, `delete-document`, `get-document`, `list-trashed-documents`, `list-documents`, `move-document`, `permanently-delete-document`, `restore-document`, `search-documents`, `update-document`                                                                                                                                                              | `app/components/sidebar/DocumentSidebar.tsx`, `app/components/sidebar/DocumentTreeItem.tsx`, `app/components/editor/DocumentToolbar.tsx`, `app/hooks/use-documents.ts`                    | Document tree rows and document metadata are created, updated, deleted, moved, searched, or read.                                                                                                                                                                                         | -                                                                                                                                                                                                                                          | -                | P0             | covered       | `actions/content-database-lifecycle.db.test.ts`, `actions/database-setup.db.test.ts`, `actions/database-setup-mcp.db.test.ts`, `actions/_local-file-documents.test.ts`                                                                                                | `document-search-edit`           | -                              |
 | sidebar.navigation-and-screen-context              | sidebar     | Navigate between documents and expose current screen context                                              | action-equivalent     | `navigate`, `view-screen`                                                                                                                                                                                                                                                                                                                                                                                   | `app/components/sidebar/DocumentSidebar.tsx`, `actions/navigate.ts`, `actions/view-screen.ts`                                                                                             | Application navigation state is updated or read so the agent can reason about the user's current page/view.                                                                                                                                                                               | Human navigation is router-local, while agent navigation/screen inspection uses application-state actions to produce the same workspace orientation effect.                                                                                | -                | P1             | seeded        | -                                                                                                                                                                                                                                                                     | -                                | -                              |
 | source-sync.builder-body-hydration-worker          | source-sync | Process queued Builder CMS body hydration work                                                            | action-backed         | `process-builder-body-hydration`                                                                                                                                                                                                                                                                                                                                                                            | `app/components/editor/DocumentEditor.tsx`, `app/components/editor/database/DatabaseView.tsx`, `app/hooks/use-content-database.ts`                                                        | Queued Builder body hydration entries are processed into readable Content document/database body state.                                                                                                                                                                                   | This action is intentionally hidden from the model with agentTool: false because it is an internal bounded queue worker; agents should use source refresh, review, and execution actions rather than manually driving hydration internals. | -                | P0             | covered       | `actions/_database-source-utils.test.ts`                                                                                                                                                                                                                              | -                                | -                              |
 | source-sync.builder-cms-review-and-write-gates     | source-sync | Review, stage, validate, cancel, and execute Builder CMS source writes                                    | action-backed         | `cancel-prepared-builder-source-update`, `execute-builder-source-batch`, `execute-builder-source-execution`, `prepare-builder-source-execution`, `prepare-builder-source-review`, `preview-builder-source-review`, `review-content-database-source-change-set`, `set-content-database-source-write-mode`, `stage-builder-source-bulk-update`, `stage-builder-revision`, `validate-builder-source-execution` | `app/components/editor/DocumentDatabase.tsx`, `app/components/editor/database/DatabaseView.tsx`, `app/components/editor/database-sources/BuilderSourceReviewDialog.tsx`                   | Builder source write mode, staged reviews, pre-dispatch cancellations, validation records, and bounded execution records are created through guarded actions.                                                                                                                             | -                                                                                                                                                                                                                                          | -                | P0             | covered       | `actions/builder-source-review-gates.db.test.ts`, `actions/cancel-prepared-builder-source-update.db.test.ts`, `actions/execute-builder-source-execution.test.ts`, `actions/stage-builder-source-bulk-update.db.test.ts`                                               | `builder-source-review-readonly` | -                              |
diff --git a/templates/content/parity/matrix.ts b/templates/content/parity/matrix.ts
index b46814a1834..58bf04f299e 100644
--- a/templates/content/parity/matrix.ts
+++ b/templates/content/parity/matrix.ts
@@ -36,6 +36,8 @@ export const parityMatrix: ParityRow[] = [
     followUpPR: null,
     coverageRefs: [
       "actions/content-database-lifecycle.db.test.ts",
+      "actions/database-setup.db.test.ts",
+      "actions/database-setup-mcp.db.test.ts",
       "actions/_local-file-documents.test.ts",
     ],
     evalScenarioIds: ["document-search-edit"],
@@ -454,6 +456,7 @@ export const parityMatrix: ParityRow[] = [
     testCoverage: "covered",
     followUpPR: null,
     coverageRefs: [
+      "actions/database-setup-mcp.db.test.ts",
       "actions/bind-content-database-source-field.db.test.ts",
       "actions/content-database-source-actions.test.ts",
       "actions/resync-content-database-source.db.test.ts",
diff --git a/templates/content/server/db/schema.ts b/templates/content/server/db/schema.ts
index 859aa53dab9..37486a974c1 100644
--- a/templates/content/server/db/schema.ts
+++ b/templates/content/server/db/schema.ts
@@ -569,6 +569,29 @@ export const contentDatabaseRowMutationReceipts = table(
   ],
 );
 
+export const contentDatabaseSetupReceipts = table(
+  "content_database_setup_receipts",
+  {
+    id: text("id").primaryKey(),
+    actorEmail: text("actor_email").notNull(),
+    operation: text("operation").notNull(),
+    scopeId: text("scope_id").notNull(),
+    idempotencyKey: text("idempotency_key").notNull(),
+    payloadDigest: text("payload_digest").notNull(),
+    databaseId: text("database_id"),
+    resultJson: text("result_json"),
+    createdAt: text("created_at").notNull().default(now()),
+  },
+  (receipt) => [
+    uniqueIndex("content_database_setup_receipts_actor_operation_key").on(
+      receipt.actorEmail,
+      receipt.operation,
+      receipt.scopeId,
+      receipt.idempotencyKey,
+    ),
+  ],
+);
+
 export const documentEditReceipts = table(
   "document_edit_receipts",
   {
diff --git a/templates/content/server/plugins/core-routes.spec.ts b/templates/content/server/plugins/core-routes.spec.ts
new file mode 100644
index 00000000000..d7d2ff773b1
--- /dev/null
+++ b/templates/content/server/plugins/core-routes.spec.ts
@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+
+import { resolveContentOpenPath } from "./core-routes.js";
+
+describe("Content open paths", () => {
+  it("preserves database, membership, and named-view context", () => {
+    expect(
+      resolveContentOpenPath({
+        view: "editor",
+        params: {
+          documentId: "row/page",
+          databaseId: "database & one",
+          databaseDocumentId: "database/page",
+          viewId: "ready view",
+        },
+      }),
+    ).toBe(
+      "/page/row%2Fpage?databaseId=database+%26+one&databaseDocumentId=database%2Fpage&viewId=ready+view",
+    );
+  });
+
+  it("keeps editor and list fallbacks on the Content home", () => {
+    expect(resolveContentOpenPath({ view: "editor", params: {} })).toBe(
+      "/home",
+    );
+    expect(resolveContentOpenPath({ view: "list", params: {} })).toBe("/home");
+    expect(resolveContentOpenPath({ view: "unknown", params: {} })).toBeNull();
+  });
+});
diff --git a/templates/content/server/plugins/core-routes.ts b/templates/content/server/plugins/core-routes.ts
index 64e532ae025..17d83674310 100644
--- a/templates/content/server/plugins/core-routes.ts
+++ b/templates/content/server/plugins/core-routes.ts
@@ -3,6 +3,26 @@ import { createCoreRoutesPlugin } from "@agent-native/core/server";
 import { envKeys } from "../lib/env-config.js";
 import { resolvePublicViewerOwner } from "../lib/public-documents.js";
 
+export function resolveContentOpenPath({
+  view,
+  params,
+}: {
+  view?: string;
+  params: Record<string, string>;
+}) {
+  if (params.documentId) {
+    const search = new URLSearchParams();
+    for (const key of ["databaseId", "databaseDocumentId", "viewId"] as const) {
+      const value = params[key];
+      if (value) search.set(key, value);
+    }
+    const query = search.toString();
+    return `/page/${encodeURIComponent(params.documentId)}${query ? `?${query}` : ""}`;
+  }
+  if (view === "editor" || view === "list") return "/home";
+  return null;
+}
+
 export default createCoreRoutesPlugin({
   googleOAuthManagedConnection: "not_applicable",
   envKeys,
@@ -10,10 +30,5 @@ export default createCoreRoutesPlugin({
   // Land deep links (`/_agent-native/open?app=content&view=editor&documentId=…`)
   // straight on the real SPA path so there's no `/editor` -> `/` bounce before
   // the polled `navigate` command applies record focus.
-  resolveOpenPath: ({ view, params }) => {
-    if (params.documentId) return `/page/${params.documentId}`;
-    if (view === "editor") return "/home";
-    if (view === "list") return "/home";
-    return null;
-  },
+  resolveOpenPath: resolveContentOpenPath,
 });
diff --git a/templates/content/server/plugins/db.ts b/templates/content/server/plugins/db.ts
index 1911f94c50e..a028dcdab7b 100644
--- a/templates/content/server/plugins/db.ts
+++ b/templates/content/server/plugins/db.ts
@@ -1119,6 +1119,23 @@ export const runContentMigrations = runMigrations(
       name: "content-databases-document-idx",
       sql: `CREATE INDEX IF NOT EXISTS content_databases_document_idx ON content_databases (document_id)`,
     },
+    {
+      version: 91,
+      name: "content-database-setup-receipts",
+      sql: `CREATE TABLE IF NOT EXISTS content_database_setup_receipts (
+        id TEXT PRIMARY KEY,
+        actor_email TEXT NOT NULL,
+        operation TEXT NOT NULL,
+        scope_id TEXT NOT NULL,
+        idempotency_key TEXT NOT NULL,
+        payload_digest TEXT NOT NULL,
+        database_id TEXT,
+        result_json TEXT,
+        created_at TEXT NOT NULL DEFAULT (CURRENT_TIMESTAMP)
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS content_database_setup_receipts_actor_operation_key
+        ON content_database_setup_receipts (actor_email, operation, scope_id, idempotency_key)`,
+    },
   ],
   { table: "content_migrations" },
 );
diff --git a/templates/content/shared/api.ts b/templates/content/shared/api.ts
index 08fa0911065..5fc0c05d03e 100644
--- a/templates/content/shared/api.ts
+++ b/templates/content/shared/api.ts
@@ -853,8 +853,8 @@ export interface ContentDatabaseSource {
   rows: ContentDatabaseSourceRow[];
   changeSets: ContentDatabaseSourceChangeSet[];
   projection?: {
-    rows: "complete" | "page";
-    changeSets: "complete" | "page";
+    rows: "complete" | "page" | "omitted";
+    changeSets: "complete" | "page" | "omitted";
   };
   bodyHydration?: ContentDatabaseBodyHydrationSummary;
 }
@@ -907,6 +907,8 @@ export interface NotionDatabaseSourcesResponse {
 }
 
 export interface ContentDatabaseResponse {
+  configurationRevision?: string;
+  setupContract?: ContentDatabaseSetupContract;
   database: ContentDatabase;
   properties: DocumentProperty[];
   items: ContentDatabaseItem[];
@@ -980,6 +982,7 @@ export interface ContentDatabaseSourceFieldPropertyResponse {
 }
 
 export interface CreateDatabaseRequest {
+  idempotencyKey?: string;
   documentId?: string;
   newDocumentId?: string;
   spaceId?: string;
@@ -1163,11 +1166,30 @@ export interface ContentSystemCollectionSummary {
 }
 
 export interface ContentDatabaseDescriptionResponse {
+  configurationRevision?: string;
+  mutationContract?: ContentDatabaseMutationContract;
+  setupContract?: ContentDatabaseSetupContract;
   database: ContentDatabase;
   contextPath: ContentContextPathEntry[];
   properties: DocumentProperty[];
 }
 
+export interface ContentDatabaseSetupContract {
+  target: { spaceId: string; databaseId: string; databaseDocumentId: string };
+  databaseUrl: string;
+  viewUrls: Array<{ viewId: string; url: string }>;
+  supportedPropertyTypes: string[];
+  canEditSchema: boolean;
+  canEditViews: boolean;
+  canManageLifecycle: boolean;
+  sourceComposition: "unsupported";
+  properties: Array<{
+    propertyId: string;
+    editable: boolean;
+    reason: string | null;
+  }>;
+}
+
 export interface ListContentDatabasesResponse {
   databases: ContentDatabaseSummary[];
   pagination: DocumentDiscoveryPagination;
@@ -1175,6 +1197,8 @@ export interface ListContentDatabasesResponse {
 }
 
 export interface TrashedContentDatabaseSummary {
+  spaceId?: string | null;
+  configurationRevision?: string;
   databaseId: string;
   title: string;
   documentId: string;
@@ -1185,6 +1209,8 @@ export interface TrashedContentDatabaseSummary {
 
 export interface ListTrashedContentDatabasesResponse {
   databases: TrashedContentDatabaseSummary[];
+  hasMore?: boolean;
+  nextOffset?: number | null;
 }
 
 export interface TrashedDocumentSummary {
diff --git a/templates/content/shared/source-field-policy.test.ts b/templates/content/shared/source-field-policy.test.ts
new file mode 100644
index 00000000000..8de4969f98a
--- /dev/null
+++ b/templates/content/shared/source-field-policy.test.ts
@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  contentDatabaseSourceFieldAllowsLocalWrite,
+  contentDatabaseSourceManagedPropertyIds,
+  contentDatabaseSourceFieldsAllowLocalWrite,
+  parseContentDatabaseSourceFieldReadOnly,
+  parseContentDatabaseSourceWriteOwner,
+} from "./source-field-policy";
+
+describe("Content source field write policy", () => {
+  it("allows only explicit local ownership with an explicit writable flag", () => {
+    expect(
+      contentDatabaseSourceFieldAllowsLocalWrite({
+        writeOwner: "local",
+        readOnly: 0,
+      }),
+    ).toBe(true);
+    expect(
+      contentDatabaseSourceFieldAllowsLocalWrite({
+        writeOwner: "local",
+        readOnly: false,
+      }),
+    ).toBe(true);
+
+    for (const field of [
+      { writeOwner: "source", readOnly: 0 },
+      { writeOwner: "derived", readOnly: 0 },
+      { writeOwner: "local", readOnly: 1 },
+      { writeOwner: "local", readOnly: true },
+    ]) {
+      expect(contentDatabaseSourceFieldAllowsLocalWrite(field)).toBe(false);
+    }
+  });
+
+  it("rejects unknown ownership and read-only values instead of coercing them", () => {
+    expect(() => parseContentDatabaseSourceWriteOwner("unknown")).toThrow(
+      "Invalid Content source field write owner: unknown",
+    );
+    expect(() => parseContentDatabaseSourceWriteOwner(null)).toThrow(
+      "Invalid Content source field write owner: null",
+    );
+    expect(() => parseContentDatabaseSourceFieldReadOnly(2)).toThrow(
+      "Invalid Content source field read-only value: 2",
+    );
+    expect(() => parseContentDatabaseSourceFieldReadOnly(undefined)).toThrow(
+      "Invalid Content source field read-only value: undefined",
+    );
+  });
+
+  it("validates every mapped field before deciding the combined policy", () => {
+    expect(() =>
+      contentDatabaseSourceFieldsAllowLocalWrite([
+        { writeOwner: "source", readOnly: 1 },
+        { writeOwner: "unknown", readOnly: 0 },
+      ]),
+    ).toThrow("Invalid Content source field write owner: unknown");
+  });
+
+  it("marks a property source-managed when any mapping blocks local writes", () => {
+    expect(
+      contentDatabaseSourceManagedPropertyIds([
+        { propertyId: "local", writeOwner: "local", readOnly: 0 },
+        { propertyId: "shared", writeOwner: "local", readOnly: 0 },
+        { propertyId: "shared", writeOwner: "source", readOnly: 1 },
+      ]),
+    ).toEqual(new Set(["shared"]));
+  });
+});
diff --git a/templates/content/shared/source-field-policy.ts b/templates/content/shared/source-field-policy.ts
new file mode 100644
index 00000000000..81f9ec747de
--- /dev/null
+++ b/templates/content/shared/source-field-policy.ts
@@ -0,0 +1,60 @@
+import type { ContentDatabaseSourceWriteOwner } from "./api.js";
+
+export function parseContentDatabaseSourceWriteOwner(
+  value: unknown,
+): ContentDatabaseSourceWriteOwner {
+  if (value === "local" || value === "source" || value === "derived") {
+    return value;
+  }
+  throw new Error(`Invalid Content source field write owner: ${String(value)}`);
+}
+
+export function parseContentDatabaseSourceFieldReadOnly(
+  value: unknown,
+): boolean {
+  if (value === true || value === 1) return true;
+  if (value === false || value === 0) return false;
+  throw new Error(
+    `Invalid Content source field read-only value: ${String(value)}`,
+  );
+}
+
+export function contentDatabaseSourceFieldAllowsLocalWrite(field: {
+  writeOwner: unknown;
+  readOnly: unknown;
+}) {
+  return (
+    parseContentDatabaseSourceWriteOwner(field.writeOwner) === "local" &&
+    !parseContentDatabaseSourceFieldReadOnly(field.readOnly)
+  );
+}
+
+export function contentDatabaseSourceFieldsAllowLocalWrite(
+  fields: Array<{ writeOwner: unknown; readOnly: unknown }>,
+) {
+  const decisions = fields.map(contentDatabaseSourceFieldAllowsLocalWrite);
+  return decisions.every(Boolean);
+}
+
+export function contentDatabaseSourceManagedPropertyIds(
+  fields: Array<{
+    propertyId: string | null;
+    writeOwner: unknown;
+    readOnly: unknown;
+  }>,
+) {
+  const decisions = fields
+    .filter(
+      (field): field is typeof field & { propertyId: string } =>
+        field.propertyId !== null,
+    )
+    .map((field) => ({
+      propertyId: field.propertyId,
+      allowsLocalWrite: contentDatabaseSourceFieldAllowsLocalWrite(field),
+    }));
+  return new Set(
+    decisions.flatMap(({ propertyId, allowsLocalWrite }) =>
+      allowsLocalWrite ? [] : [propertyId],
+    ),
+  );
+}