diff --git a/apps/nestjs-backend/src/features/ai/ai.service.ts b/apps/nestjs-backend/src/features/ai/ai.service.ts
index 562d0a48cf..975b2379c6 100644
--- a/apps/nestjs-backend/src/features/ai/ai.service.ts
+++ b/apps/nestjs-backend/src/features/ai/ai.service.ts
@@ -63,6 +63,27 @@ export class AiService {
     return { type, model, name };
   }
 
+  /**
+   * Resolve the model key by matching a body model ID against chatModel lg/md/sm values.
+   * Model keys are in format type@modelId@name — we compare the modelId segment.
+   * Falls back to lg if no match is found.
+   */
+  public resolveModelKeyFromBody(
+    chatModel: { lg?: string; md?: string; sm?: string } | undefined,
+    bodyModel?: string
+  ): string | undefined {
+    if (bodyModel) {
+      const sizes = ['lg', 'md', 'sm'] as const;
+      for (const size of sizes) {
+        const key = chatModel?.[size];
+        if (key && this.parseModelKey(key).model === bodyModel) {
+          return key;
+        }
+      }
+    }
+    return chatModel?.lg;
+  }
+
   /**
    * Check if modelKey is an AI Gateway model
    * Format: aiGateway@<modelId>@teable
@@ -554,6 +575,8 @@ export class AiService {
       ability: chatModel?.ability,
       isInstance,
       lgModelKey: chatModel.lg,
+      mdModelKey: chatModel.md,
+      smModelKey: chatModel.sm,
     };
   }
 
diff --git a/apps/nestjs-backend/src/features/auth/guard/permission.guard.ts b/apps/nestjs-backend/src/features/auth/guard/permission.guard.ts
index 177a76fe00..b940472820 100644
--- a/apps/nestjs-backend/src/features/auth/guard/permission.guard.ts
+++ b/apps/nestjs-backend/src/features/auth/guard/permission.guard.ts
@@ -155,12 +155,15 @@ export class PermissionGuard {
       resourceId,
       permissions
     );
-    // Set user to anonymous for share context
-    this.cls.set('user', {
-      id: ANONYMOUS_USER_ID,
-      name: ANONYMOUS_USER_ID,
-      email: '',
-    });
+    // Preserve logged-in user identity for allowEdit; fall back to anonymous
+    const currentUserId = this.cls.get('user.id');
+    if (!currentUserId || isAnonymous(currentUserId)) {
+      this.cls.set('user', {
+        id: ANONYMOUS_USER_ID,
+        name: ANONYMOUS_USER_ID,
+        email: '',
+      });
+    }
     this.cls.set('permissions', ownPermissions);
     return true;
   }
@@ -297,6 +300,15 @@ export class PermissionGuard {
     if (!shareId) {
       return undefined;
     }
+    // Skip share path for endpoints without @Permissions (e.g. /user/me),
+    // otherwise baseSharePermissionCheck throws ForbiddenException.
+    const permissions = this.reflector.getAllAndOverride<Action[] | undefined>(PERMISSIONS_KEY, [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+    if (!permissions?.length) {
+      return undefined;
+    }
     return await this.baseSharePermissionCheck(context, shareId);
   }
 
@@ -383,9 +395,10 @@ export class PermissionGuard {
    *
    * Priority flow:
    *   1. RESOURCE-level: exclusively use resource-specific auth (base share > template)
-   *   2. Early base share check for PUBLIC or anonymous requests when header is present
+   *   2. Share link check — when share header is present, share permissions are the ceiling
+   *      for ALL users (anonymous or authenticated), so personal role never exceeds the link
    *   3. Anonymous user handling (template / USER-level)
-   *   4. Authenticated user: standard check, with fallback for PUBLIC endpoints
+   *   4. Authenticated user: standard check, with PUBLIC fallback
    */
   protected async permissionCheckWithPublicFallback(
     context: ExecutionContext,
@@ -406,10 +419,8 @@ export class PermissionGuard {
       // No valid resource auth header — fall through to normal checks
     }
 
-    // 2. Early base share check for PUBLIC or anonymous requests
-    const shouldTryBaseShareEarly =
-      baseShareHeader && (allowAnonymousType === AllowAnonymousType.PUBLIC || this.isAnonymous());
-    if (shouldTryBaseShareEarly) {
+    // 2. Share link — permissions are bounded by the link, regardless of user role
+    if (baseShareHeader) {
       const result = await this.tryBaseSharePermissionCheck(context, baseShareHeader);
       if (result !== undefined) return result;
     }
@@ -419,7 +430,7 @@ export class PermissionGuard {
       return this.resolveAnonymousPermission(context, allowAnonymousType);
     }
 
-    // 4. Authenticated user: standard check, with fallback for PUBLIC endpoints
+    // 4. Authenticated user: standard check, with PUBLIC fallback
     try {
       return await permissionCheck();
     } catch (error) {
diff --git a/apps/nestjs-backend/src/features/auth/permission.service.ts b/apps/nestjs-backend/src/features/auth/permission.service.ts
index 9c899d1d01..325113feeb 100644
--- a/apps/nestjs-backend/src/features/auth/permission.service.ts
+++ b/apps/nestjs-backend/src/features/auth/permission.service.ts
@@ -4,6 +4,7 @@ import type { IBaseRole, Action } from '@teable/core';
 import {
   HttpErrorCode,
   IdPrefix,
+  Role,
   TemplatePermissions,
   getPermissions,
   isAnonymous,
@@ -27,6 +28,18 @@ interface IBaseNodeCacheItem {
 
 const notAllowedOperationI18nKey = 'httpErrors.permission.notAllowedOperation';
 
+/**
+ * Permissions that must never be granted via share links,
+ * even when allowEdit is enabled with a logged-in user.
+ */
+const SHARE_EXCLUDED_PERMISSIONS = new Set<Action>([
+  'view|share',
+  'space|invite_email',
+  'base|invite_email',
+  'user|email_read',
+  'user|integrations',
+]);
+
 @Injectable()
 export class PermissionService {
   private readonly logger = new Logger(PermissionService.name);
@@ -627,7 +640,13 @@ export class PermissionService {
     // Set base share in cls for downstream services to use
     this.cls.set('baseShare', { baseId, nodeId });
 
-    // Return template permissions (read-only), with record|copy if allowCopy is enabled
+    // When allowEdit is enabled and user is logged in, grant editor-level permissions
+    // excluding invite/share/privacy-sensitive actions
+    if (baseShare.allowEdit && !this.isAnonymous()) {
+      return getPermissions(Role.Editor).filter((p) => !SHARE_EXCLUDED_PERMISSIONS.has(p));
+    }
+
+    // Otherwise return template permissions (read-only), with record|copy if allowCopy is enabled
     const permissions = [...TemplatePermissions];
     if (baseShare.allowCopy) {
       permissions.push('record|copy');
diff --git a/apps/nestjs-backend/src/features/base-share/base-share-auth.service.ts b/apps/nestjs-backend/src/features/base-share/base-share-auth.service.ts
index f218bc0ed5..7796b2fc4f 100644
--- a/apps/nestjs-backend/src/features/base-share/base-share-auth.service.ts
+++ b/apps/nestjs-backend/src/features/base-share/base-share-auth.service.ts
@@ -10,6 +10,7 @@ export interface IBaseShareInfo {
   nodeId: string;
   allowSave: boolean | null;
   allowCopy: boolean | null;
+  allowEdit: boolean | null;
 }
 
 export interface IJwtBaseShareInfo {
@@ -84,6 +85,7 @@ export class BaseShareAuthService {
       nodeId: share.nodeId,
       allowSave: share.allowSave,
       allowCopy: share.allowCopy,
+      allowEdit: share.allowEdit,
     };
   }
 
diff --git a/apps/nestjs-backend/src/features/base-share/base-share-open.controller.ts b/apps/nestjs-backend/src/features/base-share/base-share-open.controller.ts
index 2cbc512f93..8e4a685ee7 100644
--- a/apps/nestjs-backend/src/features/base-share/base-share-open.controller.ts
+++ b/apps/nestjs-backend/src/features/base-share/base-share-open.controller.ts
@@ -61,7 +61,7 @@ export class BaseShareOpenController {
     @Request() req: Express.Request & { baseShareInfo: IBaseShareInfo }
   ): Promise<IGetBaseShareVo> {
     const shareInfo = req.baseShareInfo;
-    const { baseId, nodeId, allowSave, allowCopy } = shareInfo;
+    const { baseId, nodeId, allowSave, allowCopy, allowEdit } = shareInfo;
 
     // Build default URL for redirect
     const defaultUrl = await this.buildDefaultUrl(baseId, nodeId);
@@ -73,6 +73,7 @@ export class BaseShareOpenController {
         nodeId,
         allowSave,
         allowCopy,
+        allowEdit,
       },
       defaultUrl,
     };
diff --git a/apps/nestjs-backend/src/features/base-share/base-share.service.ts b/apps/nestjs-backend/src/features/base-share/base-share.service.ts
index 066e55bde2..c426623ab7 100644
--- a/apps/nestjs-backend/src/features/base-share/base-share.service.ts
+++ b/apps/nestjs-backend/src/features/base-share/base-share.service.ts
@@ -2,6 +2,7 @@ import { Injectable } from '@nestjs/common';
 import { generateShareId, HttpErrorCode } from '@teable/core';
 import { PrismaService } from '@teable/db-main-prisma';
 import type { ICreateBaseShareRo, IUpdateBaseShareRo, IBaseShareVo } from '@teable/openapi';
+import { BaseNodeResourceType } from '@teable/openapi';
 import { ClsService } from 'nestjs-cls';
 import { CustomHttpException } from '../../custom.exception';
 import { PerformanceCache, PerformanceCacheService } from '../../performance-cache';
@@ -24,6 +25,30 @@ export class BaseShareService {
     await this.performanceCacheService.del(generateBaseShareListCacheKey(baseId));
   }
 
+  private async isTableNode(nodeId: string): Promise<boolean> {
+    const node = await this.prismaService.baseNode.findFirst({
+      where: { id: nodeId },
+      select: { resourceType: true },
+    });
+    return node?.resourceType === BaseNodeResourceType.Table;
+  }
+
+  /**
+   * allowEdit and allowSave are mutually exclusive:
+   * allowEdit=true → allowSave must be false
+   * allowSave=true → allowEdit must be false
+   */
+  private resolveEditSaveFlags(
+    allowEdit: boolean | null | undefined,
+    allowSave: boolean | null | undefined
+  ): { allowEdit: boolean | null; allowSave: boolean | null } {
+    const edit = allowEdit ?? null;
+    const save = allowSave ?? null;
+    if (edit) return { allowEdit: true, allowSave: false };
+    if (save) return { allowEdit: false, allowSave: true };
+    return { allowEdit: edit, allowSave: save };
+  }
+
   private formatBaseShareVo(share: {
     baseId: string;
     shareId: string;
@@ -31,6 +56,7 @@ export class BaseShareService {
     nodeId: string;
     allowSave: boolean | null;
     allowCopy: boolean | null;
+    allowEdit: boolean | null;
     enabled: boolean;
   }): IBaseShareVo {
     return {
@@ -40,11 +66,20 @@ export class BaseShareService {
       nodeId: share.nodeId,
       allowSave: share.allowSave,
       allowCopy: share.allowCopy,
+      allowEdit: share.allowEdit,
       enabled: share.enabled,
     };
   }
 
   async createBaseShare(baseId: string, data: ICreateBaseShareRo): Promise<IBaseShareVo> {
+    // allowEdit is only valid for table nodes
+    if (data.allowEdit && !(await this.isTableNode(data.nodeId))) {
+      throw new CustomHttpException(
+        'allowEdit is only supported for table nodes',
+        HttpErrorCode.VALIDATION_ERROR
+      );
+    }
+
     const userId = this.cls.get('user.id');
 
     // Check if a share already exists for this node
@@ -54,13 +89,25 @@ export class BaseShareService {
     if (existingShare) {
       // If existing share is disabled, re-enable it
       if (!existingShare.enabled) {
+        const resolvedEdit = data.allowEdit ?? existingShare.allowEdit;
+        if (resolvedEdit && !(await this.isTableNode(data.nodeId))) {
+          throw new CustomHttpException(
+            'allowEdit is only supported for table nodes',
+            HttpErrorCode.VALIDATION_ERROR
+          );
+        }
+        const { allowEdit, allowSave } = this.resolveEditSaveFlags(
+          resolvedEdit,
+          data.allowSave ?? existingShare.allowSave
+        );
         const updated = await this.prismaService.baseShare.update({
           where: { id: existingShare.id },
           data: {
             enabled: true,
             password: data.password || existingShare.password,
-            allowSave: data.allowSave ?? existingShare.allowSave,
+            allowSave,
             allowCopy: data.allowCopy ?? existingShare.allowCopy,
+            allowEdit,
           },
         });
         // Invalidate cache when re-enabling share
@@ -79,14 +126,16 @@ export class BaseShareService {
     }
 
     const shareId = generateShareId();
+    const { allowEdit, allowSave } = this.resolveEditSaveFlags(data.allowEdit, data.allowSave);
     const share = await this.prismaService.baseShare.create({
       data: {
         baseId,
         shareId,
         password: data.password || null,
         nodeId: data.nodeId,
-        allowSave: data.allowSave,
+        allowSave,
         allowCopy: data.allowCopy,
+        allowEdit,
         createdBy: userId,
       },
     });
@@ -144,12 +193,25 @@ export class BaseShareService {
       });
     }
 
+    if (data.allowEdit && !(await this.isTableNode(share.nodeId))) {
+      throw new CustomHttpException(
+        'allowEdit is only supported for table nodes',
+        HttpErrorCode.VALIDATION_ERROR
+      );
+    }
+
+    const { allowEdit, allowSave } = this.resolveEditSaveFlags(
+      data.allowEdit !== undefined ? data.allowEdit : share.allowEdit,
+      data.allowSave !== undefined ? data.allowSave : share.allowSave
+    );
+
     const updated = await this.prismaService.baseShare.update({
       where: { id: share.id },
       data: {
         password: data.password !== undefined ? data.password : share.password,
-        allowSave: data.allowSave !== undefined ? data.allowSave : share.allowSave,
+        allowSave,
         allowCopy: data.allowCopy !== undefined ? data.allowCopy : share.allowCopy,
+        allowEdit,
         enabled: data.enabled !== undefined ? data.enabled : share.enabled,
       },
     });
diff --git a/apps/nestjs-backend/src/features/integrity/integrity-v2.service.ts b/apps/nestjs-backend/src/features/integrity/integrity-v2.service.ts
index e08145bb77..be5cfbe6a6 100644
--- a/apps/nestjs-backend/src/features/integrity/integrity-v2.service.ts
+++ b/apps/nestjs-backend/src/features/integrity/integrity-v2.service.ts
@@ -3,7 +3,11 @@ import type {
   IV2BaseSchemaIntegrityRepairRo,
   IV2SchemaIntegrityFilterStatus,
   IV2SchemaIntegrityCheckResult,
+  IV2SchemaIntegrityI18nMessage,
+  IV2SchemaIntegrityManualRepairSchema,
+  IV2SchemaIntegrityManualRepairSchemaProperty,
   IV2SchemaIntegrityRepairResult,
+  IV2SchemaIntegrityRepairCapability,
   IV2SchemaIntegrityRepairRo,
 } from '@teable/openapi';
 import { v2PostgresDbTokens } from '@teable/v2-adapter-db-postgres-pg';
@@ -13,6 +17,7 @@ import {
   PostgresSchemaIntrospector,
   type SchemaCheckResult,
   type SchemaRepairResult,
+  type SchemaRuleRepairHint,
 } from '@teable/v2-adapter-table-repository-postgres';
 import {
   BaseId,
@@ -67,6 +72,7 @@ export class IntegrityV2Service {
         table,
         repairer.repairRule(table, repairRo.fieldId, repairRo.ruleId, {
           dryRun: repairRo.dryRun,
+          targetStatuses: repairRo.targetStatuses,
         }),
         repairRo.statuses
       );
@@ -77,6 +83,7 @@ export class IntegrityV2Service {
         table,
         repairer.repairField(table, repairRo.fieldId, {
           dryRun: repairRo.dryRun,
+          targetStatuses: repairRo.targetStatuses,
         }),
         repairRo.statuses
       );
@@ -86,6 +93,7 @@ export class IntegrityV2Service {
       table,
       repairer.repairTable(table, {
         dryRun: repairRo.dryRun,
+        targetStatuses: repairRo.targetStatuses,
       }),
       repairRo.statuses
     );
@@ -206,7 +214,10 @@ export class IntegrityV2Service {
     for (const table of tables) {
       yield* this.decorateRepairStream(
         table,
-        repairer.repairTable(table, { dryRun: repairRo.dryRun }),
+        repairer.repairTable(table, {
+          dryRun: repairRo.dryRun,
+          targetStatuses: repairRo.targetStatuses,
+        }),
         repairRo.statuses
       );
     }
@@ -261,9 +272,12 @@ export class IntegrityV2Service {
       details: result.details
         ? {
             missing: this.toMutableArray(result.details.missing),
+            missingItems: this.toMutableDetailItems(result.details.missingItems),
             extra: this.toMutableArray(result.details.extra),
+            extraItems: this.toMutableDetailItems(result.details.extraItems),
           }
         : undefined,
+      repair: result.repair ? this.toMutableRepairHint(result.repair) : undefined,
       required: result.required,
       timestamp: result.timestamp,
       dependencies: result.dependencies.map((depId) => this.createScopedResultId(table, depId)),
@@ -289,10 +303,13 @@ export class IntegrityV2Service {
       details: result.details
         ? {
             missing: this.toMutableArray(result.details.missing),
+            missingItems: this.toMutableDetailItems(result.details.missingItems),
             extra: this.toMutableArray(result.details.extra),
+            extraItems: this.toMutableDetailItems(result.details.extraItems),
             statementCount: result.details.statementCount,
           }
         : undefined,
+      repair: result.repair ? this.toMutableRepairHint(result.repair) : undefined,
       required: result.required,
       timestamp: result.timestamp,
       dependencies: result.dependencies.map((depId) => this.createScopedResultId(table, depId)),
@@ -308,6 +325,127 @@ export class IntegrityV2Service {
     return values ? [...values] : undefined;
   }
 
+  private toMutableDetailItems(
+    items?: ReadonlyArray<{
+      code?: string;
+      message: {
+        key?: string;
+        values?: Readonly<Record<string, string | number | boolean>>;
+        fallback?: string;
+      };
+      description?: {
+        key?: string;
+        values?: Readonly<Record<string, string | number | boolean>>;
+        fallback?: string;
+      };
+    }>
+  ) {
+    return items?.map((item) => ({
+      code: item.code,
+      message: {
+        key: item.message.key,
+        values: item.message.values ? { ...item.message.values } : undefined,
+        fallback: item.message.fallback,
+      },
+      description: item.description
+        ? {
+            key: item.description.key,
+            values: item.description.values ? { ...item.description.values } : undefined,
+            fallback: item.description.fallback,
+          }
+        : undefined,
+    }));
+  }
+
+  private toMutableRepairHint(result: SchemaRuleRepairHint) {
+    const toMutableMessage = (message?: {
+      key?: string;
+      values?: Readonly<Record<string, string | number | boolean>>;
+      fallback?: string;
+    }): IV2SchemaIntegrityI18nMessage | undefined => {
+      if (!message) {
+        return undefined;
+      }
+
+      return {
+        key: message.key,
+        values: message.values ? { ...message.values } : undefined,
+        fallback: message.fallback,
+      };
+    };
+
+    const toMutableManualRepairProperty = (property: {
+      type: 'string' | 'boolean';
+      widget?: 'select' | 'text' | 'textarea' | 'checkbox';
+      title?: {
+        key?: string;
+        values?: Readonly<Record<string, string | number | boolean>>;
+        fallback?: string;
+      };
+      description?: {
+        key?: string;
+        values?: Readonly<Record<string, string | number | boolean>>;
+        fallback?: string;
+      };
+      options?: ReadonlyArray<{
+        value: string;
+        label: {
+          key?: string;
+          values?: Readonly<Record<string, string | number | boolean>>;
+          fallback?: string;
+        };
+        description?: {
+          key?: string;
+          values?: Readonly<Record<string, string | number | boolean>>;
+          fallback?: string;
+        };
+      }>;
+      defaultValue?: string | boolean;
+    }): IV2SchemaIntegrityManualRepairSchemaProperty => ({
+      type: property.type,
+      widget: property.widget,
+      title: toMutableMessage(property.title),
+      description: toMutableMessage(property.description),
+      options: property.options?.map((option) => ({
+        value: option.value,
+        label: {
+          key: option.label.key,
+          values: option.label.values ? { ...option.label.values } : undefined,
+          fallback: option.label.fallback,
+        },
+        description: toMutableMessage(option.description),
+      })),
+      defaultValue: property.defaultValue,
+    });
+
+    const manualRepairSchema: IV2SchemaIntegrityManualRepairSchema | undefined =
+      result.manualRepairSchema
+        ? {
+            type: result.manualRepairSchema.type,
+            title: toMutableMessage(result.manualRepairSchema.title),
+            description: toMutableMessage(result.manualRepairSchema.description),
+            submitLabel: toMutableMessage(result.manualRepairSchema.submitLabel),
+            required: result.manualRepairSchema.required
+              ? [...result.manualRepairSchema.required]
+              : undefined,
+            properties: Object.fromEntries(
+              Object.entries(result.manualRepairSchema.properties).map(([key, property]) => [
+                key,
+                toMutableManualRepairProperty(property),
+              ])
+            ),
+          }
+        : undefined;
+
+    return {
+      available: result.available,
+      mode: result.mode,
+      reason: toMutableMessage(result.reason),
+      description: toMutableMessage(result.description),
+      manualRepairSchema,
+    } satisfies IV2SchemaIntegrityRepairCapability;
+  }
+
   private createStatusFilterSet(statuses?: IV2SchemaIntegrityFilterStatus[]) {
     return statuses?.length ? new Set(statuses) : undefined;
   }
diff --git a/apps/nestjs-backend/src/features/record/open-api/record-open-api-v2.service.ts b/apps/nestjs-backend/src/features/record/open-api/record-open-api-v2.service.ts
index 7184013da9..80f2af26d9 100644
--- a/apps/nestjs-backend/src/features/record/open-api/record-open-api-v2.service.ts
+++ b/apps/nestjs-backend/src/features/record/open-api/record-open-api-v2.service.ts
@@ -1856,7 +1856,7 @@ export class RecordOpenApiV2Service {
         tableId,
         [duplicatedRecordId],
         undefined,
-        FieldKeyType.Name,
+        FieldKeyType.Id,
         undefined,
         true
       );
diff --git a/apps/nestjs-backend/src/features/record/query-builder/record-query-builder.service.ts b/apps/nestjs-backend/src/features/record/query-builder/record-query-builder.service.ts
index ab1a29daba..53736f6bff 100644
--- a/apps/nestjs-backend/src/features/record/query-builder/record-query-builder.service.ts
+++ b/apps/nestjs-backend/src/features/record/query-builder/record-query-builder.service.ts
@@ -325,9 +325,9 @@ export class RecordQueryBuilderService implements IRecordQueryBuilder {
       const rawChoices = (field.options as { choices?: { name: string }[] } | undefined)?.choices;
       const choices = Array.isArray(rawChoices) ? rawChoices : [];
       if (choices.length) {
-        const arrayLiteral = `ARRAY[${choices
-          .map(({ name }) => this.knex.raw('?', [name]).toQuery())
-          .join(', ')}]`;
+        const choiceNames = choices.map(({ name }) => name);
+        const placeholders = choiceNames.map(() => '?').join(', ');
+        const arrayLiteral = `ARRAY[${placeholders}]`;
 
         if (field.type === FieldType.MultipleSelect) {
           const firstIndexExpr = `CASE
@@ -336,7 +336,11 @@ export class RecordQueryBuilderService implements IRecordQueryBuilder {
               THEN ARRAY_POSITION(${arrayLiteral}, jsonb_path_query_first(${orderableSelection}::jsonb, '$[0]') #>> '{}')
             ELSE ARRAY_POSITION(${arrayLiteral}, ${orderableSelection}::text)
           END`;
-          qb.orderByRaw(`${firstIndexExpr} ${direction} ${nullOrdering}`);
+          // arrayLiteral appears twice in firstIndexExpr, so duplicate bindings
+          qb.orderByRaw(`${firstIndexExpr} ${direction} ${nullOrdering}`, [
+            ...choiceNames,
+            ...choiceNames,
+          ]);
           qb.orderByRaw(`${orderableSelection}::jsonb::text ${direction} ${nullOrdering}`);
           return;
         } else {
@@ -345,7 +349,7 @@ export class RecordQueryBuilderService implements IRecordQueryBuilder {
             field.dbFieldType
           );
           const arrayPositionExpr = `ARRAY_POSITION(${arrayLiteral}, ${normalizedExpr})`;
-          qb.orderByRaw(`${arrayPositionExpr} ${direction} ${nullOrdering}`);
+          qb.orderByRaw(`${arrayPositionExpr} ${direction} ${nullOrdering}`, choiceNames);
           return;
         }
       }
diff --git a/apps/nestjs-backend/src/features/record/record.service.ts b/apps/nestjs-backend/src/features/record/record.service.ts
index 58cacebb34..ef308691fa 100644
--- a/apps/nestjs-backend/src/features/record/record.service.ts
+++ b/apps/nestjs-backend/src/features/record/record.service.ts
@@ -2120,20 +2120,19 @@ export class RecordService {
             return searchArr.includes(field.id);
           })
           .filter((field) => {
-            if (
-              [CellValueType.Boolean, CellValueType.DateTime].includes(field.cellValueType) &&
-              isSearchAllFields
-            ) {
+            if (field.type === FieldType.Button) {
               return false;
             }
             if (field.cellValueType === CellValueType.Boolean) {
               return false;
             }
-            return true;
-          })
-          .filter((field) => {
-            if (field.type === FieldType.Button) {
-              return false;
+            if (isSearchAllFields) {
+              if (field.cellValueType === CellValueType.DateTime) {
+                return false;
+              }
+              if (field.cellValueType === CellValueType.Number && isNaN(Number(search[0]))) {
+                return false;
+              }
             }
             return true;
           })
diff --git a/apps/nestjs-backend/src/features/table/open-api/table-open-api.service.ts b/apps/nestjs-backend/src/features/table/open-api/table-open-api.service.ts
index 0de407f41a..cb26e83b34 100644
--- a/apps/nestjs-backend/src/features/table/open-api/table-open-api.service.ts
+++ b/apps/nestjs-backend/src/features/table/open-api/table-open-api.service.ts
@@ -763,15 +763,22 @@ export class TableOpenApiService {
 
   async getPermission(baseId: string, tableId: string): Promise<ITablePermissionVo> {
     const baseShare = this.cls.get('baseShare');
-    if (
-      this.cls.get('template') ||
-      this.cls.get('template.baseId') === baseId ||
-      baseShare?.baseId === baseId
-    ) {
+    if (this.cls.get('template') || this.cls.get('template.baseId') === baseId) {
       return this.getPermissionByPermissionMap(
         TemplateRolePermission as Record<BasePermission, boolean>
       );
     }
+    if (baseShare?.baseId === baseId) {
+      const clsPermissions = new Set(this.cls.get('permissions'));
+      // Build permission map from CLS permissions (already curated by permission service)
+      const permissionMap = { ...TemplateRolePermission } as Record<BasePermission, boolean>;
+      for (const perm of Object.keys(permissionMap) as BasePermission[]) {
+        if (clsPermissions.has(perm)) {
+          permissionMap[perm as BasePermission] = true;
+        }
+      }
+      return this.getPermissionByPermissionMap(permissionMap);
+    }
     let role: IRole | null = await this.permissionService.getRoleByBaseId(baseId);
     if (!role) {
       const { spaceId } = await this.permissionService.getUpperIdByBaseId(baseId);
diff --git a/apps/nestjs-backend/src/types/i18n.generated.ts b/apps/nestjs-backend/src/types/i18n.generated.ts
index 846d16e18a..072b9f9ef5 100644
--- a/apps/nestjs-backend/src/types/i18n.generated.ts
+++ b/apps/nestjs-backend/src/types/i18n.generated.ts
@@ -773,6 +773,15 @@ export type I18nTranslations = {
                     "chatModels": {
                         "lg": string;
                         "lgDescription": string;
+                        "md": string;
+                        "mdDescription": string;
+                        "sm": string;
+                        "smDescription": string;
+                        "inheritHint": string;
+                        "modelTiers": string;
+                        "modelTiersDescription": string;
+                        "allInheriting": string;
+                        "customized": string;
                     };
                     "actions": {
                         "title": string;
@@ -4136,6 +4145,18 @@ export type I18nTranslations = {
                     "runCheck": string;
                     "recheck": string;
                     "repair": string;
+                    "repairWarnings": string;
+                    "repairWarningsAndErrors": string;
+                    "repairRule": string;
+                    "repairUnavailable": string;
+                    "manual": string;
+                    "manualRepairNotice": string;
+                    "manualRepairNoticeWithCount": string;
+                    "manualRepairDialogTitle": string;
+                    "manualRepairDialogDescription": string;
+                    "manualRepairDialogReason": string;
+                    "manualRepairDialogHint": string;
+                    "manualRepairDialogClose": string;
                     "checking": string;
                     "repairing": string;
                     "streamError": string;
@@ -4165,6 +4186,7 @@ export type I18nTranslations = {
                         "baseCheckCompleted": string;
                         "repairCompleted": string;
                         "baseRepairCompleted": string;
+                        "skippedStatusNotSelected": string;
                     };
                     "rule": {
                         "column": string;
@@ -4204,6 +4226,21 @@ export type I18nTranslations = {
                         "systemColumnUnique": string;
                         "systemColumnPrimaryKey": string;
                         "systemColumnDefault": string;
+                        "columnUniqueMissing": string;
+                        "columnUniqueMissingDescription": string;
+                        "columnUniqueIndexMismatch": string;
+                        "columnUniqueIndexMismatchDescription": string;
+                        "foreignKeyMissing": string;
+                        "foreignKeyMissingDescription": string;
+                        "referenceMissing": string;
+                        "referenceMissingDescription": string;
+                        "symmetricFieldTargetMissing": string;
+                        "symmetricFieldWrongType": string;
+                        "symmetricFieldInvalidOptions": string;
+                        "symmetricFieldMissingBackReference": string;
+                        "symmetricFieldWrongBackReference": string;
+                        "symmetricFieldDuplicateUsage": string;
+                        "symmetricFieldDuplicateUsageDescription": string;
                     };
                     "phase": {
                         "check": string;
@@ -4233,6 +4270,34 @@ export type I18nTranslations = {
                         "manual": string;
                         "skipped": string;
                     };
+                    "manualRepairPreview": string;
+                    "manualRepairPreviewTip": string;
+                    "repairMeta": {
+                        "reason": {
+                            "alreadyValid": string;
+                            "manualRule": string;
+                            "statementGenerationFailed": string;
+                            "noStatements": string;
+                            "symmetricFieldConflict": string;
+                        };
+                        "description": {
+                            "symmetricFieldConflict": string;
+                        };
+                        "manual": {
+                            "apply": string;
+                            "symmetricField": {
+                                "title": string;
+                                "description": string;
+                                "resolutionLabel": string;
+                                "resolutionDescription": string;
+                                "option": {
+                                    "keepCurrent": string;
+                                    "keepDuplicate": string;
+                                    "convertDuplicate": string;
+                                };
+                            };
+                        };
+                    };
                 };
                 "type": string;
                 "message": string;
@@ -4535,8 +4600,12 @@ export type I18nTranslations = {
             "shareLink": string;
             "linkHolderLabel": string;
             "linkHolderCanView": string;
+            "linkHolderCanViewDesc": string;
             "linkHolderCanEdit": string;
+            "linkHolderCanEditDesc": string;
             "linkHolderCanCopyAndSave": string;
+            "linkHolderCanCopyAndSaveDesc": string;
+            "editRequiresLogin": string;
             "passwordProtection": string;
             "enterPassword": string;
             "selectNodes": string;
@@ -5155,6 +5224,13 @@ export type I18nTranslations = {
                 "queueFull": string;
                 "messageQueued": string;
             };
+            "effort": {
+                "title": string;
+                "low": string;
+                "medium": string;
+                "high": string;
+                "max": string;
+            };
         };
         "download": {
             "allAttachments": {
diff --git a/apps/nestjs-backend/test/base-share.e2e-spec.ts b/apps/nestjs-backend/test/base-share.e2e-spec.ts
index bfd548a307..978cc04d63 100644
--- a/apps/nestjs-backend/test/base-share.e2e-spec.ts
+++ b/apps/nestjs-backend/test/base-share.e2e-spec.ts
@@ -1,7 +1,7 @@
 import type { INestApplication } from '@nestjs/common';
 import type { IFieldRo, ILookupOptionsRo } from '@teable/core';
 import { FieldType, Relationship } from '@teable/core';
-import type { IBaseNodeVo, IGetBaseShareVo } from '@teable/openapi';
+import type { IBaseNodeVo, IGetBaseShareVo, ITablePermissionVo } from '@teable/openapi';
 import {
   BASE_SHARE_AUTH,
   BASE_SHARE_ID_HEADER,
@@ -10,13 +10,16 @@ import {
   createBase,
   createBaseNode,
   createBaseShare,
+  CREATE_RECORD,
   createField,
   createSpace,
+  DELETE_RECORD_URL,
   deleteBaseShare,
   deleteSpace,
   GET_BASE_NODE_LIST,
   GET_BASE_NODE_TREE,
   GET_BASE_SHARE,
+  GET_TABLE_PERMISSION,
   getBaseNodeList,
   getBaseShareByNodeId,
   getFields,
@@ -24,10 +27,13 @@ import {
   listBaseShare,
   moveBaseNode,
   refreshBaseShare,
+  UPDATE_RECORD,
   updateBaseShare,
   urlBuilder,
 } from '@teable/openapi';
+import type { AxiosInstance } from 'axios';
 import { createAnonymousUserAxios } from './utils/axios-instance/anonymous-user';
+import { createNewUserAxios } from './utils/axios-instance/new-user';
 import { getError } from './utils/get-error';
 import {
   createTable,
@@ -1279,4 +1285,253 @@ describe('BaseShareController (e2e)', () => {
       expect(nodeIds.has(rootTableNodeId)).toBe(false);
     });
   });
+
+  describe('BaseShare - allowEdit permission', () => {
+    let editBaseId: string;
+    let editTableId: string;
+    let editTableNodeId: string;
+    let editFolderNodeId: string;
+    let loggedInUser: AxiosInstance;
+    const createdShareIds: string[] = [];
+
+    beforeAll(async () => {
+      const base = await createBase({
+        name: 'allowEdit-e2e',
+        spaceId: globalThis.testConfig.spaceId,
+      }).then((res) => res.data);
+      editBaseId = base.id;
+
+      const table = await createTable(editBaseId, { name: 'edit-table' });
+      editTableId = table.id;
+
+      const folder = await createBaseNode(editBaseId, {
+        resourceType: BaseNodeResourceType.Folder,
+        name: 'edit-folder',
+      });
+      editFolderNodeId = folder.data.id;
+
+      const nodeList = await getBaseNodeList(editBaseId);
+      const tableNode = nodeList.data.find((n) => n.resourceId === editTableId);
+      if (!tableNode) throw new Error('Table node not found');
+      editTableNodeId = tableNode.id;
+
+      loggedInUser = await createNewUserAxios({
+        email: 'allow-edit-e2e@test.com',
+        password: 'TestPassword123!',
+      });
+    });
+
+    afterAll(async () => {
+      await permanentDeleteBase(editBaseId);
+    });
+
+    afterEach(async () => {
+      for (const shareId of createdShareIds) {
+        await deleteBaseShare(editBaseId, shareId).catch(() => undefined);
+      }
+      createdShareIds.length = 0;
+    });
+
+    it('should create share with allowEdit for table node', async () => {
+      const res = await createBaseShare(editBaseId, {
+        nodeId: editTableNodeId,
+        allowEdit: true,
+      });
+      createdShareIds.push(res.data.shareId);
+      expect(res.status).toEqual(201);
+      expect(res.data.allowEdit).toBe(true);
+      // allowEdit implies allowSave is false (mutually exclusive)
+      expect(res.data.allowSave).toBe(false);
+    });
+
+    it('should reject allowEdit for folder node', async () => {
+      const error = await getError(() =>
+        createBaseShare(editBaseId, {
+          nodeId: editFolderNodeId,
+          allowEdit: true,
+        })
+      );
+      expect(error?.status).toEqual(400);
+    });
+
+    it('should enforce allowEdit/allowSave mutual exclusivity on create', async () => {
+      const res = await createBaseShare(editBaseId, {
+        nodeId: editTableNodeId,
+        allowEdit: true,
+        allowSave: true,
+      });
+      createdShareIds.push(res.data.shareId);
+      // allowEdit takes precedence
+      expect(res.data.allowEdit).toBe(true);
+      expect(res.data.allowSave).toBe(false);
+    });
+
+    it('should enforce allowEdit/allowSave mutual exclusivity on update', async () => {
+      const share = await createBaseShare(editBaseId, {
+        nodeId: editTableNodeId,
+        allowEdit: false,
+        allowSave: true,
+      });
+      createdShareIds.push(share.data.shareId);
+      expect(share.data.allowSave).toBe(true);
+      expect(share.data.allowEdit).toBe(false);
+
+      // Switch to allowEdit
+      const updated = await updateBaseShare(editBaseId, share.data.shareId, {
+        allowEdit: true,
+      });
+      expect(updated.data.allowEdit).toBe(true);
+      expect(updated.data.allowSave).toBe(false);
+    });
+
+    it('should re-enable soft-deleted share and inherit old settings', async () => {
+      // Create a share with specific settings
+      const share = await createBaseShare(editBaseId, {
+        nodeId: editTableNodeId,
+        allowEdit: true,
+        allowCopy: true,
+      });
+      createdShareIds.push(share.data.shareId);
+      expect(share.data.allowEdit).toBe(true);
+      expect(share.data.allowCopy).toBe(true);
+
+      // Soft-delete it
+      await deleteBaseShare(editBaseId, share.data.shareId);
+
+      // Re-create with same nodeId — should re-enable and inherit old settings
+      const reEnabled = await createBaseShare(editBaseId, {
+        nodeId: editTableNodeId,
+      });
+      createdShareIds.push(reEnabled.data.shareId);
+      expect(reEnabled.data.enabled).toBe(true);
+      expect(reEnabled.data.allowEdit).toBe(true);
+      expect(reEnabled.data.allowCopy).toBe(true);
+    });
+
+    it('should grant editor-level permissions to logged-in user with allowEdit', async () => {
+      const share = await createBaseShare(editBaseId, {
+        nodeId: editTableNodeId,
+        allowEdit: true,
+      });
+      createdShareIds.push(share.data.shareId);
+
+      const permRes = await loggedInUser.get<ITablePermissionVo>(
+        urlBuilder(GET_TABLE_PERMISSION, { baseId: editBaseId, tableId: editTableId }),
+        { headers: { [BASE_SHARE_ID_HEADER]: share.data.shareId } }
+      );
+      expect(permRes.status).toEqual(200);
+      // Editor-level: can create/update/delete records
+      expect(permRes.data.record['record|create']).toBe(true);
+      expect(permRes.data.record['record|update']).toBe(true);
+      expect(permRes.data.record['record|delete']).toBe(true);
+      // Excluded: view|share must be denied
+      expect(permRes.data.view['view|share']).toBeFalsy();
+    });
+
+    it('should only grant read-only permissions to anonymous user even with allowEdit', async () => {
+      const share = await createBaseShare(editBaseId, {
+        nodeId: editTableNodeId,
+        allowEdit: true,
+      });
+      createdShareIds.push(share.data.shareId);
+
+      const permRes = await anonymousUser.get<ITablePermissionVo>(
+        urlBuilder(GET_TABLE_PERMISSION, { baseId: editBaseId, tableId: editTableId }),
+        { headers: { [BASE_SHARE_ID_HEADER]: share.data.shareId } }
+      );
+      expect(permRes.status).toEqual(200);
+      // Anonymous user should NOT have write permissions
+      expect(permRes.data.record['record|create']).toBeFalsy();
+      expect(permRes.data.record['record|update']).toBeFalsy();
+      expect(permRes.data.record['record|delete']).toBeFalsy();
+    });
+
+    it('should allow logged-in user to create records via allowEdit share', async () => {
+      const share = await createBaseShare(editBaseId, {
+        nodeId: editTableNodeId,
+        allowEdit: true,
+      });
+      createdShareIds.push(share.data.shareId);
+
+      const fields = await getFields(editTableId);
+      const firstField = fields.data[0];
+
+      const createRes = await loggedInUser.post(
+        urlBuilder(CREATE_RECORD, { tableId: editTableId }),
+        { records: [{ fields: { [firstField.id]: 'share-edit-test' } }], fieldKeyType: 'id' },
+        { headers: { [BASE_SHARE_ID_HEADER]: share.data.shareId } }
+      );
+      expect(createRes.status).toEqual(201);
+      expect(createRes.data.records).toHaveLength(1);
+
+      const recordId = createRes.data.records[0].id;
+
+      // Update the record
+      const updateRes = await loggedInUser.patch(
+        urlBuilder(UPDATE_RECORD, { tableId: editTableId, recordId }),
+        { record: { fields: { [firstField.id]: 'updated-via-share' } }, fieldKeyType: 'id' },
+        { headers: { [BASE_SHARE_ID_HEADER]: share.data.shareId } }
+      );
+      expect(updateRes.status).toEqual(200);
+
+      // Delete the record
+      const deleteRes = await loggedInUser.delete(
+        urlBuilder(DELETE_RECORD_URL, { tableId: editTableId, recordId }),
+        { headers: { [BASE_SHARE_ID_HEADER]: share.data.shareId } }
+      );
+      expect(deleteRes.status).toEqual(200);
+    });
+
+    it('should deny anonymous user record creation even with allowEdit', async () => {
+      const share = await createBaseShare(editBaseId, {
+        nodeId: editTableNodeId,
+        allowEdit: true,
+      });
+      createdShareIds.push(share.data.shareId);
+
+      const fields = await getFields(editTableId);
+      const firstField = fields.data[0];
+
+      const error = await getError(() =>
+        anonymousUser.post(
+          urlBuilder(CREATE_RECORD, { tableId: editTableId }),
+          { records: [{ fields: { [firstField.id]: 'should-fail' } }], fieldKeyType: 'id' },
+          { headers: { [BASE_SHARE_ID_HEADER]: share.data.shareId } }
+        )
+      );
+      expect(error?.status).toEqual(403);
+    });
+
+    it('should cap permissions at share level even for base owner', async () => {
+      // The default test user is the base owner
+      const share = await createBaseShare(editBaseId, {
+        nodeId: editTableNodeId,
+        allowEdit: true,
+      });
+      createdShareIds.push(share.data.shareId);
+
+      // Access via share header — should get editor-level, not owner-level
+      const permRes = await loggedInUser.get<ITablePermissionVo>(
+        urlBuilder(GET_TABLE_PERMISSION, { baseId: editBaseId, tableId: editTableId }),
+        { headers: { [BASE_SHARE_ID_HEADER]: share.data.shareId } }
+      );
+      expect(permRes.status).toEqual(200);
+      // view|share is excluded from share permissions, even though owner normally has it
+      expect(permRes.data.view['view|share']).toBeFalsy();
+    });
+
+    it('should include allowEdit in shareMeta via public API', async () => {
+      const share = await createBaseShare(editBaseId, {
+        nodeId: editTableNodeId,
+        allowEdit: true,
+      });
+      createdShareIds.push(share.data.shareId);
+
+      const res = await anonymousUser.get<IGetBaseShareVo>(
+        urlBuilder(GET_BASE_SHARE, { shareId: share.data.shareId })
+      );
+      expect(res.status).toEqual(200);
+      expect(res.data.shareMeta.allowEdit).toBe(true);
+    });
+  });
 });
diff --git a/apps/nestjs-backend/test/conditional-rollup.e2e-spec.ts b/apps/nestjs-backend/test/conditional-rollup.e2e-spec.ts
index 9907fbcfe7..4356001c48 100644
--- a/apps/nestjs-backend/test/conditional-rollup.e2e-spec.ts
+++ b/apps/nestjs-backend/test/conditional-rollup.e2e-spec.ts
@@ -4366,138 +4366,4 @@ describe('OpenAPI Conditional Rollup field (e2e)', () => {
       expect(bobSummary.fields[sumWithoutExcludedField.id]).toEqual(7);
     });
   });
-
-  describe('v2 update field hasError propagation', () => {
-    const isForceV2 = process.env.FORCE_V2_ALL === 'true';
-    const itV2Only = isForceV2 ? it : it.skip;
-
-    itV2Only('marks conditional rollup as errored when filter field is deleted', async () => {
-      const foreign = await createTable(baseId, {
-        name: 'V2CondRollupFilterDel_Foreign',
-        fields: [
-          { name: 'Title', type: FieldType.SingleLineText } as IFieldRo,
-          { name: 'Amount', type: FieldType.Number } as IFieldRo,
-          { name: 'Status', type: FieldType.SingleLineText } as IFieldRo,
-        ],
-        records: [
-          { fields: { Title: 'Alpha', Amount: 2, Status: 'Active' } },
-          { fields: { Title: 'Beta', Amount: 4, Status: 'Active' } },
-          { fields: { Title: 'Gamma', Amount: 6, Status: 'Inactive' } },
-        ],
-      });
-      const host = await createTable(baseId, {
-        name: 'V2CondRollupFilterDel_Host',
-        fields: [{ name: 'Label', type: FieldType.SingleLineText } as IFieldRo],
-        records: [{ fields: { Label: 'Row 1' } }],
-      });
-      const amountId = foreign.fields.find((f) => f.name === 'Amount')!.id;
-      const statusId = foreign.fields.find((f) => f.name === 'Status')!.id;
-
-      try {
-        // Create conditional rollup without filter
-        let rollupField = await createField(host.id, {
-          name: 'Filtered Sum',
-          type: FieldType.ConditionalRollup,
-          options: {
-            foreignTableId: foreign.id,
-            lookupFieldId: amountId,
-            expression: 'sum({values})',
-          },
-        } as IFieldRo);
-
-        // Convert to add a filter referencing statusId
-        rollupField = await convertField(host.id, rollupField.id, {
-          name: 'Filtered Sum',
-          type: FieldType.ConditionalRollup,
-          options: {
-            foreignTableId: foreign.id,
-            lookupFieldId: amountId,
-            expression: 'sum({values})',
-            filter: {
-              conjunction: 'and',
-              filterSet: [{ fieldId: statusId, operator: 'is', value: 'Active' }],
-            },
-          },
-        } as IFieldRo);
-
-        const hostRecord = await getRecord(host.id, host.records[0].id);
-        expect(hostRecord.fields[rollupField.id]).toEqual(6);
-
-        // Delete the filter field from the foreign table
-        await deleteField(foreign.id, statusId);
-
-        const hostFields = await getFields(host.id);
-        const erroredField = hostFields.find((f) => f.id === rollupField.id)!;
-        expect(erroredField.hasError).toBe(true);
-      } finally {
-        await permanentDeleteTable(baseId, host.id);
-        await permanentDeleteTable(baseId, foreign.id);
-      }
-    });
-
-    itV2Only(
-      'marks conditional rollup as errored when lookup field type becomes incompatible',
-      async () => {
-        const foreign = await createTable(baseId, {
-          name: 'V2CondRollupTypeErr_Foreign',
-          fields: [
-            { name: 'Title', type: FieldType.SingleLineText } as IFieldRo,
-            { name: 'Amount', type: FieldType.Number } as IFieldRo,
-          ],
-          records: [
-            { fields: { Title: 'Alpha', Amount: 2 } },
-            { fields: { Title: 'Beta', Amount: 4 } },
-            { fields: { Title: 'Gamma', Amount: 6 } },
-          ],
-        });
-        const host = await createTable(baseId, {
-          name: 'V2CondRollupTypeErr_Host',
-          fields: [{ name: 'Label', type: FieldType.SingleLineText } as IFieldRo],
-          records: [{ fields: { Label: 'Row 1' } }],
-        });
-        const amountId = foreign.fields.find((f) => f.name === 'Amount')!.id;
-        const hostRecordId = host.records[0].id;
-
-        try {
-          const rollupField = await createField(host.id, {
-            name: 'Sum Amount',
-            type: FieldType.ConditionalRollup,
-            options: {
-              foreignTableId: foreign.id,
-              lookupFieldId: amountId,
-              expression: 'sum({values})',
-            },
-          } as IFieldRo);
-
-          const baseline = await getRecord(host.id, hostRecordId);
-          expect(baseline.fields[rollupField.id]).toEqual(12);
-
-          // Convert numeric lookup field to SingleSelect (incompatible with sum)
-          await convertField(foreign.id, amountId, {
-            name: 'Amount (Select)',
-            type: FieldType.SingleSelect,
-            options: {
-              choices: [
-                { name: '2', color: Colors.Blue },
-                { name: '4', color: Colors.Green },
-                { name: '6', color: Colors.Orange },
-              ],
-            },
-          } as IFieldRo);
-
-          let erroredField: IFieldVo | undefined;
-          for (let attempt = 0; attempt < 10; attempt++) {
-            const fieldsAfterConversion = await getFields(host.id);
-            erroredField = fieldsAfterConversion.find((f) => f.id === rollupField.id);
-            if (erroredField?.hasError) break;
-            await new Promise((resolve) => setTimeout(resolve, 200));
-          }
-          expect(erroredField?.hasError).toBe(true);
-        } finally {
-          await permanentDeleteTable(baseId, host.id);
-          await permanentDeleteTable(baseId, foreign.id);
-        }
-      }
-    );
-  });
 });
diff --git a/apps/nestjs-backend/test/field-converting.e2e-spec.ts b/apps/nestjs-backend/test/field-converting.e2e-spec.ts
index ca9aa28bcf..458da47be6 100644
--- a/apps/nestjs-backend/test/field-converting.e2e-spec.ts
+++ b/apps/nestjs-backend/test/field-converting.e2e-spec.ts
@@ -3866,95 +3866,6 @@ describe('OpenAPI Freely perform column transformations (e2e)', () => {
       }
     );
 
-    it.skipIf(!canRunCanaryV2)(
-      'should remove conditional lookup sort and limit when convert payload omits them in v2',
-      async () => {
-        const statusField = await createField(table2.id, {
-          name: 'Status',
-          type: FieldType.SingleLineText,
-        });
-        const scoreField = await createField(table2.id, {
-          name: 'Score',
-          type: FieldType.Number,
-        });
-        const statusFilterField = await createField(table1.id, {
-          name: 'Status Filter',
-          type: FieldType.SingleLineText,
-        });
-
-        await updateRecordByApi(table2.id, table2.records[0].id, table2.fields[0].id, 'row-1');
-        await updateRecordByApi(table2.id, table2.records[1].id, table2.fields[0].id, 'row-2');
-        await updateRecordByApi(table2.id, table2.records[0].id, statusField.id, 'Active');
-        await updateRecordByApi(table2.id, table2.records[1].id, statusField.id, 'Active');
-        await updateRecordByApi(table2.id, table2.records[0].id, scoreField.id, 10);
-        await updateRecordByApi(table2.id, table2.records[1].id, scoreField.id, 20);
-        await updateRecordByApi(table1.id, table1.records[0].id, statusFilterField.id, 'Active');
-
-        const lookupField = await createField(table1.id, {
-          type: FieldType.SingleLineText,
-          isLookup: true,
-          isConditionalLookup: true,
-          lookupOptions: {
-            foreignTableId: table2.id,
-            lookupFieldId: table2.fields[0].id,
-            filter: {
-              conjunction: 'and',
-              filterSet: [
-                {
-                  fieldId: statusField.id,
-                  operator: 'is',
-                  value: { type: 'field', fieldId: statusFilterField.id },
-                },
-              ],
-            },
-            sort: {
-              fieldId: scoreField.id,
-              order: SortFunc.Desc,
-            },
-            limit: 1,
-          },
-        });
-
-        const beforeRecord = await getRecord(table1.id, table1.records[0].id);
-        expect(beforeRecord.fields[lookupField.id]).toEqual(['row-2']);
-
-        const updatedField = await convertFieldByCanaryV2(table1.id, lookupField.id, {
-          type: FieldType.SingleLineText,
-          isLookup: true,
-          isConditionalLookup: true,
-          lookupOptions: {
-            foreignTableId: table2.id,
-            lookupFieldId: table2.fields[0].id,
-            filter: {
-              conjunction: 'and',
-              filterSet: [
-                {
-                  fieldId: statusField.id,
-                  operator: 'is',
-                  value: { type: 'field', fieldId: statusFilterField.id },
-                },
-              ],
-            },
-          },
-        });
-
-        const updatedLookupOptions = updatedField.lookupOptions as IConditionalLookupOptions;
-        expect(updatedLookupOptions.sort).toBeUndefined();
-        expect(updatedLookupOptions.limit).toBeUndefined();
-
-        const refreshedField = await getField(table1.id, lookupField.id);
-        const refreshedLookupOptions = refreshedField.lookupOptions as IConditionalLookupOptions;
-        expect(refreshedLookupOptions.sort).toBeUndefined();
-        expect(refreshedLookupOptions.limit).toBeUndefined();
-
-        const afterRecord = await getRecord(table1.id, table1.records[0].id);
-        expect([...(afterRecord.fields[lookupField.id] as string[])].sort()).toEqual([
-          'row-1',
-          'row-2',
-        ]);
-      }
-    );
-
     it.skipIf(!canRunCanaryV2)(
       'should remove conditional lookup sort and limit for formula inner type when switch is off in v2',
       async () => {
@@ -4089,6 +4000,52 @@ describe('OpenAPI Freely perform column transformations (e2e)', () => {
       }
     );
 
+    it.skipIf(!canRunCanaryV2)(
+      'should remove link filter options when convert payload omits them in v2',
+      async () => {
+        const statusField = await createField(table2.id, {
+          name: 'Status',
+          type: FieldType.SingleLineText,
+        });
+        await updateRecordByApi(table2.id, table2.records[0].id, statusField.id, 'Active');
+
+        const linkField = await createField(table1.id, {
+          type: FieldType.Link,
+          options: {
+            relationship: Relationship.ManyOne,
+            foreignTableId: table2.id,
+            lookupFieldId: table2.fields[0].id,
+            filterByViewId: table2.defaultViewId,
+            visibleFieldIds: [table2.fields[0].id],
+            filter: {
+              conjunction: 'and',
+              filterSet: [{ fieldId: statusField.id, operator: 'is', value: 'Active' }],
+            },
+          },
+        });
+
+        const updatedField = await convertFieldByCanaryV2(table1.id, linkField.id, {
+          type: FieldType.Link,
+          options: {
+            relationship: Relationship.ManyOne,
+            foreignTableId: table2.id,
+            lookupFieldId: table2.fields[0].id,
+          },
+        });
+
+        const updatedOptions = updatedField.options as ILinkFieldOptions;
+        expect(updatedOptions.filterByViewId).toBeUndefined();
+        expect(updatedOptions.visibleFieldIds).toBeUndefined();
+        expect(updatedOptions.filter).toBeUndefined();
+
+        const refreshedField = await getField(table1.id, linkField.id);
+        const refreshedOptions = refreshedField.options as ILinkFieldOptions;
+        expect(refreshedOptions.filterByViewId).toBeUndefined();
+        expect(refreshedOptions.visibleFieldIds).toBeUndefined();
+        expect(refreshedOptions.filter).toBeUndefined();
+      }
+    );
+
     it.skipIf(!canRunCanaryV2)(
       'should preserve formula datetime formatting when converting conditional lookup inner type in v2',
       async () => {
@@ -4234,52 +4191,6 @@ describe('OpenAPI Freely perform column transformations (e2e)', () => {
       }
     );
 
-    it.skipIf(!canRunCanaryV2)(
-      'should remove link filter options when convert payload omits them in v2',
-      async () => {
-        const statusField = await createField(table2.id, {
-          name: 'Status',
-          type: FieldType.SingleLineText,
-        });
-        await updateRecordByApi(table2.id, table2.records[0].id, statusField.id, 'Active');
-
-        const linkField = await createField(table1.id, {
-          type: FieldType.Link,
-          options: {
-            relationship: Relationship.ManyOne,
-            foreignTableId: table2.id,
-            lookupFieldId: table2.fields[0].id,
-            filterByViewId: table2.defaultViewId,
-            visibleFieldIds: [table2.fields[0].id],
-            filter: {
-              conjunction: 'and',
-              filterSet: [{ fieldId: statusField.id, operator: 'is', value: 'Active' }],
-            },
-          },
-        });
-
-        const updatedField = await convertFieldByCanaryV2(table1.id, linkField.id, {
-          type: FieldType.Link,
-          options: {
-            relationship: Relationship.ManyOne,
-            foreignTableId: table2.id,
-            lookupFieldId: table2.fields[0].id,
-          },
-        });
-
-        const updatedOptions = updatedField.options as ILinkFieldOptions;
-        expect(updatedOptions.filterByViewId).toBeUndefined();
-        expect(updatedOptions.visibleFieldIds).toBeUndefined();
-        expect(updatedOptions.filter).toBeUndefined();
-
-        const refreshedField = await getField(table1.id, linkField.id);
-        const refreshedOptions = refreshedField.options as ILinkFieldOptions;
-        expect(refreshedOptions.filterByViewId).toBeUndefined();
-        expect(refreshedOptions.visibleFieldIds).toBeUndefined();
-        expect(refreshedOptions.filter).toBeUndefined();
-      }
-    );
-
     it('should change lookupField from link to text', async () => {
       const linkFieldRo: IFieldRo = {
         type: FieldType.Link,
@@ -4701,93 +4612,6 @@ describe('OpenAPI Freely perform column transformations (e2e)', () => {
 
       await convertField(table2.id, rollupField.id, rollupFieldRo2);
     });
-
-    it.skipIf(!canRunCanaryV2)(
-      'should remove conditional rollup sort and limit when convert payload omits them in v2',
-      async () => {
-        const statusField = await createField(table2.id, {
-          name: 'Status',
-          type: FieldType.SingleLineText,
-        });
-        const scoreField = await createField(table2.id, {
-          name: 'Score',
-          type: FieldType.Number,
-        });
-        const statusFilterField = await createField(table1.id, {
-          name: 'Status Filter',
-          type: FieldType.SingleLineText,
-        });
-
-        await updateRecordByApi(table2.id, table2.records[0].id, table2.fields[0].id, 'row-1');
-        await updateRecordByApi(table2.id, table2.records[1].id, table2.fields[0].id, 'row-2');
-        await updateRecordByApi(table2.id, table2.records[0].id, statusField.id, 'Active');
-        await updateRecordByApi(table2.id, table2.records[1].id, statusField.id, 'Active');
-        await updateRecordByApi(table2.id, table2.records[0].id, scoreField.id, 10);
-        await updateRecordByApi(table2.id, table2.records[1].id, scoreField.id, 20);
-        await updateRecordByApi(table1.id, table1.records[0].id, statusFilterField.id, 'Active');
-
-        const conditionalRollupField = await createField(table1.id, {
-          type: FieldType.ConditionalRollup,
-          options: {
-            foreignTableId: table2.id,
-            lookupFieldId: table2.fields[0].id,
-            expression: 'array_compact({values})',
-            filter: {
-              conjunction: 'and',
-              filterSet: [
-                {
-                  fieldId: statusField.id,
-                  operator: 'is',
-                  value: { type: 'field', fieldId: statusFilterField.id },
-                },
-              ],
-            },
-            sort: {
-              fieldId: scoreField.id,
-              order: SortFunc.Desc,
-            },
-            limit: 1,
-          } as IConditionalRollupFieldOptions,
-        });
-
-        const beforeRecord = await getRecord(table1.id, table1.records[0].id);
-        expect(beforeRecord.fields[conditionalRollupField.id]).toEqual(['row-2']);
-
-        const updatedField = await convertFieldByCanaryV2(table1.id, conditionalRollupField.id, {
-          type: FieldType.ConditionalRollup,
-          options: {
-            foreignTableId: table2.id,
-            lookupFieldId: table2.fields[0].id,
-            expression: 'array_compact({values})',
-            filter: {
-              conjunction: 'and',
-              filterSet: [
-                {
-                  fieldId: statusField.id,
-                  operator: 'is',
-                  value: { type: 'field', fieldId: statusFilterField.id },
-                },
-              ],
-            },
-          } as IConditionalRollupFieldOptions,
-        });
-
-        const updatedOptions = updatedField.options as IConditionalRollupFieldOptions;
-        expect(updatedOptions.sort).toBeUndefined();
-        expect(updatedOptions.limit).toBeUndefined();
-
-        const refreshedField = await getField(table1.id, conditionalRollupField.id);
-        const refreshedOptions = refreshedField.options as IConditionalRollupFieldOptions;
-        expect(refreshedOptions.sort).toBeUndefined();
-        expect(refreshedOptions.limit).toBeUndefined();
-
-        const afterRecord = await getRecord(table1.id, table1.records[0].id);
-        expect([...(afterRecord.fields[conditionalRollupField.id] as string[])].sort()).toEqual([
-          'row-1',
-          'row-2',
-        ]);
-      }
-    );
   });
 
   describe('rollup conversion regressions', () => {
diff --git a/apps/nestjs-backend/test/field.e2e-spec.ts b/apps/nestjs-backend/test/field.e2e-spec.ts
index 4b68dae6fe..705562bc48 100644
--- a/apps/nestjs-backend/test/field.e2e-spec.ts
+++ b/apps/nestjs-backend/test/field.e2e-spec.ts
@@ -21,7 +21,6 @@ import {
 } from '@teable/core';
 import { PrismaService } from '@teable/db-main-prisma';
 import type { ITableFullVo } from '@teable/openapi';
-import { convertField } from '@teable/openapi';
 import type { Knex } from 'knex';
 import type { FieldCreateEvent } from '../src/event-emitter/events';
 import { Events } from '../src/event-emitter/events';
@@ -38,7 +37,19 @@ import {
   getRecords,
 } from './utils/init-app';
 
-const isForceV2 = process.env.FORCE_V2_ALL === 'true';
+const withForceV2All = async <T>(callback: () => Promise<T>) => {
+  const previousForceV2All = process.env.FORCE_V2_ALL;
+  process.env.FORCE_V2_ALL = 'true';
+  try {
+    return await callback();
+  } finally {
+    if (previousForceV2All == null) {
+      delete process.env.FORCE_V2_ALL;
+    } else {
+      process.env.FORCE_V2_ALL = previousForceV2All;
+    }
+  }
+};
 
 describe('OpenAPI FieldController (e2e)', () => {
   let app: INestApplication;
@@ -315,79 +326,79 @@ describe('OpenAPI FieldController (e2e)', () => {
   });
 
   describe('v2 lookup option sync', () => {
-    const itIfForceV2 = isForceV2 ? it : it.skip;
-
-    itIfForceV2('ignores API-supplied choices for lookup-backed single select fields', async () => {
+    it('ignores API-supplied choices for lookup-backed single select fields', async () => {
       let hostTable: ITableFullVo | undefined;
       let foreignTable: ITableFullVo | undefined;
 
       try {
-        foreignTable = await createTable(baseId, {
-          name: 'lookup-option-sync-foreign',
-          fields: [
-            { name: 'Title', type: FieldType.SingleLineText },
-            {
-              name: 'Importance',
-              type: FieldType.SingleSelect,
-              options: {
-                choices: [
-                  { id: 'choLookupCore', name: '核心', color: Colors.Blue },
-                  { id: 'choLookupImportant', name: '重要', color: Colors.Green },
-                  { id: 'choLookupReference', name: '参考', color: Colors.Orange },
-                ],
+        await withForceV2All(async () => {
+          foreignTable = await createTable(baseId, {
+            name: 'lookup-option-sync-foreign',
+            fields: [
+              { name: 'Title', type: FieldType.SingleLineText },
+              {
+                name: 'Importance',
+                type: FieldType.SingleSelect,
+                options: {
+                  choices: [
+                    { id: 'choLookupCore', name: '核心', color: Colors.Blue },
+                    { id: 'choLookupImportant', name: '重要', color: Colors.Green },
+                    { id: 'choLookupReference', name: '参考', color: Colors.Orange },
+                  ],
+                },
               },
-            },
-          ],
-        });
-        hostTable = await createTable(baseId, {
-          name: 'lookup-option-sync-host',
-          fields: [{ name: 'Name', type: FieldType.SingleLineText }],
-        });
+            ],
+          });
+          hostTable = await createTable(baseId, {
+            name: 'lookup-option-sync-host',
+            fields: [{ name: 'Name', type: FieldType.SingleLineText }],
+          });
 
-        const foreignImportanceField = foreignTable.fields.find(
-          (field) => field.name === 'Importance'
-        )!;
-        const expectedChoices = (
-          foreignImportanceField.options as {
-            choices: Array<{ id: string; name: string; color: string }>;
-          }
-        ).choices;
-
-        const linkField = await createField(hostTable.id, {
-          name: 'Related',
-          type: FieldType.Link,
-          options: {
-            relationship: Relationship.ManyMany,
-            foreignTableId: foreignTable.id,
-          } as ILinkFieldOptionsRo,
-        });
+          const foreignImportanceField = foreignTable.fields.find(
+            (field) => field.name === 'Importance'
+          )!;
+          const expectedChoices = (
+            foreignImportanceField.options as {
+              choices: Array<{ id: string; name: string; color: string }>;
+            }
+          ).choices;
 
-        const createdLookupField = await createField(hostTable.id, {
-          name: '章节重要程度',
-          type: FieldType.SingleSelect,
-          isLookup: true,
-          lookupOptions: {
-            foreignTableId: foreignTable.id,
-            lookupFieldId: foreignImportanceField.id,
-            linkFieldId: linkField.id,
-          } as ILookupOptionsRo,
-          options: {
-            choices: [
-              { id: 'choBroken1', name: 'Option 1', color: Colors.Blue },
-              { id: 'choBroken2', name: 'Option 2', color: Colors.Green },
-            ],
-          },
-        });
+          const linkField = await createField(hostTable.id, {
+            name: 'Related',
+            type: FieldType.Link,
+            options: {
+              relationship: Relationship.ManyMany,
+              foreignTableId: foreignTable.id,
+            } as ILinkFieldOptionsRo,
+          });
 
-        expect(createdLookupField.options).toEqual({
-          choices: expectedChoices,
-        });
+          const createdLookupField = await createField(hostTable.id, {
+            name: '章节重要程度',
+            type: FieldType.SingleSelect,
+            isLookup: true,
+            lookupOptions: {
+              foreignTableId: foreignTable.id,
+              lookupFieldId: foreignImportanceField.id,
+              linkFieldId: linkField.id,
+            } as ILookupOptionsRo,
+            options: {
+              choices: [
+                { id: 'choBroken1', name: 'Option 1', color: Colors.Blue },
+                { id: 'choBroken2', name: 'Option 2', color: Colors.Green },
+              ],
+            },
+          });
 
-        const persistedLookupField = (await getFields(hostTable.id)).find(
-          (field) => field.id === createdLookupField.id
-        );
-        expect(persistedLookupField?.options).toEqual({
-          choices: expectedChoices,
+          expect(createdLookupField.options).toEqual({
+            choices: expectedChoices,
+          });
+
+          const persistedLookupField = (await getFields(hostTable.id)).find(
+            (field) => field.id === createdLookupField.id
+          );
+          expect(persistedLookupField?.options).toEqual({
+            choices: expectedChoices,
+          });
         });
       } finally {
         if (hostTable) {
@@ -399,13 +410,12 @@ describe('OpenAPI FieldController (e2e)', () => {
       }
     });
 
-    itIfForceV2(
-      'ignores API-supplied choices for conditional lookup-backed single select fields',
-      async () => {
-        let hostTable: ITableFullVo | undefined;
-        let foreignTable: ITableFullVo | undefined;
+    it('ignores API-supplied choices for conditional lookup-backed single select fields', async () => {
+      let hostTable: ITableFullVo | undefined;
+      let foreignTable: ITableFullVo | undefined;
 
-        try {
+      try {
+        await withForceV2All(async () => {
           foreignTable = await createTable(baseId, {
             name: 'conditional-lookup-option-sync-foreign',
             fields: [
@@ -484,185 +494,16 @@ describe('OpenAPI FieldController (e2e)', () => {
           expect(persistedConditionalLookupField?.options).toEqual({
             choices: expectedChoices,
           });
-        } finally {
-          if (hostTable) {
-            await permanentDeleteTable(baseId, hostTable.id);
-          }
-          if (foreignTable) {
-            await permanentDeleteTable(baseId, foreignTable.id);
-          }
-        }
-      }
-    );
-  });
-
-  describe('long text markdown showAs API', () => {
-    const itIfForceV2 = isForceV2 ? it : it.skip;
-
-    itIfForceV2('should update and clear long text showAs via convert field API', async () => {
-      let table: ITableFullVo | undefined;
-
-      try {
-        table = await createTable(baseId, {
-          name: 'long-text-show-as-update-api',
-          fields: [{ name: 'Name', type: FieldType.SingleLineText }],
-        });
-
-        const longTextField = await createField(table.id, {
-          name: 'Body',
-          type: FieldType.LongText,
         });
-
-        const markdownUpdatedResponse = await convertField(table.id, longTextField.id, {
-          name: longTextField.name,
-          type: FieldType.LongText,
-          options: {
-            showAs: {
-              type: 'markdown',
-            },
-          },
-        });
-        expect(markdownUpdatedResponse.status).toBe(200);
-
-        const persistedAfterEnable = (await getFields(table.id)).find(
-          (field) => field.id === longTextField.id
-        )!;
-        expect(persistedAfterEnable.options).toMatchObject({
-          showAs: {
-            type: 'markdown',
-          },
-        });
-
-        const clearedResponse = await convertField(table.id, longTextField.id, {
-          name: longTextField.name,
-          type: FieldType.LongText,
-          options: {
-            showAs: null,
-          },
-        });
-        expect(clearedResponse.status).toBe(200);
-
-        const persistedAfterClear = (await getFields(table.id)).find(
-          (field) => field.id === longTextField.id
-        )!;
-        expect((persistedAfterClear.options as { showAs?: unknown }).showAs).toBeUndefined();
       } finally {
-        if (table) {
-          await permanentDeleteTable(baseId, table.id);
+        if (hostTable) {
+          await permanentDeleteTable(baseId, hostTable.id);
         }
-      }
-    });
-
-    itIfForceV2(
-      'should keep lookup long text showAs cleared when API attempts to set markdown',
-      async () => {
-        let hostTable: ITableFullVo | undefined;
-        let foreignTable: ITableFullVo | undefined;
-
-        try {
-          foreignTable = await createTable(baseId, {
-            name: 'lookup-long-text-show-as-foreign',
-            fields: [
-              { name: 'Title', type: FieldType.SingleLineText },
-              {
-                name: 'Foreign Long Text',
-                type: FieldType.LongText,
-                options: {
-                  showAs: {
-                    type: 'markdown',
-                  },
-                },
-              },
-            ],
-          });
-
-          hostTable = await createTable(baseId, {
-            name: 'lookup-long-text-show-as-host',
-            fields: [{ name: 'Name', type: FieldType.SingleLineText }],
-          });
-
-          const foreignLongTextField = foreignTable.fields.find(
-            (field) => field.name === 'Foreign Long Text'
-          )!;
-
-          const linkField = await createField(hostTable.id, {
-            name: 'Related',
-            type: FieldType.Link,
-            options: {
-              relationship: Relationship.ManyMany,
-              foreignTableId: foreignTable.id,
-            } as ILinkFieldOptionsRo,
-          });
-
-          const lookupLongTextField = await createField(hostTable.id, {
-            name: 'Lookup Long Text',
-            type: FieldType.LongText,
-            isLookup: true,
-            lookupOptions: {
-              foreignTableId: foreignTable.id,
-              lookupFieldId: foreignLongTextField.id,
-              linkFieldId: linkField.id,
-            } as ILookupOptionsRo,
-          });
-
-          expect(lookupLongTextField.options).toMatchObject({
-            showAs: {
-              type: 'markdown',
-            },
-          });
-
-          const lookupOptions = lookupLongTextField.lookupOptions as ILookupOptionsRo;
-          const clearedLookupResponse = await convertField(hostTable.id, lookupLongTextField.id, {
-            name: lookupLongTextField.name,
-            type: FieldType.LongText,
-            isLookup: true,
-            lookupOptions: {
-              foreignTableId: lookupOptions.foreignTableId,
-              lookupFieldId: lookupOptions.lookupFieldId,
-              linkFieldId: lookupOptions.linkFieldId,
-            },
-            options: {
-              showAs: null,
-            },
-          });
-          expect(clearedLookupResponse.status).toBe(200);
-
-          const persistedAfterClear = (await getFields(hostTable.id)).find(
-            (field) => field.id === lookupLongTextField.id
-          )!;
-          expect((persistedAfterClear.options as { showAs?: unknown }).showAs).toBeUndefined();
-
-          const updatedLookupResponse = await convertField(hostTable.id, lookupLongTextField.id, {
-            name: lookupLongTextField.name,
-            type: FieldType.LongText,
-            isLookup: true,
-            lookupOptions: {
-              foreignTableId: lookupOptions.foreignTableId,
-              lookupFieldId: lookupOptions.lookupFieldId,
-              linkFieldId: lookupOptions.linkFieldId,
-            },
-            options: {
-              showAs: {
-                type: 'markdown',
-              },
-            },
-          });
-          expect(updatedLookupResponse.status).toBe(200);
-
-          const persistedLookupField = (await getFields(hostTable.id)).find(
-            (field) => field.id === lookupLongTextField.id
-          )!;
-          expect((persistedLookupField.options as { showAs?: unknown }).showAs).toBeUndefined();
-        } finally {
-          if (hostTable) {
-            await permanentDeleteTable(baseId, hostTable.id);
-          }
-          if (foreignTable) {
-            await permanentDeleteTable(baseId, foreignTable.id);
-          }
+        if (foreignTable) {
+          await permanentDeleteTable(baseId, foreignTable.id);
         }
       }
-    );
+    });
   });
 
   describe('should decide whether to create field validation rules based on the field type', () => {
diff --git a/apps/nestjs-backend/test/filter.e2e-spec.ts b/apps/nestjs-backend/test/filter.e2e-spec.ts
index d10454bfb1..d41d408ac7 100644
--- a/apps/nestjs-backend/test/filter.e2e-spec.ts
+++ b/apps/nestjs-backend/test/filter.e2e-spec.ts
@@ -15,6 +15,20 @@ afterAll(async () => {
   await app.close();
 });
 
+const withForceV2All = async <T>(callback: () => Promise<T>) => {
+  const previousForceV2All = process.env.FORCE_V2_ALL;
+  process.env.FORCE_V2_ALL = 'true';
+  try {
+    return await callback();
+  } finally {
+    if (previousForceV2All == null) {
+      delete process.env.FORCE_V2_ALL;
+    } else {
+      process.env.FORCE_V2_ALL = previousForceV2All;
+    }
+  }
+};
+
 async function updateViewFilter(tableId: string, viewId: string, filterRo: IFilterRo) {
   try {
     const result = await apiSetViewFilter(tableId, viewId, filterRo);
@@ -80,18 +94,17 @@ describe('OpenAPI ViewController (e2e) option (PUT)', () => {
 });
 
 // V1 does not normalize is/isNot+null through the domain FieldConditionSpecBuilder,
-// so this test only applies to V2.
-describe.skipIf(process.env.FORCE_V2_ALL !== 'true')(
-  'View filter with is/isNot null value (e2e)',
-  () => {
-    let tableId: string;
-    let viewId: string;
+// so this test must force the V2 path explicitly inside the single integration run.
+describe('View filter with is/isNot null value (e2e)', () => {
+  let tableId: string;
+  let viewId: string;
 
-    afterAll(async () => {
-      await permanentDeleteTable(baseId, tableId);
-    });
+  afterAll(async () => {
+    await permanentDeleteTable(baseId, tableId);
+  });
 
-    it('should apply view filter with is+null (checkbox) and isNotEmpty via API viewId query', async () => {
+  it('should apply view filter with is+null (checkbox) and isNotEmpty via API viewId query', async () => {
+    await withForceV2All(async () => {
       // Create table with checkbox and text fields
       const table = await createTable(baseId, {
         name: 'View Filter Null Test',
@@ -144,5 +157,5 @@ describe.skipIf(process.env.FORCE_V2_ALL !== 'true')(
       const names = records.map((r) => r.fields.Name).sort();
       expect(names).toEqual(['row2', 'row3']);
     });
-  }
-);
+  });
+});
diff --git a/apps/nestjs-backend/test/group.e2e-spec.ts b/apps/nestjs-backend/test/group.e2e-spec.ts
index 6d7d599e53..3631669ead 100644
--- a/apps/nestjs-backend/test/group.e2e-spec.ts
+++ b/apps/nestjs-backend/test/group.e2e-spec.ts
@@ -695,3 +695,118 @@ describe('Lookup multiple select respects choice order when sorting groups', ()
     expect(recordCategories).toEqual([choiceOrder[0], choiceOrder[1], choiceOrder[2]]);
   });
 });
+
+describe('Single select grouping with special characters in choice names', () => {
+  const choiceOrder = ['Pending?', 'Done!', 'N/A'] as const;
+  const choiceDefinitions = choiceOrder.map((name, index) => ({
+    id: `sc-choice-${index}`,
+    name,
+    color: index === 0 ? Colors.Red : index === 1 ? Colors.Green : Colors.Blue,
+  }));
+  const statusFieldName = 'Status';
+  const itemFieldName = 'Item';
+
+  let table: ITableFullVo;
+  let statusField: IFieldRo;
+
+  beforeAll(async () => {
+    table = await createTable(baseId, {
+      name: 'group_special_char_choices',
+      fields: [
+        { name: itemFieldName, type: FieldType.SingleLineText },
+        {
+          name: statusFieldName,
+          type: FieldType.SingleSelect,
+          options: { choices: choiceDefinitions },
+        },
+      ],
+      records: [
+        { fields: { [itemFieldName]: 'r1', [statusFieldName]: 'Pending?' } },
+        { fields: { [itemFieldName]: 'r2', [statusFieldName]: 'Done!' } },
+        { fields: { [itemFieldName]: 'r3', [statusFieldName]: 'N/A' } },
+      ],
+    });
+    statusField = table.fields!.find(
+      ({ name, type }) => name === statusFieldName && type === FieldType.SingleSelect
+    ) as IFieldRo;
+  });
+
+  afterAll(async () => {
+    await permanentDeleteTable(baseId, table.id);
+  });
+
+  it('groups correctly when choice name contains ? character', async () => {
+    const query: IGetRecordsRo = {
+      fieldKeyType: FieldKeyType.Id,
+      groupBy: [{ fieldId: statusField.id!, order: SortFunc.Asc }],
+    };
+    const { records, extra } = await getRecords(table.id, query);
+
+    const headerValues =
+      extra?.groupPoints
+        ?.filter((point): point is IGroupHeaderPoint => point.type === GroupPointType.Header)
+        .map((point) => point.value as string) ?? [];
+
+    expect(headerValues).toEqual([...choiceOrder]);
+    expect(records).toHaveLength(3);
+
+    const statusSequence = records.map((record) => record.fields?.[statusField.id!] as string);
+    expect(statusSequence).toEqual([...choiceOrder]);
+  });
+});
+
+describe('Multiple select grouping with special characters in choice names', () => {
+  const choiceOrder = ['Alpha?', 'Beta!', 'Gamma'] as const;
+  const choiceDefinitions = choiceOrder.map((name, index) => ({
+    id: `ms-choice-${index}`,
+    name,
+    color: index === 0 ? Colors.Red : index === 1 ? Colors.Green : Colors.Blue,
+  }));
+  const tagFieldName = 'Tags';
+  const itemFieldName = 'Item';
+
+  let table: ITableFullVo;
+  let tagField: IFieldRo;
+
+  beforeAll(async () => {
+    table = await createTable(baseId, {
+      name: 'group_multi_select_special_char',
+      fields: [
+        { name: itemFieldName, type: FieldType.SingleLineText },
+        {
+          name: tagFieldName,
+          type: FieldType.MultipleSelect,
+          options: { choices: choiceDefinitions },
+        },
+      ],
+      records: [
+        { fields: { [itemFieldName]: 'r1', [tagFieldName]: ['Alpha?'] } },
+        { fields: { [itemFieldName]: 'r2', [tagFieldName]: ['Beta!'] } },
+        { fields: { [itemFieldName]: 'r3', [tagFieldName]: ['Gamma'] } },
+      ],
+    });
+    tagField = table.fields!.find(
+      ({ name, type }) => name === tagFieldName && type === FieldType.MultipleSelect
+    ) as IFieldRo;
+  });
+
+  afterAll(async () => {
+    await permanentDeleteTable(baseId, table.id);
+  });
+
+  it('groups correctly when multiple select choice name contains ? character', async () => {
+    const query: IGetRecordsRo = {
+      fieldKeyType: FieldKeyType.Id,
+      groupBy: [{ fieldId: tagField.id!, order: SortFunc.Asc }],
+    };
+    const { records, extra } = await getRecords(table.id, query);
+
+    const headerValues =
+      extra?.groupPoints
+        ?.filter((point): point is IGroupHeaderPoint => point.type === GroupPointType.Header)
+        .map((point) => point.value) ?? [];
+
+    expect(headerValues).toHaveLength(3);
+    expect(records).toHaveLength(3);
+  });
+});
diff --git a/apps/nestjs-backend/test/record-search-query.e2e-spec.ts b/apps/nestjs-backend/test/record-search-query.e2e-spec.ts
index 0452682c62..9a6ab7ea33 100644
--- a/apps/nestjs-backend/test/record-search-query.e2e-spec.ts
+++ b/apps/nestjs-backend/test/record-search-query.e2e-spec.ts
@@ -321,6 +321,75 @@ describe('OpenAPI Record-Search-Query (e2e)', async () => {
     });
   });
 
+  describe('global search should skip number fields for non-numeric queries', () => {
+    let table: ITableFullVo;
+    beforeAll(async () => {
+      table = await createTable(baseId, {
+        name: 'number_skip_test',
+        fields: [
+          {
+            name: 'text',
+            type: FieldType.SingleLineText,
+          },
+          {
+            name: 'amount',
+            type: FieldType.Number,
+            options: {
+              formatting: { type: 'decimal', precision: 0 },
+            },
+          },
+        ],
+        records: [
+          { fields: { text: 'apple', amount: 100 } },
+          { fields: { text: 'banana', amount: 200 } },
+          { fields: { text: '100 items', amount: 300 } },
+        ],
+      });
+    });
+
+    afterAll(async () => {
+      await permanentDeleteTable(baseId, table.id);
+    });
+
+    it('should not match number fields when searching non-numeric text globally', async () => {
+      const { records } = (
+        await apiGetRecords(table.id, {
+          fieldKeyType: FieldKeyType.Id,
+          viewId: table.views[0].id,
+          search: ['apple', '', true],
+        })
+      ).data;
+      // should only match the text field, not scan number fields
+      expect(records.length).toBe(1);
+      expect(records[0].fields[table.fields[0].id]).toBe('apple');
+    });
+
+    it('should match number fields when searching numeric text globally', async () => {
+      const { records } = (
+        await apiGetRecords(table.id, {
+          fieldKeyType: FieldKeyType.Id,
+          viewId: table.views[0].id,
+          search: ['100', '', true],
+        })
+      ).data;
+      // should match both text "100 items" and number 100
+      expect(records.length).toBe(2);
+    });
+
+    it('should still search number fields when targeting a specific field', async () => {
+      const numberFieldId = table.fields[1].id;
+      const { records } = (
+        await apiGetRecords(table.id, {
+          fieldKeyType: FieldKeyType.Id,
+          viewId: table.views[0].id,
+          search: ['apple', numberFieldId, true],
+        })
+      ).data;
+      // no number value matches "apple"
+      expect(records.length).toBe(0);
+    });
+  });
+
   describe('search value with special characters', () => {
     let table: ITableFullVo;
     beforeAll(async () => {
diff --git a/apps/nestjs-backend/test/rollup.e2e-spec.ts b/apps/nestjs-backend/test/rollup.e2e-spec.ts
index 30701842fd..11097b5663 100644
--- a/apps/nestjs-backend/test/rollup.e2e-spec.ts
+++ b/apps/nestjs-backend/test/rollup.e2e-spec.ts
@@ -1389,63 +1389,4 @@ describe('OpenAPI Rollup field (e2e)', () => {
       expect(record1.fields[rollup1.id]).toEqual(0);
     });
   });
-
-  describe('v2 update field hasError propagation', () => {
-    const isForceV2 = process.env.FORCE_V2_ALL === 'true';
-    const itV2Only = isForceV2 ? it : it.skip;
-
-    itV2Only(
-      'marks rollup as errored when foreign lookup field type becomes incompatible via v2 convert',
-      async () => {
-        const foreign = await createTable(baseId, {
-          name: 'V2RollupHasError_Foreign',
-          fields: [{ name: 'Amount', type: FieldType.Number } as IFieldRo],
-        });
-        const host = await createTable(baseId, {
-          name: 'V2RollupHasError_Host',
-          fields: [{ name: 'Label', type: FieldType.SingleLineText } as IFieldRo],
-        });
-        const amountFieldId = foreign.fields.find((field) => field.name === 'Amount')!.id;
-
-        try {
-          const linkField = await createField(host.id, {
-            name: 'Link to Foreign',
-            type: FieldType.Link,
-            options: {
-              relationship: Relationship.OneMany,
-              foreignTableId: foreign.id,
-            },
-          } as IFieldRo);
-
-          const rollupField = await createField(host.id, {
-            name: 'Sum Amount',
-            type: FieldType.Rollup,
-            options: {
-              expression: 'sum({values})',
-            },
-            lookupOptions: {
-              foreignTableId: foreign.id,
-              linkFieldId: linkField.id,
-              lookupFieldId: amountFieldId,
-            } as ILookupOptionsRo,
-          } as IFieldRo);
-
-          expect((await getField(host.id, rollupField.id)).hasError).toBeFalsy();
-
-          // Convert the foreign lookup field to an incompatible type via v2
-          await convertField(foreign.id, amountFieldId, {
-            name: 'Amount',
-            type: FieldType.SingleLineText,
-            options: {},
-          } as IFieldRo);
-
-          const afterConvert = await getField(host.id, rollupField.id);
-          expect(afterConvert.hasError).toBe(true);
-        } finally {
-          await permanentDeleteTable(baseId, host.id);
-          await permanentDeleteTable(baseId, foreign.id);
-        }
-      }
-    );
-  });
 });
diff --git a/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/CodingModels.tsx b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/CodingModels.tsx
index 703a75a9d2..8cb0f5a88f 100644
--- a/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/CodingModels.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/CodingModels.tsx
@@ -3,14 +3,17 @@ import { chatModelAbilityType } from '@teable/openapi';
 import type { IAIIntegrationConfig, IChatModelAbility, IAbilityDetail } from '@teable/openapi';
 import {
   cn,
+  Collapsible,
+  CollapsibleContent,
+  CollapsibleTrigger,
   Tooltip,
   TooltipContent,
   TooltipProvider,
   TooltipTrigger,
 } from '@teable/ui-lib/shadcn';
-import { Cpu } from 'lucide-react';
+import { ChevronRight, Cpu } from 'lucide-react';
 import { useTranslation } from 'next-i18next';
-import { useMemo } from 'react';
+import { useMemo, useState } from 'react';
 import { AIModelSelect, type IModelOption } from './AiModelSelect';
 
 // Helper to check if ability is supported (handles both boolean and detailed format)
@@ -52,6 +55,10 @@ export const CodingModels = ({
   placeholder?: string;
 }) => {
   const { t } = useTranslation('common');
+  const [tiersOpen, setTiersOpen] = useState(
+    () =>
+      Boolean(value?.md && value.md !== value?.lg) || Boolean(value?.sm && value.sm !== value?.lg)
+  );
 
   const abilityIconMap = useMemo(() => {
     return {
@@ -74,15 +81,38 @@ export const CodingModels = ({
     return selectedModel?.capabilities as IChatModelAbility | undefined;
   }, [value?.lg, value?.ability, models]);
 
-  const handleModelChange = (model: string) => {
+  const handleLgChange = (model: string) => {
     // Get ability from the model's capabilities (already tested)
     const selectedModel = models?.find((m) => m.modelKey === model);
     const ability = (selectedModel?.capabilities as IChatModelAbility) || {};
 
-    // Set all sizes to the same model (simplified selection)
-    onChange({ ...value, lg: model, md: model, sm: model, ability });
+    // Update lg; clear md/sm if they were inheriting (same as old lg)
+    const next: IAIIntegrationConfig['chatModel'] = { ...value, lg: model, ability };
+    if (value?.md === value?.lg) next.md = undefined;
+    if (value?.sm === value?.lg) next.sm = undefined;
+    onChange(next);
+  };
+
+  const handleMdChange = (model: string) => {
+    onChange({ ...value, md: model || undefined });
+  };
+
+  const handleSmChange = (model: string) => {
+    onChange({ ...value, sm: model || undefined });
   };
 
+  // Display name of the lg model for inherit hint
+  const lgModelLabel = useMemo(() => {
+    if (!value?.lg || !models) return '';
+    const m = models.find((m) => m.modelKey === value.lg);
+    return m?.label || value.lg;
+  }, [value?.lg, models]);
+
+  const inheritPlaceholder = useMemo(
+    () => t('admin.setting.ai.chatModels.inheritHint', { model: lgModelLabel }),
+    [t, lgModelLabel]
+  );
+
   // Icon for chat model selection
   const chatModelIcon = useMemo(() => <Cpu className="size-4 text-purple-500" />, []);
 
@@ -124,12 +154,20 @@ export const CodingModels = ({
     return missing.length > 0 ? missing : null;
   }, [value?.lg, isModelTested, selectedModelAbility, t]);
 
+  // Count how many tiers have a custom (non-inherited) model
+  const customizedCount = useMemo(() => {
+    let count = 0;
+    if (value?.md && value.md !== value?.lg) count++;
+    if (value?.sm && value.sm !== value?.lg) count++;
+    return count;
+  }, [value?.lg, value?.md, value?.sm]);
+
   // Abilities to test and display
   const testableAbilities = chatModelAbilityType.options;
 
   return (
     <div className="flex flex-1 flex-col gap-4">
-      {/* Chat model selection - simplified to one model */}
+      {/* LG - Primary chat model (required) */}
       <div className="relative flex flex-col gap-2">
         <div className="flex shrink-0 items-center gap-2 truncate text-sm">
           {chatModelIcon}
@@ -142,7 +180,7 @@ export const CodingModels = ({
 
         <AIModelSelect
           value={value?.lg ?? ''}
-          onValueChange={handleModelChange}
+          onValueChange={handleLgChange}
           options={models}
           className="flex-1"
           needGroup={needGroup}
@@ -226,6 +264,66 @@ export const CodingModels = ({
           </div>
         )}
       </div>
+
+      {/* Model tiers - collapsible */}
+      {value?.lg && (
+        <Collapsible open={tiersOpen} onOpenChange={setTiersOpen}>
+          <CollapsibleTrigger className="flex w-full items-center gap-1.5 text-sm text-muted-foreground hover:text-foreground">
+            <ChevronRight
+              className={cn('size-4 shrink-0 transition-transform', tiersOpen && 'rotate-90')}
+            />
+            <span>{t('admin.setting.ai.chatModels.modelTiers')}</span>
+            {!tiersOpen && (
+              <span className="ml-1 text-xs opacity-60">
+                {customizedCount > 0
+                  ? t('admin.setting.ai.chatModels.customized', { count: customizedCount })
+                  : t('admin.setting.ai.chatModels.allInheriting')}
+              </span>
+            )}
+          </CollapsibleTrigger>
+          <CollapsibleContent>
+            <div className="mt-2 text-xs text-muted-foreground">
+              {t('admin.setting.ai.chatModels.modelTiersDescription')}
+            </div>
+            <div className="mt-3 flex flex-col gap-4 rounded-md border bg-muted/30 p-4">
+              {/* MD - Standard */}
+              <div className="flex flex-col gap-1.5">
+                <div className="flex items-baseline gap-2">
+                  <span className="text-sm font-medium">{t('admin.setting.ai.chatModels.md')}</span>
+                  <span className="text-xs text-muted-foreground">
+                    {t('admin.setting.ai.chatModels.mdDescription')}
+                  </span>
+                </div>
+                <AIModelSelect
+                  value={value?.md ?? ''}
+                  onValueChange={handleMdChange}
+                  options={models}
+                  className="flex-1"
+                  needGroup={needGroup}
+                  placeholder={inheritPlaceholder}
+                />
+              </div>
+              {/* SM - Lightweight */}
+              <div className="flex flex-col gap-1.5">
+                <div className="flex items-baseline gap-2">
+                  <span className="text-sm font-medium">{t('admin.setting.ai.chatModels.sm')}</span>
+                  <span className="text-xs text-muted-foreground">
+                    {t('admin.setting.ai.chatModels.smDescription')}
+                  </span>
+                </div>
+                <AIModelSelect
+                  value={value?.sm ?? ''}
+                  onValueChange={handleSmChange}
+                  options={models}
+                  className="flex-1"
+                  needGroup={needGroup}
+                  placeholder={inheritPlaceholder}
+                />
+              </div>
+            </div>
+          </CollapsibleContent>
+        </Collapsible>
+      )}
     </div>
   );
 };
diff --git a/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/DefaultModelsStep.tsx b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/DefaultModelsStep.tsx
index 1085e30891..7ad8ae1bb6 100644
--- a/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/DefaultModelsStep.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/DefaultModelsStep.tsx
@@ -3,13 +3,18 @@
 import { Zap, MessageSquare, Star, HelpCircle } from '@teable/icons';
 import {
   Button,
+  Collapsible,
+  CollapsibleContent,
+  CollapsibleTrigger,
+  cn,
   Tooltip,
   TooltipContent,
   TooltipProvider,
   TooltipTrigger,
 } from '@teable/ui-lib/shadcn';
+import { ChevronRight } from 'lucide-react';
 import { useTranslation } from 'next-i18next';
-import { useCallback } from 'react';
+import { useCallback, useMemo, useState } from 'react';
 import type { IModelOption } from './AiModelSelect';
 import { AIModelSelect } from './AiModelSelect';
 
@@ -33,6 +38,18 @@ export function DefaultModelsStep({
   disabled,
 }: IDefaultModelsStepProps) {
   const { t } = useTranslation('common');
+  const [tiersOpen, setTiersOpen] = useState(
+    () =>
+      Boolean(chatModel?.md && chatModel.md !== chatModel?.lg) ||
+      Boolean(chatModel?.sm && chatModel.sm !== chatModel?.lg)
+  );
+
+  const customizedCount = useMemo(() => {
+    let count = 0;
+    if (chatModel?.md && chatModel.md !== chatModel?.lg) count++;
+    if (chatModel?.sm && chatModel.sm !== chatModel?.lg) count++;
+    return count;
+  }, [chatModel?.lg, chatModel?.md, chatModel?.sm]);
 
   // Filter to only text models (not image models)
   const textModels = models.filter((m) => !m.isImageModel);
@@ -40,27 +57,49 @@ export function DefaultModelsStep({
   // Find a recommended default (first gateway model, or first model)
   const recommendedDefault = textModels.find((m) => m.isGateway) || textModels[0];
 
+  const lgModelLabel = useMemo(() => {
+    if (!chatModel?.lg) return '';
+    const m = textModels.find((m) => m.modelKey === chatModel.lg);
+    return m?.label || chatModel.lg;
+  }, [chatModel?.lg, textModels]);
+
+  const inheritPlaceholder = useMemo(
+    () => t('admin.setting.ai.chatModels.inheritHint', { model: lgModelLabel }),
+    [t, lgModelLabel]
+  );
+
   const handleUseRecommended = useCallback(() => {
     if (recommendedDefault) {
-      // Set the same model for all sizes
       onChange({
+        ...chatModel,
         lg: recommendedDefault.modelKey,
-        md: recommendedDefault.modelKey,
-        sm: recommendedDefault.modelKey,
       });
     }
-  }, [recommendedDefault, onChange]);
+  }, [recommendedDefault, chatModel, onChange]);
 
-  const handleModelChange = useCallback(
+  const handleLgChange = useCallback(
     (value: string) => {
-      // Set all sizes to the same model for simplicity
-      onChange({
-        lg: value,
-        md: value,
-        sm: value,
-      });
+      const next: IChatModel = { ...chatModel, lg: value };
+      // Clear md/sm if they were inheriting from the old lg
+      if (chatModel?.md === chatModel?.lg) next.md = undefined;
+      if (chatModel?.sm === chatModel?.lg) next.sm = undefined;
+      onChange(next);
+    },
+    [chatModel, onChange]
+  );
+
+  const handleMdChange = useCallback(
+    (value: string) => {
+      onChange({ ...chatModel, md: value || undefined });
     },
-    [onChange]
+    [chatModel, onChange]
+  );
+
+  const handleSmChange = useCallback(
+    (value: string) => {
+      onChange({ ...chatModel, sm: value || undefined });
+    },
+    [chatModel, onChange]
   );
 
   if (disabled) {
@@ -107,7 +146,7 @@ export function DefaultModelsStep({
         </div>
       )}
 
-      {/* Model Selection - simplified to one model */}
+      {/* Model Selection */}
       <div className="space-y-3">
         <div className="flex items-center gap-2 text-sm font-medium text-muted-foreground">
           <MessageSquare className="size-4" />
@@ -126,10 +165,70 @@ export function DefaultModelsStep({
 
         <AIModelSelect
           value={chatModel?.lg || ''}
-          onValueChange={handleModelChange}
+          onValueChange={handleLgChange}
           options={textModels}
           className="w-full"
         />
+
+        {/* Model tiers - collapsible */}
+        {chatModel?.lg && (
+          <Collapsible open={tiersOpen} onOpenChange={setTiersOpen}>
+            <CollapsibleTrigger className="flex w-full items-center gap-1.5 text-sm text-muted-foreground hover:text-foreground">
+              <ChevronRight
+                className={cn('size-4 shrink-0 transition-transform', tiersOpen && 'rotate-90')}
+              />
+              <span>{t('admin.setting.ai.chatModels.modelTiers')}</span>
+              {!tiersOpen && (
+                <span className="ml-1 text-xs opacity-60">
+                  {customizedCount > 0
+                    ? t('admin.setting.ai.chatModels.customized', { count: customizedCount })
+                    : t('admin.setting.ai.chatModels.allInheriting')}
+                </span>
+              )}
+            </CollapsibleTrigger>
+            <CollapsibleContent>
+              <div className="mt-2 text-xs text-muted-foreground">
+                {t('admin.setting.ai.chatModels.modelTiersDescription')}
+              </div>
+              <div className="mt-3 flex flex-col gap-4 rounded-md border bg-muted/30 p-4">
+                <div className="flex flex-col gap-1.5">
+                  <div className="flex items-baseline gap-2">
+                    <span className="text-sm font-medium">
+                      {t('admin.setting.ai.chatModels.md')}
+                    </span>
+                    <span className="text-xs text-muted-foreground">
+                      {t('admin.setting.ai.chatModels.mdDescription')}
+                    </span>
+                  </div>
+                  <AIModelSelect
+                    value={chatModel?.md || ''}
+                    onValueChange={handleMdChange}
+                    options={textModels}
+                    className="w-full"
+                    placeholder={inheritPlaceholder}
+                  />
+                </div>
+                <div className="flex flex-col gap-1.5">
+                  <div className="flex items-baseline gap-2">
+                    <span className="text-sm font-medium">
+                      {t('admin.setting.ai.chatModels.sm')}
+                    </span>
+                    <span className="text-xs text-muted-foreground">
+                      {t('admin.setting.ai.chatModels.smDescription')}
+                    </span>
+                  </div>
+                  <AIModelSelect
+                    value={chatModel?.sm || ''}
+                    onValueChange={handleSmChange}
+                    options={textModels}
+                    className="w-full"
+                    placeholder={inheritPlaceholder}
+                  />
+                </div>
+              </div>
+            </CollapsibleContent>
+          </Collapsible>
+        )}
       </div>
 
       {/* Status */}
diff --git a/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/ai-model-select/ModelSelectTrigger.tsx b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/ai-model-select/ModelSelectTrigger.tsx
index 9fbf8e0bab..cd22ae0b32 100644
--- a/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/ai-model-select/ModelSelectTrigger.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/ai-model-select/ModelSelectTrigger.tsx
@@ -40,7 +40,9 @@ export const ModelSelectTrigger = forwardRef<HTMLButtonElement, IModelSelectTrig
       >
         <div className="flex flex-1 items-center truncate">
           {!currentModel ? (
-            placeholder ?? t('admin.setting.ai.selectModel')
+            <span className="text-muted-foreground">
+              {placeholder ?? t('admin.setting.ai.selectModel')}
+            </span>
           ) : (
             <>
               {Icon && <Icon className="mr-1.5 size-4 shrink-0" />}
diff --git a/apps/nextjs-app/src/features/app/blocks/base/base-side-bar/BaseSidebarHeaderLeft.tsx b/apps/nextjs-app/src/features/app/blocks/base/base-side-bar/BaseSidebarHeaderLeft.tsx
index df20ae8a65..d69dcde711 100644
--- a/apps/nextjs-app/src/features/app/blocks/base/base-side-bar/BaseSidebarHeaderLeft.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/base/base-side-bar/BaseSidebarHeaderLeft.tsx
@@ -133,14 +133,16 @@ const BaseDropdownMenu = ({
             </div>
           </DropdownMenuItem>
         )}
-        <PublishBaseDialog onClose={() => setOpen(false)} closeOnSuccess={false}>
-          <DropdownMenuItem onSelect={(e) => e.preventDefault()}>
-            <div className="flex w-full cursor-pointer items-center gap-2">
-              <Send className="size-4" />
-              {t('space:publishBase.publishToCommunity')}
-            </div>
-          </DropdownMenuItem>
-        </PublishBaseDialog>
+        {showRename && (
+          <PublishBaseDialog onClose={() => setOpen(false)} closeOnSuccess={false}>
+            <DropdownMenuItem onSelect={(e) => e.preventDefault()}>
+              <div className="flex w-full cursor-pointer items-center gap-2">
+                <Send className="size-4" />
+                {t('space:publishBase.publishToCommunity')}
+              </div>
+            </DropdownMenuItem>
+          </PublishBaseDialog>
+        )}
 
         <DropdownMenuSeparator />
         <DropdownMenuItem asChild>
diff --git a/apps/nextjs-app/src/features/app/blocks/base/base-side-bar/NodeShareContent.tsx b/apps/nextjs-app/src/features/app/blocks/base/base-side-bar/NodeShareContent.tsx
index 11bb39be80..9231b8d23c 100644
--- a/apps/nextjs-app/src/features/app/blocks/base/base-side-bar/NodeShareContent.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/base/base-side-bar/NodeShareContent.tsx
@@ -48,7 +48,7 @@ import {
   TooltipTrigger,
 } from '@teable/ui-lib/shadcn';
 import { toast } from '@teable/ui-lib/shadcn/ui/sonner';
-import { Check, ChevronDown, ChevronRight, Eye, HelpCircle } from 'lucide-react';
+import { Check, ChevronDown, ChevronRight, Eye } from 'lucide-react';
 import { useTranslation } from 'next-i18next';
 import { QRCodeSVG } from 'qrcode.react';
 import { useMemo, useState } from 'react';
@@ -403,42 +403,68 @@ export const NodeShareContent = ({
       {isShareEnabled && share && (
         <>
           <div className="flex flex-col gap-2">
-            <div className="flex items-center gap-2 text-sm">
-              <span className="text-muted-foreground">{t('table:baseShare.linkHolderLabel')}</span>
-              <DropdownMenu>
-                <DropdownMenuTrigger asChild>
-                  <button className="inline-flex items-center gap-0.5 text-blue-500 hover:text-blue-600">
-                    {share.allowSave
-                      ? t('table:baseShare.linkHolderCanCopyAndSave')
-                      : t('table:baseShare.linkHolderCanView')}
-                    <ChevronDown className="size-4" />
-                  </button>
-                </DropdownMenuTrigger>
-                <DropdownMenuContent align="start">
-                  <DropdownMenuItem
-                    className={!share.allowSave ? 'text-blue-500' : ''}
-                    onClick={() => handleUpdateSetting({ allowSave: false })}
-                  >
-                    {!share.allowSave ? (
-                      <Check className="mr-2 size-4" />
-                    ) : (
-                      <span className="mr-2 size-4" />
-                    )}
-                    {t('table:baseShare.linkHolderCanView')}
-                  </DropdownMenuItem>
-                  <DropdownMenuItem
-                    className={share.allowSave ? 'text-blue-500' : ''}
-                    onClick={() => handleUpdateSetting({ allowSave: true })}
-                  >
-                    {share.allowSave ? (
-                      <Check className="mr-2 size-4" />
-                    ) : (
-                      <span className="mr-2 size-4" />
-                    )}
-                    {t('table:baseShare.linkHolderCanCopyAndSave')}
-                  </DropdownMenuItem>
-                </DropdownMenuContent>
-              </DropdownMenu>
+            <div className="flex flex-col gap-1">
+              <div className="flex items-center gap-1.5 text-sm">
+                <span className="text-muted-foreground">
+                  {t('table:baseShare.linkHolderLabel')}
+                </span>
+                <DropdownMenu>
+                  <DropdownMenuTrigger asChild>
+                    <button className="inline-flex items-center gap-0.5 font-medium text-blue-500 hover:text-blue-600">
+                      {share.allowEdit
+                        ? t('table:baseShare.linkHolderCanEdit')
+                        : share.allowSave
+                          ? t('table:baseShare.linkHolderCanCopyAndSave')
+                          : t('table:baseShare.linkHolderCanView')}
+                      <ChevronDown className="size-3.5" />
+                    </button>
+                  </DropdownMenuTrigger>
+                  <DropdownMenuContent align="start" className="w-64">
+                    {[
+                      {
+                        active: !share.allowSave && !share.allowEdit,
+                        label: t('table:baseShare.linkHolderCanView'),
+                        desc: t('table:baseShare.linkHolderCanViewDesc'),
+                        onClick: () => handleUpdateSetting({ allowSave: false, allowEdit: false }),
+                      },
+                      node.resourceType === BaseNodeResourceType.Table && {
+                        active: !!share.allowEdit,
+                        label: t('table:baseShare.linkHolderCanEdit'),
+                        desc: t('table:baseShare.linkHolderCanEditDesc'),
+                        onClick: () => handleUpdateSetting({ allowEdit: true, allowSave: false }),
+                      },
+                      {
+                        active: !!share.allowSave,
+                        label: t('table:baseShare.linkHolderCanCopyAndSave'),
+                        desc: t('table:baseShare.linkHolderCanCopyAndSaveDesc'),
+                        onClick: () => handleUpdateSetting({ allowSave: true, allowEdit: false }),
+                      },
+                    ]
+                      .filter((item): item is Exclude<typeof item, false> => Boolean(item))
+                      .map((item) => (
+                        <DropdownMenuItem
+                          key={item.label}
+                          className={item.active ? 'text-blue-500' : ''}
+                          onClick={item.onClick}
+                        >
+                          <div className="flex items-start gap-1.5">
+                            {item.active ? (
+                              <Check className="mt-0.5 size-4 shrink-0" />
+                            ) : (
+                              <span className="mt-0.5 size-4 shrink-0" />
+                            )}
+                            <div className="flex flex-col">
+                              <span>{item.label}</span>
+                              <span className="text-xs font-normal text-muted-foreground">
+                                {item.desc}
+                              </span>
+                            </div>
+                          </div>
+                        </DropdownMenuItem>
+                      ))}
+                  </DropdownMenuContent>
+                </DropdownMenu>
+              </div>
             </div>
             <div className="flex items-center gap-2">
               <Input className="min-w-0 flex-1" value={shareUrl} readOnly />
diff --git a/apps/nextjs-app/src/features/app/blocks/design/components/IntegrityV2Components.tsx b/apps/nextjs-app/src/features/app/blocks/design/components/IntegrityV2Components.tsx
index 39f8270a81..facbc2195e 100644
--- a/apps/nextjs-app/src/features/app/blocks/design/components/IntegrityV2Components.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/design/components/IntegrityV2Components.tsx
@@ -1,22 +1,62 @@
-import { Badge, Button, ToggleGroup, ToggleGroupItem, cn } from '@teable/ui-lib/shadcn';
+import { FieldType } from '@teable/core';
+import { useFieldStaticGetter } from '@teable/sdk/hooks';
+import {
+  Alert,
+  AlertDescription,
+  Badge,
+  Button,
+  Checkbox,
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+  Input,
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+  Textarea,
+  ToggleGroup,
+  ToggleGroupItem,
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger,
+  cn,
+} from '@teable/ui-lib/shadcn';
 import {
   AlertTriangle,
+  ChevronDown,
   CheckCircle2,
   Clock,
+  Columns3,
+  Info,
   Loader2,
   RefreshCcw,
+  Table2,
   Wrench,
   XCircle,
 } from 'lucide-react';
 import { useTranslation } from 'next-i18next';
+import { useEffect, useMemo, useState, type ComponentType } from 'react';
 import {
   getLocalizedDetailItems,
+  getLocalizedRepairDescription,
+  getLocalizedRepairReason,
   getLocalizedResultMessage,
   getLocalizedRuleDescription,
   getGroupDisplayName,
   getGroupDisplayState,
   integrityFilterStatuses,
   getPhaseText,
+  translateIntegrityMessage,
   type GroupDisplayState,
   type IntegrityFilterStatus,
   type IntegrityPhase,
@@ -76,14 +116,462 @@ const OutcomeBadge = ({ result }: { result: IntegrityResult }) => {
   );
 };
 
-const RuleResultItem = ({ result }: { result: IntegrityResult }) => {
+const SYSTEM_FIELD_TYPE_MAP: Record<string, FieldType> = {
+  __id: FieldType.SingleLineText,
+  __auto_number: FieldType.AutoNumber,
+  __created_time: FieldType.CreatedTime,
+  __last_modified_time: FieldType.LastModifiedTime,
+  __created_by: FieldType.CreatedBy,
+  __last_modified_by: FieldType.LastModifiedBy,
+  __version: FieldType.Number,
+};
+
+const getSystemFieldType = (fieldId: string) => {
+  if (!fieldId.startsWith('__system__:')) {
+    return undefined;
+  }
+
+  return SYSTEM_FIELD_TYPE_MAP[fieldId.replace('__system__:', '')];
+};
+
+const getRuleType = (ruleId: string) => ruleId.split(':')[0];
+
+const getColumnDataType = (ruleDescription: string) => {
+  const match = ruleDescription.match(/\(([^()]+)\)\s*$/);
+  return match?.[1]?.toLowerCase();
+};
+
+const DB_TYPE_TO_FIELD_TYPE: Record<string, FieldType> = {
+  text: FieldType.SingleLineText,
+  varchar: FieldType.SingleLineText,
+  'character varying': FieldType.SingleLineText,
+  integer: FieldType.Number,
+  bigint: FieldType.Number,
+  numeric: FieldType.Number,
+  real: FieldType.Number,
+  'double precision': FieldType.Number,
+  timestamptz: FieldType.Date,
+  timestamp: FieldType.Date,
+  date: FieldType.Date,
+  boolean: FieldType.Checkbox,
+};
+
+const inferFieldTypeFromReferenceRule = (description: string) => {
+  if (description.includes('conditional rollup')) {
+    return { type: FieldType.ConditionalRollup };
+  }
+
+  if (description.includes('rollup')) {
+    return { type: FieldType.Rollup };
+  }
+
+  if (description.includes('conditional lookup')) {
+    return { type: FieldType.Link, isLookup: true, isConditionalLookup: true };
+  }
+
+  if (description.includes('lookup field') || description.includes('lookup-link field')) {
+    return { type: FieldType.Link, isLookup: true };
+  }
+
+  return undefined;
+};
+
+const inferFieldTypeFromRule = (result: IntegrityResult) => {
+  const ruleType = getRuleType(result.ruleId);
+  const description = result.ruleDescription.toLowerCase();
+
+  if (
+    ruleType === 'link_value_column' ||
+    ruleType === 'fk_column' ||
+    ruleType === 'order_column' ||
+    ruleType === 'field_meta' ||
+    ruleType === 'symmetric_field'
+  ) {
+    return { type: FieldType.Link };
+  }
+
+  if (ruleType === 'reference') {
+    return inferFieldTypeFromReferenceRule(description);
+  }
+
+  if (ruleType === 'generated_column' || ruleType === 'generated_meta') {
+    return { type: FieldType.Formula };
+  }
+
+  if (ruleType === 'column' || ruleType === 'system_column') {
+    const columnDataType = getColumnDataType(result.ruleDescription);
+    if (columnDataType && DB_TYPE_TO_FIELD_TYPE[columnDataType]) {
+      return { type: DB_TYPE_TO_FIELD_TYPE[columnDataType] };
+    }
+  }
+
+  return undefined;
+};
+
+const inferFieldTypeFromGroup = (group: ResultGroup) => {
+  const systemFieldType = getSystemFieldType(group.fieldId);
+  if (systemFieldType) {
+    return { type: systemFieldType };
+  }
+
+  for (const result of group.results) {
+    const inferredFieldType = inferFieldTypeFromRule(result);
+    if (inferredFieldType) {
+      return inferredFieldType;
+    }
+  }
+
+  return undefined;
+};
+
+type ManualRepairSchema = NonNullable<NonNullable<IntegrityResult['repair']>['manualRepairSchema']>;
+type ManualRepairProperty = ManualRepairSchema['properties'][string];
+
+const getManualRepairDefaultValues = (manualRepairSchema?: ManualRepairSchema) => {
+  return Object.fromEntries(
+    Object.entries(manualRepairSchema?.properties || {}).map(([key, property]) => [
+      key,
+      property.defaultValue ?? (property.type === 'boolean' ? false : ''),
+    ])
+  ) as Record<string, string | boolean>;
+};
+
+const getManualRepairWidget = (property: ManualRepairProperty) => {
+  return (
+    property.widget ??
+    (property.options?.length ? 'select' : property.type === 'boolean' ? 'checkbox' : 'text')
+  );
+};
+
+const ManualRepairFieldInput = ({
+  property,
+  value,
+  onChange,
+  t,
+}: {
+  property: ManualRepairProperty;
+  value: string | boolean | undefined;
+  onChange: (value: string | boolean) => void;
+  t: Translate;
+}) => {
+  const widget = getManualRepairWidget(property);
+
+  if (widget === 'select') {
+    return (
+      <Select value={String(value ?? '')} onValueChange={(nextValue) => onChange(nextValue)}>
+        <SelectTrigger className="w-full">
+          <SelectValue />
+        </SelectTrigger>
+        <SelectContent>
+          {property.options?.map((option) => (
+            <SelectItem key={option.value} value={option.value}>
+              {translateIntegrityMessage(t, option.label) || option.value}
+            </SelectItem>
+          ))}
+        </SelectContent>
+      </Select>
+    );
+  }
+
+  if (widget === 'textarea') {
+    return (
+      <Textarea
+        value={String(value ?? '')}
+        onChange={(event) => onChange(event.target.value)}
+        className="min-h-24"
+      />
+    );
+  }
+
+  if (widget === 'checkbox') {
+    return (
+      <Checkbox
+        checked={Boolean(value)}
+        onCheckedChange={(checked) => onChange(checked === true)}
+      />
+    );
+  }
+
+  return <Input value={String(value ?? '')} onChange={(event) => onChange(event.target.value)} />;
+};
+
+const ManualRepairDialog = ({
+  result,
+  triggerLabel,
+}: {
+  result: IntegrityResult;
+  triggerLabel: string;
+}) => {
+  const { t } = useTranslation(['table']);
+  const manualRepairSchema = result.repair?.manualRepairSchema;
+  const schemaProperties: Array<[string, ManualRepairProperty]> = manualRepairSchema
+    ? (Object.entries(manualRepairSchema.properties) as Array<[string, ManualRepairProperty]>)
+    : [];
+  const [open, setOpen] = useState(false);
+  const [values, setValues] = useState<Record<string, string | boolean>>(() =>
+    getManualRepairDefaultValues(manualRepairSchema)
+  );
+  const reason = getLocalizedRepairReason(t as Translate, result);
+  const description = getLocalizedRepairDescription(t as Translate, result);
+  const submitLabel =
+    translateIntegrityMessage(t as Translate, manualRepairSchema?.submitLabel) ||
+    t('table:table.integrity.v2.repairMeta.manual.apply');
+
+  useEffect(() => {
+    setValues(getManualRepairDefaultValues(manualRepairSchema));
+  }, [manualRepairSchema, open]);
+
+  if (!result.repair || result.repair.mode !== 'manual') {
+    return null;
+  }
+
+  return (
+    <Dialog open={open} onOpenChange={setOpen}>
+      <Button
+        size="xs"
+        variant="secondary"
+        className="h-7 px-2 text-xs"
+        onClick={() => setOpen(true)}
+      >
+        <Info className="mr-1 size-3.5" />
+        {triggerLabel}
+      </Button>
+      <DialogContent className="max-w-xl">
+        <DialogHeader>
+          <DialogTitle>
+            {translateIntegrityMessage(t as Translate, manualRepairSchema?.title) ||
+              t('table:table.integrity.v2.manualRepairDialogTitle')}
+          </DialogTitle>
+          <DialogDescription>
+            {translateIntegrityMessage(t as Translate, manualRepairSchema?.description) ||
+              description ||
+              t('table:table.integrity.v2.manualRepairDialogDescription')}
+          </DialogDescription>
+        </DialogHeader>
+
+        <div className="space-y-4">
+          <Alert className="border-amber-200 bg-amber-50/70 text-amber-950">
+            <AlertDescription className="space-y-1">
+              <div className="font-medium">
+                {t('table:table.integrity.v2.manualRepairDialogReason')}
+              </div>
+              <div>{reason || t('table:table.integrity.v2.message.manualRepair')}</div>
+            </AlertDescription>
+          </Alert>
+
+          {manualRepairSchema ? (
+            <div className="rounded-md border border-border bg-muted/30 p-3">
+              <div className="space-y-3">
+                {schemaProperties.map(([key, property]) => {
+                  const label = translateIntegrityMessage(t as Translate, property.title) || key;
+                  const fieldDescription = translateIntegrityMessage(
+                    t as Translate,
+                    property.description
+                  );
+                  const isRequired = manualRepairSchema.required?.includes(key);
+
+                  return (
+                    <label key={key} className="block space-y-1.5 text-sm">
+                      <div className="font-medium text-foreground">
+                        {label}
+                        {isRequired ? <span className="ml-1 text-destructive">*</span> : null}
+                      </div>
+                      {fieldDescription ? (
+                        <div className="text-xs text-muted-foreground">{fieldDescription}</div>
+                      ) : null}
+                      <ManualRepairFieldInput
+                        property={property}
+                        value={values[key]}
+                        t={t as Translate}
+                        onChange={(nextValue) =>
+                          setValues((current) => ({
+                            ...current,
+                            [key]: nextValue,
+                          }))
+                        }
+                      />
+                    </label>
+                  );
+                })}
+              </div>
+            </div>
+          ) : null}
+
+          <div className="text-xs text-muted-foreground">
+            {t('table:table.integrity.v2.manualRepairDialogHint')}
+          </div>
+        </div>
+
+        <DialogFooter>
+          <TooltipProvider>
+            <Tooltip>
+              <TooltipTrigger asChild>
+                <span className="inline-flex">
+                  <Button type="button" disabled>
+                    {submitLabel}
+                  </Button>
+                </span>
+              </TooltipTrigger>
+              <TooltipContent className="max-w-xs whitespace-normal">
+                {t('table:table.integrity.v2.manualRepairPreviewTip')}
+              </TooltipContent>
+            </Tooltip>
+          </TooltipProvider>
+          <Button type="button" variant="secondary" onClick={() => setOpen(false)}>
+            {t('table:table.integrity.v2.manualRepairDialogClose')}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+};
+
+const RuleRepairAction = ({
+  result,
+  isRunning,
+  isActive,
+  onRepairRule,
+}: {
+  result: IntegrityResult;
+  isRunning: boolean;
+  isActive: boolean;
+  onRepairRule?: (result: IntegrityResult) => void;
+}) => {
+  const { t } = useTranslation(['table']);
+  const canRepair = Boolean(result.repair?.available && result.tableId && result.fieldId);
+  const reason = getLocalizedRepairReason(t as Translate, result);
+  const description = getLocalizedRepairDescription(t as Translate, result);
+
+  if (!result.repair) {
+    return null;
+  }
+
+  return (
+    <div className="ml-auto flex items-center gap-2 opacity-0 transition-opacity duration-150 group-focus-within:opacity-100 group-hover:opacity-100">
+      {result.repair.mode === 'manual' ? (
+        <TooltipProvider>
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <span className="inline-flex">
+                <ManualRepairDialog
+                  result={result}
+                  triggerLabel={t('table:table.integrity.v2.manual')}
+                />
+              </span>
+            </TooltipTrigger>
+            <TooltipContent className="max-w-xs whitespace-normal">
+              <div>{reason || t('table:table.integrity.v2.manualRepairNotice')}</div>
+              {description ? <div className="mt-1 opacity-80">{description}</div> : null}
+            </TooltipContent>
+          </Tooltip>
+        </TooltipProvider>
+      ) : null}
+      <TooltipProvider>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <span className="inline-flex">
+              <Button
+                size="xs"
+                variant="outline"
+                className="h-7 px-2 text-xs"
+                disabled={!canRepair || isRunning}
+                onClick={() => onRepairRule?.(result)}
+              >
+                {isRunning && isActive ? (
+                  <Loader2 className="mr-1 size-3.5 animate-spin" />
+                ) : (
+                  <Wrench className="mr-1 size-3.5" />
+                )}
+                {t('table:table.integrity.v2.repairRule')}
+              </Button>
+            </span>
+          </TooltipTrigger>
+          {!canRepair || reason ? (
+            <TooltipContent className="max-w-xs whitespace-normal">
+              <div>{reason || t('table:table.integrity.v2.repairUnavailable')}</div>
+              {description ? <div className="mt-1 opacity-80">{description}</div> : null}
+            </TooltipContent>
+          ) : null}
+        </Tooltip>
+      </TooltipProvider>
+    </div>
+  );
+};
+
+const getUnavailableRepairGuidance = (
+  result: IntegrityResult,
+  reason?: string,
+  description?: string
+) => {
+  const show =
+    result.status !== 'success' &&
+    Boolean(result.repair) &&
+    result.repair?.available === false &&
+    result.repair?.mode === 'auto' &&
+    Boolean(reason || description);
+
+  return {
+    show,
+    reason,
+    description,
+  };
+};
+
+const UnavailableRepairGuidance = ({
+  reason,
+  description,
+}: {
+  reason?: string;
+  description?: string;
+}) => {
+  if (!reason && !description) {
+    return null;
+  }
+
+  return (
+    <div className="mt-2 rounded-md border border-amber-200/70 bg-amber-50/80 px-3 py-2 text-[13px] text-amber-950">
+      {reason ? <div className="font-medium">{reason}</div> : null}
+      {description ? (
+        <div className={cn(reason ? 'mt-1 text-amber-900/90' : 'text-amber-900/90')}>
+          {description}
+        </div>
+      ) : null}
+    </div>
+  );
+};
+
+const RuleResultItem = ({
+  result,
+  isRunning,
+  isActive,
+  onRepairRule,
+}: {
+  result: IntegrityResult;
+  isRunning: boolean;
+  isActive: boolean;
+  onRepairRule?: (result: IntegrityResult) => void;
+}) => {
   const { t } = useTranslation(['table']);
   const localizedMessage = getLocalizedResultMessage(t as Translate, result);
-  const localizedMissing = getLocalizedDetailItems(t as Translate, result.details?.missing);
-  const localizedExtra = getLocalizedDetailItems(t as Translate, result.details?.extra);
+  const shouldShowMessage = localizedMessage && result.status !== 'success';
+  const repairReason = getLocalizedRepairReason(t as Translate, result);
+  const repairDescription = getLocalizedRepairDescription(t as Translate, result);
+  const unavailableRepairGuidance = getUnavailableRepairGuidance(
+    result,
+    repairReason,
+    repairDescription
+  );
+  const localizedMissing = getLocalizedDetailItems(
+    t as Translate,
+    result.details?.missingItems || result.details?.missing
+  );
+  const localizedExtra = getLocalizedDetailItems(
+    t as Translate,
+    result.details?.extraItems || result.details?.extra
+  );
 
   return (
-    <div className="py-3 text-sm">
+    <div className="group py-3 text-sm">
       <div className="flex flex-wrap items-start gap-2">
         <StatusIcon status={result.status} />
         <span className="font-medium text-foreground">
@@ -99,10 +587,22 @@ const RuleResultItem = ({ result }: { result: IntegrityResult }) => {
             {t('table:table.integrity.v2.optional')}
           </Badge>
         ) : null}
+        <RuleRepairAction
+          result={result}
+          isRunning={isRunning}
+          isActive={isActive}
+          onRepairRule={onRepairRule}
+        />
       </div>
-      {localizedMessage ? (
+      {shouldShowMessage ? (
         <div className="mt-2 text-muted-foreground">{localizedMessage}</div>
       ) : null}
+      {unavailableRepairGuidance.show ? (
+        <UnavailableRepairGuidance
+          reason={unavailableRepairGuidance.reason}
+          description={unavailableRepairGuidance.description}
+        />
+      ) : null}
       {localizedMissing?.length ? (
         <div className="mt-2 text-muted-foreground">
           {t('table:table.integrity.v2.detailsMissing', {
@@ -172,12 +672,12 @@ export const SummaryBadges = ({
 
 const filterChipClasses: Record<IntegrityFilterStatus, string> = {
   success:
-    'border-green-500/30 text-green-700 data-[state=on]:border-green-500/50 data-[state=on]:bg-green-500/10 data-[state=on]:text-green-700',
-  warn: 'border-yellow-500/30 text-yellow-700 data-[state=on]:border-yellow-500/50 data-[state=on]:bg-yellow-500/10 data-[state=on]:text-yellow-700',
+    'data-[state=on]:border-green-300 data-[state=on]:bg-green-50 data-[state=on]:text-green-700 data-[state=on]:shadow-sm',
+  warn: 'data-[state=on]:border-amber-300 data-[state=on]:bg-amber-50 data-[state=on]:text-amber-700 data-[state=on]:shadow-sm',
   error:
-    'border-destructive/30 text-destructive data-[state=on]:border-destructive/50 data-[state=on]:bg-destructive/10 data-[state=on]:text-destructive',
+    'data-[state=on]:border-destructive/30 data-[state=on]:bg-destructive/10 data-[state=on]:text-destructive data-[state=on]:shadow-sm',
   skipped:
-    'border-muted-foreground/20 text-muted-foreground data-[state=on]:border-muted-foreground/30 data-[state=on]:bg-muted data-[state=on]:text-foreground',
+    'data-[state=on]:border-slate-300 data-[state=on]:bg-slate-100 data-[state=on]:text-slate-700 data-[state=on]:shadow-sm',
 };
 
 export const IntegrityStatusFilters = ({
@@ -217,7 +717,7 @@ export const IntegrityStatusFilters = ({
           key={status}
           value={status}
           className={cn(
-            'h-9 rounded-full border px-3 text-sm font-medium shadow-none',
+            'h-9 rounded-full border border-slate-200 bg-white px-3 text-sm font-medium text-slate-500 shadow-none transition-colors hover:bg-slate-50 hover:text-slate-700 data-[state=off]:bg-white data-[state=off]:text-slate-500',
             filterChipClasses[status]
           )}
         >
@@ -233,7 +733,8 @@ export const IntegrityStatusFilters = ({
 export const IntegrityActions = ({
   canRun,
   hasRun,
-  canRepair,
+  canRepairWarnings,
+  canRepairAny,
   isRunning,
   phase,
   onCheck,
@@ -241,11 +742,12 @@ export const IntegrityActions = ({
 }: {
   canRun: boolean;
   hasRun: boolean;
-  canRepair: boolean;
+  canRepairWarnings: boolean;
+  canRepairAny: boolean;
   isRunning: boolean;
   phase: IntegrityPhase;
   onCheck: () => void;
-  onRepair: () => void;
+  onRepair: (targetStatuses: Array<'warn' | 'error'>) => void;
 }) => {
   const { t } = useTranslation(['table']);
 
@@ -259,14 +761,41 @@ export const IntegrityActions = ({
         )}
         {hasRun ? t('table:table.integrity.v2.recheck') : t('table:table.integrity.v2.runCheck')}
       </Button>
-      <Button size="sm" onClick={onRepair} disabled={!canRepair}>
-        {isRunning && phase === 'repair' ? (
-          <Loader2 className="mr-2 size-4 animate-spin" />
-        ) : (
-          <Wrench className="mr-2 size-4" />
-        )}
-        {t('table:table.integrity.v2.repair')}
-      </Button>
+      <div className="inline-flex items-center">
+        <Button
+          size="sm"
+          onClick={() => onRepair(['warn'])}
+          disabled={!canRepairWarnings || isRunning}
+          className="rounded-r-none border-r-0"
+        >
+          {isRunning && phase === 'repair' ? (
+            <Loader2 className="mr-2 size-4 animate-spin" />
+          ) : (
+            <Wrench className="mr-2 size-4" />
+          )}
+          {t('table:table.integrity.v2.repair')}
+        </Button>
+        <DropdownMenu>
+          <DropdownMenuTrigger asChild>
+            <Button
+              size="sm"
+              variant="default"
+              disabled={!canRepairAny || isRunning}
+              className="rounded-l-none px-2"
+            >
+              <ChevronDown className="size-4" />
+            </Button>
+          </DropdownMenuTrigger>
+          <DropdownMenuContent align="start">
+            <DropdownMenuItem disabled={!canRepairWarnings} onClick={() => onRepair(['warn'])}>
+              {t('table:table.integrity.v2.repairWarnings')}
+            </DropdownMenuItem>
+            <DropdownMenuItem disabled={!canRepairAny} onClick={() => onRepair(['warn', 'error'])}>
+              {t('table:table.integrity.v2.repairWarningsAndErrors')}
+            </DropdownMenuItem>
+          </DropdownMenuContent>
+        </DropdownMenu>
+      </div>
       {isRunning ? (
         <span className="text-sm text-muted-foreground">
           {getPhaseText(t as Translate, phase, 'running')}
@@ -292,50 +821,154 @@ const GroupStateIcon = ({ displayState }: { displayState: GroupDisplayState }) =
   return <Loader2 className="size-4 animate-spin text-blue-500" />;
 };
 
-const IntegrityGroupCard = ({ group }: { group: ResultGroup }) => {
+const HeaderTypeIcon = ({
+  type,
+  icon: Icon,
+}: {
+  type: 'table' | 'field';
+  icon?: ComponentType<{ className?: string }>;
+}) => {
+  if (type === 'table') {
+    return (
+      <span className="inline-flex size-8 items-center justify-center rounded-lg border border-slate-300/70 bg-white/80 text-slate-700 shadow-sm">
+        <Table2 className="size-[18px]" />
+      </span>
+    );
+  }
+
+  const FieldIcon = Icon ?? Columns3;
+
+  return (
+    <span className="inline-flex size-7 items-center justify-center rounded-md border border-slate-200 bg-white/75 text-slate-600">
+      <FieldIcon className="size-4" />
+    </span>
+  );
+};
+
+const ManualRepairNotice = ({ count }: { count: number }) => {
+  const { t } = useTranslation(['table']);
+
+  if (count <= 0) {
+    return null;
+  }
+
+  return (
+    <Alert className="border-amber-200 bg-amber-50/70 text-amber-950">
+      <AlertDescription>
+        {t('table:table.integrity.v2.manualRepairNoticeWithCount', {
+          count,
+        })}
+      </AlertDescription>
+    </Alert>
+  );
+};
+
+const IntegrityGroupCard = ({
+  group,
+  isRunning,
+  activeRepairResultId,
+  onRepairRule,
+  nested = false,
+}: {
+  group: ResultGroup;
+  isRunning: boolean;
+  activeRepairResultId?: string | null;
+  onRepairRule?: (result: IntegrityResult) => void;
+  nested?: boolean;
+}) => {
   const { t } = useTranslation(['table']);
+  const fieldStaticGetter = useFieldStaticGetter();
   const displayState = getGroupDisplayState(group.results);
   const displayName = getGroupDisplayName(t as Translate, group);
+  const fieldIcon = useMemo(() => {
+    const iconConfig = inferFieldTypeFromGroup(group);
+
+    if (!iconConfig) {
+      return undefined;
+    }
+
+    return fieldStaticGetter(iconConfig.type, {
+      isLookup: iconConfig.isLookup,
+      isConditionalLookup: iconConfig.isConditionalLookup,
+    }).Icon;
+  }, [fieldStaticGetter, group]);
 
   return (
-    <section className="rounded-lg border border-border bg-background">
-      <div className="flex flex-wrap items-center gap-2 border-b border-border px-4 py-3">
+    <section className={cn(!nested && 'rounded-xl border border-border bg-background')}>
+      <div
+        className={cn(
+          'flex flex-wrap items-center justify-between gap-3 border-b border-slate-200 px-4 py-3',
+          nested ? 'bg-slate-50/70' : 'bg-slate-50/85'
+        )}
+      >
+        <div className="flex min-w-0 items-center gap-3">
+          <HeaderTypeIcon type="field" icon={fieldIcon} />
+          <div className="min-w-0">
+            <div className="truncate text-sm font-semibold text-slate-900">{displayName}</div>
+            {group.fieldId &&
+            group.fieldId !== '__system__' &&
+            !group.fieldId.startsWith('__system__:') ? (
+              <div className="truncate font-mono text-xs text-slate-500">{group.fieldId}</div>
+            ) : null}
+          </div>
+        </div>
         <GroupStateIcon displayState={displayState} />
-        <span className="text-sm font-medium">{displayName}</span>
-        {group.fieldId &&
-        group.fieldId !== '__system__' &&
-        !group.fieldId.startsWith('__system__:') ? (
-          <span className="font-mono text-xs text-muted-foreground">{group.fieldId}</span>
-        ) : null}
       </div>
 
       <div className="divide-y divide-border px-4">
         {group.results.map((result) => (
-          <RuleResultItem key={result.id} result={result} />
+          <RuleResultItem
+            key={result.id}
+            result={result}
+            isRunning={isRunning}
+            isActive={activeRepairResultId === result.id}
+            onRepairRule={onRepairRule}
+          />
         ))}
       </div>
     </section>
   );
 };
 
-const IntegrityTableCard = ({ group }: { group: TableResultGroup }) => {
+const IntegrityTableCard = ({
+  group,
+  isRunning,
+  activeRepairResultId,
+  onRepairRule,
+}: {
+  group: TableResultGroup;
+  isRunning: boolean;
+  activeRepairResultId?: string | null;
+  onRepairRule?: (result: IntegrityResult) => void;
+}) => {
   const displayState = getGroupDisplayState(group.results);
 
   return (
     <section className="rounded-xl border border-border bg-background">
-      <div className="flex flex-wrap items-center gap-2 border-b border-border px-4 py-3">
+      <div className="flex flex-wrap items-center justify-between gap-3 border-b border-slate-200 bg-slate-100/90 px-4 py-3.5">
+        <div className="flex min-w-0 items-center gap-3">
+          <HeaderTypeIcon type="table" />
+          <div className="min-w-0">
+            <div className="truncate text-sm font-semibold text-slate-950">
+              {group.tableName || group.tableId}
+            </div>
+            {group.tableId ? (
+              <div className="truncate font-mono text-xs text-slate-500">{group.tableId}</div>
+            ) : null}
+          </div>
+        </div>
         <GroupStateIcon displayState={displayState} />
-        <span className="text-sm font-medium">{group.tableName || group.tableId}</span>
-        {group.tableId ? (
-          <span className="font-mono text-xs text-muted-foreground">{group.tableId}</span>
-        ) : null}
       </div>
 
-      <div className="space-y-3 p-4">
+      <div className="divide-y divide-border">
         {group.groups.map((fieldGroup) => (
           <IntegrityGroupCard
             key={`${group.tableId}:${fieldGroup.fieldId || '__general__'}`}
             group={fieldGroup}
+            isRunning={isRunning}
+            activeRepairResultId={activeRepairResultId}
+            onRepairRule={onRepairRule}
+            nested
           />
         ))}
       </div>
@@ -352,6 +985,8 @@ export const IntegrityResultsPanel = ({
   phase,
   hasTarget,
   hasFilteredOutAll,
+  activeRepairResultId,
+  onRepairRule,
 }: {
   scope: IntegrityScope;
   tableGroups: TableResultGroup[];
@@ -361,9 +996,18 @@ export const IntegrityResultsPanel = ({
   phase: IntegrityPhase;
   hasTarget: boolean;
   hasFilteredOutAll: boolean;
+  activeRepairResultId?: string | null;
+  onRepairRule?: (result: IntegrityResult) => void;
 }) => {
   const { t } = useTranslation(['table']);
   const runningText = getPhaseText(t as Translate, phase, 'running');
+  const currentResults =
+    scope === 'base'
+      ? tableGroups.flatMap((group) => group.results)
+      : groupedResults.flatMap((group) => group.results);
+  const manualRepairCount = currentResults.filter(
+    (result) => result.repair?.mode === 'manual'
+  ).length;
 
   if (!hasTarget) {
     return (
@@ -399,8 +1043,15 @@ export const IntegrityResultsPanel = ({
   if (scope === 'base') {
     return (
       <div className="space-y-4">
+        <ManualRepairNotice count={manualRepairCount} />
         {tableGroups.map((group) => (
-          <IntegrityTableCard key={group.tableId || group.tableName} group={group} />
+          <IntegrityTableCard
+            key={group.tableId || group.tableName}
+            group={group}
+            isRunning={isRunning}
+            activeRepairResultId={activeRepairResultId}
+            onRepairRule={onRepairRule}
+          />
         ))}
       </div>
     );
@@ -408,9 +1059,21 @@ export const IntegrityResultsPanel = ({
 
   return (
     <div className="space-y-4">
-      {groupedResults.map((group) => (
-        <IntegrityGroupCard key={group.fieldId || '__general__'} group={group} />
-      ))}
+      <ManualRepairNotice count={manualRepairCount} />
+      <section className="overflow-hidden rounded-xl border border-border bg-background">
+        <div className="divide-y divide-border">
+          {groupedResults.map((group) => (
+            <IntegrityGroupCard
+              key={group.fieldId || '__general__'}
+              group={group}
+              isRunning={isRunning}
+              activeRepairResultId={activeRepairResultId}
+              onRepairRule={onRepairRule}
+              nested
+            />
+          ))}
+        </div>
+      </section>
     </div>
   );
 };
diff --git a/apps/nextjs-app/src/features/app/blocks/design/components/IntegrityV2Dialog.tsx b/apps/nextjs-app/src/features/app/blocks/design/components/IntegrityV2Dialog.tsx
index 3757d1ca41..72e9fddd24 100644
--- a/apps/nextjs-app/src/features/app/blocks/design/components/IntegrityV2Dialog.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/design/components/IntegrityV2Dialog.tsx
@@ -38,7 +38,6 @@ import {
   type IntegrityPhase,
   type IntegrityResult,
   type IntegrityScope,
-  type IntegritySummary,
   type Translate,
   upsertResult,
 } from './integrityV2Utils';
@@ -62,15 +61,16 @@ export const IntegrityV2Dialog = ({
   const [hasRun, setHasRun] = useState(false);
   const [results, setResults] = useState<IntegrityResult[]>([]);
   const [streamError, setStreamError] = useState<string | null>(null);
-  const [lastCheckSummary, setLastCheckSummary] = useState<IntegritySummary | null>(null);
   const [selectedStatuses, setSelectedStatuses] =
     useState<IntegrityFilterStatus[]>(integrityFilterStatuses);
+  const [activeRepairResultId, setActiveRepairResultId] = useState<string | null>(null);
   const abortRef = useRef<AbortController | null>(null);
 
   const stopStream = useCallback(() => {
     abortRef.current?.abort();
     abortRef.current = null;
     setIsRunning(false);
+    setActiveRepairResultId(null);
   }, []);
 
   const runCheck = useCallback(async () => {
@@ -107,8 +107,6 @@ export const IntegrityV2Dialog = ({
           onResult,
         });
       }
-
-      setLastCheckSummary(createSummary(nextResults));
     } catch (error) {
       if (!controller.signal.aborted) {
         const message = getErrorMessage(error, t('table:table.integrity.v2.streamError'));
@@ -123,58 +121,113 @@ export const IntegrityV2Dialog = ({
     }
   }, [baseId, scope, stopStream, t, tableId]);
 
-  const runRepair = useCallback(async () => {
-    if (!baseId) {
-      return;
-    }
+  const runRepair = useCallback(
+    async (targetStatuses: Array<'warn' | 'error'> = ['warn']) => {
+      if (!baseId) {
+        return;
+      }
 
-    stopStream();
-    const controller = new AbortController();
-    abortRef.current = controller;
+      stopStream();
+      const controller = new AbortController();
+      abortRef.current = controller;
 
-    setPhase('repair');
-    setHasRun(true);
-    setIsRunning(true);
-    setStreamError(null);
-    setResults([]);
+      setPhase('repair');
+      setHasRun(true);
+      setIsRunning(true);
+      setActiveRepairResultId(null);
+      setStreamError(null);
+      setResults([]);
 
-    try {
-      const onResult = (result: IntegrityResult) => {
-        setResults((currentResults) => upsertResult(currentResults, result));
-      };
+      try {
+        const onResult = (result: IntegrityResult) => {
+          setResults((currentResults) => upsertResult(currentResults, result));
+        };
+
+        if (scope === 'table' && tableId) {
+          await streamV2TableSchemaIntegrityRepair(
+            tableId,
+            { targetStatuses },
+            {
+              signal: controller.signal,
+              onResult,
+            }
+          );
+        } else {
+          await streamV2BaseSchemaIntegrityRepair(
+            baseId,
+            { targetStatuses },
+            {
+              signal: controller.signal,
+              onResult,
+            }
+          );
+        }
+      } catch (error) {
+        if (!controller.signal.aborted) {
+          const message = getErrorMessage(error, t('table:table.integrity.v2.streamError'));
+          setStreamError(message);
+          toast.error(message);
+        }
+      } finally {
+        if (abortRef.current === controller) {
+          abortRef.current = null;
+          setIsRunning(false);
+          setActiveRepairResultId(null);
+        }
+      }
+    },
+    [baseId, scope, stopStream, t, tableId]
+  );
+
+  const runRuleRepair = useCallback(
+    async (result: IntegrityResult) => {
+      if (!result.tableId || !result.fieldId) {
+        return;
+      }
+
+      stopStream();
+      const controller = new AbortController();
+      abortRef.current = controller;
+
+      setPhase('repair');
+      setHasRun(true);
+      setIsRunning(true);
+      setActiveRepairResultId(result.id);
+      setStreamError(null);
+
+      try {
+        const onResult = (nextResult: IntegrityResult) => {
+          setResults((currentResults) => upsertResult(currentResults, nextResult));
+        };
 
-      if (scope === 'table' && tableId) {
         await streamV2TableSchemaIntegrityRepair(
-          tableId,
-          {},
+          result.tableId,
           {
-            signal: controller.signal,
-            onResult,
-          }
-        );
-      } else {
-        await streamV2BaseSchemaIntegrityRepair(
-          baseId,
-          {},
+            fieldId: result.fieldId,
+            ruleId: result.ruleId,
+            targetStatuses: ['warn', 'error'],
+          },
           {
             signal: controller.signal,
             onResult,
           }
         );
+      } catch (error) {
+        if (!controller.signal.aborted) {
+          const message = getErrorMessage(error, t('table:table.integrity.v2.streamError'));
+          setStreamError(message);
+          toast.error(message);
+        }
+      } finally {
+        if (abortRef.current === controller) {
+          abortRef.current = null;
+          setIsRunning(false);
+          setActiveRepairResultId(null);
+        }
       }
-    } catch (error) {
-      if (!controller.signal.aborted) {
-        const message = getErrorMessage(error, t('table:table.integrity.v2.streamError'));
-        setStreamError(message);
-        toast.error(message);
-      }
-    } finally {
-      if (abortRef.current === controller) {
-        abortRef.current = null;
-        setIsRunning(false);
-      }
-    }
-  }, [baseId, scope, stopStream, t, tableId]);
+    },
+    [stopStream, t]
+  );
 
   useEffect(() => {
     if (!open) {
@@ -203,8 +256,18 @@ export const IntegrityV2Dialog = ({
   const filteredResults = filterResultsByStatuses(results, selectedStatuses);
   const groupedResults = groupResults(filteredResults);
   const tableGroups = groupResultsByTable(filteredResults);
-  const canRepair = Boolean(
-    baseId && !isRunning && lastCheckSummary && lastCheckSummary.issueCount > 0
+  const canRepairWarnings = Boolean(
+    baseId &&
+      !isRunning &&
+      results.some((result) => result.status === 'warn' && result.repair?.available)
+  );
+  const canRepairAny = Boolean(
+    baseId &&
+      !isRunning &&
+      results.some(
+        (result) =>
+          (result.status === 'warn' || result.status === 'error') && result.repair?.available
+      )
   );
   const hasFilteredOutAll = filteredResults.length === 0 && results.length > 0;
 
@@ -245,11 +308,12 @@ export const IntegrityV2Dialog = ({
             <IntegrityActions
               canRun={Boolean(baseId)}
               hasRun={hasRun}
-              canRepair={canRepair}
+              canRepairWarnings={canRepairWarnings}
+              canRepairAny={canRepairAny}
               isRunning={isRunning}
               phase={phase}
               onCheck={() => void runCheck()}
-              onRepair={() => void runRepair()}
+              onRepair={(targetStatuses) => void runRepair(targetStatuses)}
             />
             <IntegrityStatusFilters
               summary={summary}
@@ -275,6 +339,8 @@ export const IntegrityV2Dialog = ({
             phase={phase}
             hasTarget={Boolean(baseId)}
             hasFilteredOutAll={hasFilteredOutAll}
+            activeRepairResultId={activeRepairResultId}
+            onRepairRule={(result) => void runRuleRepair(result)}
           />
         </ScrollArea>
 
diff --git a/apps/nextjs-app/src/features/app/blocks/design/components/integrityV2Utils.ts b/apps/nextjs-app/src/features/app/blocks/design/components/integrityV2Utils.ts
index 4cb60faa39..37d7a16924 100644
--- a/apps/nextjs-app/src/features/app/blocks/design/components/integrityV2Utils.ts
+++ b/apps/nextjs-app/src/features/app/blocks/design/components/integrityV2Utils.ts
@@ -1,6 +1,7 @@
 import type {
   IV2SchemaIntegrityFilterStatus,
   IV2SchemaIntegrityCheckResult,
+  IV2SchemaIntegrityI18nMessage,
   IV2SchemaIntegrityRepairResult,
 } from '@teable/openapi';
 
@@ -46,6 +47,8 @@ export type Translate = {
   (key: string, options: Record<string, unknown>): string;
 };
 
+type IntegrityI18nMessage = IV2SchemaIntegrityI18nMessage;
+
 export const integrityFilterStatuses: IntegrityFilterStatus[] = [
   'success',
   'warn',
@@ -333,6 +336,24 @@ const localizedMessageKeys: Record<string, string> = {
   'Base schema integrity check completed': 'table:table.integrity.v2.message.baseCheckCompleted',
   'Schema integrity repair completed': 'table:table.integrity.v2.message.repairCompleted',
   'Base schema integrity repair completed': 'table:table.integrity.v2.message.baseRepairCompleted',
+  'Skipped: status not selected for repair':
+    'table:table.integrity.v2.message.skippedStatusNotSelected',
+  'Skipped: repair unavailable': 'table:table.integrity.v2.message.skippedRepairUnavailable',
+};
+
+export const translateIntegrityMessage = (
+  t: Translate,
+  message?: IntegrityI18nMessage
+): string | undefined => {
+  if (!message) {
+    return undefined;
+  }
+
+  if (message.key) {
+    return t(message.key, message.values || {});
+  }
+
+  return message.fallback;
 };
 
 export const getLocalizedRuleDescription = (t: Translate, result: IntegrityResult) => {
@@ -422,11 +443,40 @@ export const getLocalizedResultMessage = (t: Translate, result: IntegrityResult)
 
 export const getLocalizedDetailItems = (
   t: Translate,
-  items?: ReadonlyArray<string>
+  items?: ReadonlyArray<
+    | string
+    | {
+        code?: string;
+        message: IntegrityI18nMessage;
+        description?: IntegrityI18nMessage;
+      }
+  >
 ): string[] | undefined => {
   if (!items?.length) {
     return undefined;
   }
 
-  return items.map((item) => localizeSystemDetail(t, item));
+  return items.flatMap((item) => {
+    if (typeof item === 'string') {
+      return [localizeSystemDetail(t, item)];
+    }
+
+    const message = translateIntegrityMessage(t, item.message);
+    const description = translateIntegrityMessage(t, item.description);
+
+    if (message && description) {
+      return [`${message}: ${description}`];
+    }
+
+    const localized = description || message || item.code;
+    return localized ? [localized] : [];
+  });
+};
+
+export const getLocalizedRepairReason = (t: Translate, result: IntegrityResult) => {
+  return translateIntegrityMessage(t, result.repair?.reason);
+};
+
+export const getLocalizedRepairDescription = (t: Translate, result: IntegrityResult) => {
+  return translateIntegrityMessage(t, result.repair?.description);
 };
diff --git a/apps/nextjs-app/src/features/app/blocks/share/base/share-base-ssr.ts b/apps/nextjs-app/src/features/app/blocks/share/base/share-base-ssr.ts
index 7551ee2a2c..c137b9eb73 100644
--- a/apps/nextjs-app/src/features/app/blocks/share/base/share-base-ssr.ts
+++ b/apps/nextjs-app/src/features/app/blocks/share/base/share-base-ssr.ts
@@ -19,6 +19,7 @@ export interface IShareBasePagePropsBase extends IBaseNodePageProps {
   shareNodeId?: string;
   allowSave?: boolean;
   allowCopy?: boolean;
+  allowEdit?: boolean;
 }
 
 export const getCurrentUser = async (ssrApi: SsrApi) => {
@@ -56,6 +57,7 @@ export const buildShareProps = async <T extends IShareBasePagePropsBase>(
       shareNodeId: shareData.shareMeta?.nodeId,
       allowSave: !!shareData?.shareMeta?.allowSave,
       allowCopy: !!shareData?.shareMeta?.allowCopy,
+      allowEdit: !!shareData?.shareMeta?.allowEdit,
       ...extraProps,
     } as T,
   };
diff --git a/apps/nextjs-app/src/features/app/blocks/table/Table.tsx b/apps/nextjs-app/src/features/app/blocks/table/Table.tsx
index 76dd6f1765..e13981b87b 100644
--- a/apps/nextjs-app/src/features/app/blocks/table/Table.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/table/Table.tsx
@@ -1,5 +1,6 @@
 import { useQuery, useQueryClient } from '@tanstack/react-query';
 import type { IFieldVo, IRecord, IViewVo } from '@teable/core';
+import { ViewType } from '@teable/core';
 import {
   getBaseById,
   LastVisitResourceType,
@@ -13,13 +14,14 @@ import {
   ViewProvider,
   PersonalViewProxy,
   PersonalViewProvider,
+  ShareSessionViewStoreProvider,
   ReactQueryKeys,
   useTables,
   useIsReadOnlyPreview,
 } from '@teable/sdk';
 import { TablePermissionProvider } from '@teable/sdk/context/table-permission';
 import Head from 'next/head';
-import { useEffect } from 'react';
+import { useEffect, useMemo } from 'react';
 import { ErrorBoundary } from 'react-error-boundary';
 import { useHotkeys } from 'react-hotkeys-hook';
 import {
@@ -28,6 +30,7 @@ import {
 } from '../../components/download-attachments';
 import { PluginContextMenu } from '../../components/plugin-context-menu/PluginContextMenu';
 import { PluginPanel } from '../../components/plugin-panel/PluginPanel';
+import { useShareContext, useShareEffectiveEdit } from '../../context/ShareContext';
 import type { IBaseResourceTable } from '../../hooks/useBaseResource';
 import { useBaseResource } from '../../hooks/useBaseResource';
 import { useBrand } from '../../hooks/useBrand';
@@ -36,6 +39,25 @@ import { FailAlert } from './FailAlert';
 import { useViewErrorHandler } from './hooks/use-view-error-handler';
 import { TableHeader } from './table-header/TableHeader';
 
+const SessionViewStoreWrapper = ({
+  useSession,
+  initialViewMap,
+  children,
+}: {
+  useSession: boolean;
+  initialViewMap?: Record<string, Record<string, unknown>>;
+  children: React.ReactNode;
+}) => {
+  if (useSession && initialViewMap) {
+    return (
+      <ShareSessionViewStoreProvider initialViewMap={initialViewMap}>
+        {children}
+      </ShareSessionViewStoreProvider>
+    );
+  }
+  return <>{children}</>;
+};
+
 export interface ITableProps {
   fieldServerData: IFieldVo[];
   viewServerData: IViewVo[];
@@ -56,6 +78,32 @@ export const Table: React.FC<ITableProps> = ({
   const queryClient = useQueryClient();
   const isReadOnlyPreview = useIsReadOnlyPreview();
   const { baseId, tableId, viewId } = useBaseResource() as IBaseResourceTable;
+  const { shareId } = useShareContext();
+  const isShareEditor = useShareEffectiveEdit();
+
+  // In share mode without effective edit (can view / anonymous), or template mode, use session-only personal view
+  const isTemplate = isReadOnlyPreview && !shareId;
+  const useSessionPersonalView = isTemplate || Boolean(shareId && !isShareEditor);
+
+  // Build initial view map from server data for session-only personal view
+  const initialViewMap = useMemo(() => {
+    if (!useSessionPersonalView) return undefined;
+    const map: Record<string, Record<string, unknown>> = {};
+    for (const view of viewServerData) {
+      if (view.type === ViewType.Plugin || view.type === ViewType.Form) continue;
+      map[view.id] = {
+        id: view.id,
+        type: view.type,
+        filter: view.filter,
+        sort: view.sort,
+        group: view.group,
+        options: view.options,
+        columnMeta: view.columnMeta,
+      };
+    }
+    return map;
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [useSessionPersonalView]);
 
   const table = tables.find((t) => t.id === tableId);
 
@@ -100,38 +148,43 @@ export const Table: React.FC<ITableProps> = ({
       </Head>
       <TablePermissionProvider baseId={baseId}>
         <ViewProvider serverData={viewServerData}>
-          <PersonalViewProxy serverData={viewServerData}>
-            <FieldProvider serverSideData={fieldServerData}>
-              <PersonalViewProvider>
-                <div className="flex h-full grow basis-[500px]">
-                  <div
-                    className="flex flex-1 flex-col overflow-hidden"
-                    data-screenshot-target="base-view"
-                  >
-                    <TableHeader />
-                    <ErrorBoundary
-                      fallback={
-                        <div className="flex size-full items-center justify-center">
-                          <FailAlert />
-                        </div>
-                      }
+          <SessionViewStoreWrapper
+            useSession={useSessionPersonalView}
+            initialViewMap={initialViewMap}
+          >
+            <PersonalViewProxy serverData={viewServerData}>
+              <FieldProvider serverSideData={fieldServerData}>
+                <PersonalViewProvider>
+                  <div className="flex h-full grow basis-[500px]">
+                    <div
+                      className="flex flex-1 flex-col overflow-hidden"
+                      data-screenshot-target="base-view"
                     >
-                      <View
-                        recordServerData={recordServerData}
-                        recordsServerData={recordsServerData}
-                        groupPointsServerDataMap={groupPointsServerDataMap}
-                      />
-                    </ErrorBoundary>
+                      <TableHeader />
+                      <ErrorBoundary
+                        fallback={
+                          <div className="flex size-full items-center justify-center">
+                            <FailAlert />
+                          </div>
+                        }
+                      >
+                        <View
+                          recordServerData={recordServerData}
+                          recordsServerData={recordsServerData}
+                          groupPointsServerDataMap={groupPointsServerDataMap}
+                        />
+                      </ErrorBoundary>
+                    </div>
+                    <PluginPanel tableId={tableId} />
+                    <PluginContextMenu tableId={tableId} baseId={baseId} />
+                    <DownloadAllAttachmentsDialog />
+                    <CellDownloadHandler />
+                    {/* <ChatPanel /> */}
                   </div>
-                  <PluginPanel tableId={tableId} />
-                  <PluginContextMenu tableId={tableId} baseId={baseId} />
-                  <DownloadAllAttachmentsDialog />
-                  <CellDownloadHandler />
-                  {/* <ChatPanel /> */}
-                </div>
-              </PersonalViewProvider>
-            </FieldProvider>
-          </PersonalViewProxy>
+                </PersonalViewProvider>
+              </FieldProvider>
+            </PersonalViewProxy>
+          </SessionViewStoreWrapper>
         </ViewProvider>
       </TablePermissionProvider>
     </AnchorContext.Provider>
diff --git a/apps/nextjs-app/src/features/app/blocks/table/table-header/BaseShare.tsx b/apps/nextjs-app/src/features/app/blocks/table/table-header/BaseShare.tsx
index 3b66947acf..e0feae3409 100644
--- a/apps/nextjs-app/src/features/app/blocks/table/table-header/BaseShare.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/table/table-header/BaseShare.tsx
@@ -1,3 +1,5 @@
+import { hasPermission } from '@teable/core';
+import { useBase } from '@teable/sdk/hooks';
 import { Button } from '@teable/ui-lib/shadcn';
 import { ChevronRight, Send } from 'lucide-react';
 import { useTranslation } from 'next-i18next';
@@ -5,6 +7,13 @@ import { PublishBaseDialog } from './publish-base/PublishBaseDialog';
 
 export const BaseShare = ({ onClose }: { onClose: () => void }) => {
   const { t } = useTranslation(['table', 'common', 'space']);
+  const base = useBase();
+  const hasUpdatePermission = hasPermission(base.role, 'base|update');
+
+  if (!hasUpdatePermission) {
+    return null;
+  }
+
   return (
     <PublishBaseDialog onClose={onClose} closeOnSuccess={false}>
       <Button
diff --git a/apps/nextjs-app/src/features/app/blocks/view/View.tsx b/apps/nextjs-app/src/features/app/blocks/view/View.tsx
index 2011894e2d..4d3a28a846 100644
--- a/apps/nextjs-app/src/features/app/blocks/view/View.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/view/View.tsx
@@ -10,6 +10,7 @@ import {
 import { useTranslation } from 'next-i18next';
 import { useEffect } from 'react';
 import type { Query } from 'sharedb';
+import { useShareEffectiveEdit } from '@/features/app/context/ShareContext';
 import { tableConfig } from '@/features/i18n/table.config';
 import { CalendarView } from './calendar/CalendarView';
 import { FormView } from './form/FormView';
@@ -27,13 +28,16 @@ export const View = (props: IViewBaseProps) => {
   const { connection } = useConnection();
   const tableId = useTableId();
   const isReadOnlyPreview = useIsReadOnlyPreview();
+  const isShareEditor = useShareEffectiveEdit();
   const { openPersonalView, isPersonalView } = usePersonalView();
 
+  // Auto-open personal view for read-only contexts:
+  // template, can-view share, or anonymous on can-edit share (no real edit permissions).
   useEffect(() => {
-    if (isReadOnlyPreview && !isPersonalView) {
+    if (isReadOnlyPreview && !isShareEditor && !isPersonalView) {
       openPersonalView?.();
     }
-  }, [isReadOnlyPreview, openPersonalView, isPersonalView]);
+  }, [isReadOnlyPreview, isShareEditor, openPersonalView, isPersonalView]);
 
   if (tableId && connection?.queries) {
     const query = Object.values(connection?.queries).find(
diff --git a/apps/nextjs-app/src/features/app/blocks/view/tool-bar/Others.tsx b/apps/nextjs-app/src/features/app/blocks/view/tool-bar/Others.tsx
index 82c26f4416..0259d8a5ca 100644
--- a/apps/nextjs-app/src/features/app/blocks/view/tool-bar/Others.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/view/tool-bar/Others.tsx
@@ -5,6 +5,7 @@ import { useTranslation } from 'next-i18next';
 import { useMemo, useState } from 'react';
 import { useBaseNodeContext } from '@/features/app/blocks/base/base-node/hooks/useBaseNodeContext';
 import { useSharedNodeIds } from '@/features/app/blocks/base/base-side-bar/BaseNodeShareIndicator';
+import { useShareEffectiveEdit } from '@/features/app/context/ShareContext';
 import { tableConfig } from '@/features/i18n/table.config';
 import { SearchButton } from '../search/SearchButton';
 import { PersonalViewSwitch } from './components';
@@ -107,6 +108,8 @@ const OthersMenu = ({ className }: { className?: string }) => {
 
 export const Others: React.FC = () => {
   const isReadOnlyPreview = useIsReadOnlyPreview();
+  const isShareEditor = useShareEffectiveEdit();
+  const showControls = !isReadOnlyPreview || isShareEditor;
   return (
     <div
       className={cn(
@@ -116,16 +119,22 @@ export const Others: React.FC = () => {
       )}
     >
       <SearchButton className="size-7 shrink-0" />
-      {!isReadOnlyPreview && (
+      {showControls && (
         <>
           <div className="mx-1 h-4 w-px shrink-0 bg-border"></div>
           <UndoRedoButtons />
           <div className="mx-1 h-4 w-px shrink-0 bg-border"></div>
-          <OthersList
-            className="hidden @md/toolbar:flex"
-            classNames={{ textClassName: '@2xl/toolbar:inline' }}
-          />
-          <OthersMenu className="@md/toolbar:hidden" />
+          {isShareEditor ? (
+            <PersonalViewSwitch />
+          ) : (
+            <>
+              <OthersList
+                className="hidden @md/toolbar:flex"
+                classNames={{ textClassName: '@2xl/toolbar:inline' }}
+              />
+              <OthersMenu className="@md/toolbar:hidden" />
+            </>
+          )}
         </>
       )}
     </div>
diff --git a/apps/nextjs-app/src/features/app/components/PublicOperateButton.tsx b/apps/nextjs-app/src/features/app/components/PublicOperateButton.tsx
index 416143d187..b36893655a 100644
--- a/apps/nextjs-app/src/features/app/components/PublicOperateButton.tsx
+++ b/apps/nextjs-app/src/features/app/components/PublicOperateButton.tsx
@@ -1,10 +1,11 @@
+import { useTheme } from '@teable/next-themes';
 import { useIsAnonymous, useIsHydrated, useShareId, useTemplate } from '@teable/sdk/hooks';
 import { Button } from '@teable/ui-lib/shadcn';
 import Image from 'next/image';
 import { useRouter } from 'next/router';
 import { useTranslation } from 'next-i18next';
 import React, { useRef } from 'react';
-import { useShareAllowSave } from '../context/ShareContext';
+import { useShareAllowEdit, useShareAllowSave } from '../context/ShareContext';
 import { useIsInIframe } from '../hooks/useIsInIframe';
 import type { IShareSelectSpaceDialogRef } from './ShareSelectSpaceDialog';
 import { ShareSelectSpaceDialog } from './ShareSelectSpaceDialog';
@@ -18,17 +19,45 @@ export const PublicOperateButton = () => {
   const isTemplate = !!template;
   const isShare = !!shareId;
   const allowSave = useShareAllowSave();
-  const { t } = useTranslation(['common']);
+  const allowEdit = useShareAllowEdit();
+  const { t } = useTranslation(['common', 'table']);
   const router = useRouter();
   const isInIframe = useIsInIframe();
   const templateRef = useRef<ITemplateSelectSpaceDialogRef>(null);
   const shareRef = useRef<IShareSelectSpaceDialogRef>(null);
   const isHydrated = useIsHydrated();
 
+  const { resolvedTheme } = useTheme();
+  const isDark = resolvedTheme === 'dark';
+
   if (isInIframe || !isHydrated) {
     return <></>;
   }
 
+  // For share mode with allowEdit, show login card for anonymous users
+  if (isShare && allowEdit && isAnonymous) {
+    const handleLoginClick = () => {
+      router.push(`/auth/login?redirect=${encodeURIComponent(window.location.href)}`);
+    };
+
+    return (
+      <div className="flex w-full flex-col items-center">
+        <Image
+          src={isDark ? '/images/layout/welcome-dark.png' : '/images/layout/welcome-light.png'}
+          alt=""
+          width={120}
+          height={120}
+        />
+        <p className="mb-3 text-xs text-muted-foreground">
+          {t('table:baseShare.editRequiresLogin')}
+        </p>
+        <Button size={'sm'} className="w-full text-[13px] font-normal" onClick={handleLoginClick}>
+          {t('common:actions.login')}
+        </Button>
+      </div>
+    );
+  }
+
   // For share mode, show "Copy to my space" button if allowSave is enabled
   if (isShare) {
     // Don't show the button if allowSave is disabled
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/FieldEditor.tsx b/apps/nextjs-app/src/features/app/components/field-setting/FieldEditor.tsx
index 9cc7179a22..e1b3ea0e69 100644
--- a/apps/nextjs-app/src/features/app/components/field-setting/FieldEditor.tsx
+++ b/apps/nextjs-app/src/features/app/components/field-setting/FieldEditor.tsx
@@ -1,16 +1,20 @@
+import { useQuery } from '@tanstack/react-query';
 import type { IFieldOptionsRo, IFieldVo } from '@teable/core';
 import {
   FieldType,
   checkFieldNotNullValidationEnabled,
   checkFieldUniqueValidationEnabled,
   isConditionalLookupOptions,
+  isLinkLookupOptions,
 } from '@teable/core';
 import { Plus } from '@teable/icons';
+import { getField } from '@teable/openapi';
 import { useFieldStaticGetter } from '@teable/sdk';
+import { useFields } from '@teable/sdk/hooks';
 import { Button, Textarea } from '@teable/ui-lib/shadcn';
 import { Input } from '@teable/ui-lib/shadcn/ui/input';
 import { useTranslation } from 'next-i18next';
-import { useCallback, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 import { tableConfig } from '@/features/i18n/table.config';
 import { useIsCloud } from '../../hooks/useIsCloud';
 import { useIsEE } from '../../hooks/useIsEE';
@@ -18,6 +22,7 @@ import { FieldAiConfig } from './field-ai-config';
 import { FieldValidation } from './field-validation/FieldValidation';
 import { FieldOptions } from './FieldOptions';
 import type { IFieldOptionsProps } from './FieldOptions';
+import { hydrateLookupFieldState } from './hooks/hydrateLookupFieldState';
 import { useUpdateConditionalLookupOptions } from './hooks/useUpdateConditionalLookupOptions';
 import { useUpdateLookupOptions } from './hooks/useUpdateLookupOptions';
 import { LookupOptions } from './lookup-options/LookupOptions';
@@ -28,6 +33,31 @@ import { FieldOperator } from './type';
 import type { IFieldEditorRo } from './type';
 import { useFieldTypeSubtitle } from './useFieldTypeSubtitle';
 
+const useSelectedLookupField = (field: Partial<IFieldEditorRo>) => {
+  const fields = useFields({ withHidden: true, withDenied: true });
+  const lookupOptions = isLinkLookupOptions(field.lookupOptions) ? field.lookupOptions : undefined;
+  const lookupFieldId = lookupOptions?.lookupFieldId;
+  const foreignTableId = lookupOptions?.foreignTableId;
+
+  const localLookupField = useMemo(() => {
+    if (!lookupFieldId) return undefined;
+    return fields.find((candidate) => candidate.id === lookupFieldId);
+  }, [fields, lookupFieldId]);
+
+  const shouldFetchLookupField = Boolean(field.isLookup && foreignTableId && lookupFieldId);
+
+  const { data: remoteLookupField } = useQuery({
+    queryKey: ['field-editor-lookup-field', foreignTableId, lookupFieldId],
+    queryFn: async () => {
+      const res = await getField(foreignTableId!, lookupFieldId!);
+      return res.data;
+    },
+    enabled: shouldFetchLookupField && !localLookupField,
+  });
+
+  return localLookupField ?? remoteLookupField;
+};
+
 export const FieldEditor = (props: {
   isPrimary?: boolean;
   field: Partial<IFieldEditorRo>;
@@ -45,7 +75,9 @@ export const FieldEditor = (props: {
   );
   const getFieldSubtitle = useFieldTypeSubtitle();
   const getFieldStatic = useFieldStaticGetter();
+  const fields = useFields({ withHidden: true, withDenied: true });
   const { t } = useTranslation(tableConfig.i18nNamespaces);
+  const selectedLookupField = useSelectedLookupField(field);
 
   const isEE = useIsEE();
   const isCloud = useIsCloud();
@@ -130,6 +162,29 @@ export const FieldEditor = (props: {
   const updateLookupOptions = useUpdateLookupOptions(field, setFieldFn);
   const updateConditionalLookupOptions = useUpdateConditionalLookupOptions(field, setFieldFn);
 
+  useEffect(() => {
+    if (!field.isLookup || field.isConditionalLookup || !selectedLookupField) {
+      return;
+    }
+
+    const lookupOptions = isLinkLookupOptions(field.lookupOptions)
+      ? field.lookupOptions
+      : undefined;
+    const linkField = lookupOptions?.linkFieldId
+      ? fields.find((candidate) => candidate.id === lookupOptions.linkFieldId)
+      : undefined;
+
+    const hydratedField = hydrateLookupFieldState({
+      field: field as IFieldEditorRo,
+      lookupField: selectedLookupField,
+      linkField,
+    });
+
+    if (hydratedField) {
+      setFieldFn(hydratedField);
+    }
+  }, [field, fields, selectedLookupField, setFieldFn]);
+
   const getUnionOptions = () => {
     if (field.isLookup) {
       if (field.isConditionalLookup) {
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/hooks/hydrateLookupFieldState.spec.ts b/apps/nextjs-app/src/features/app/components/field-setting/hooks/hydrateLookupFieldState.spec.ts
new file mode 100644
index 0000000000..7d4156313c
--- /dev/null
+++ b/apps/nextjs-app/src/features/app/components/field-setting/hooks/hydrateLookupFieldState.spec.ts
@@ -0,0 +1,67 @@
+import { CellValueType, FieldType } from '@teable/core';
+import { hydrateLookupFieldState } from './hydrateLookupFieldState';
+
+describe('hydrateLookupFieldState', () => {
+  it('hydrates stale lookup metadata from an existing selected lookup field', () => {
+    const hydrated = hydrateLookupFieldState({
+      field: {
+        type: FieldType.SingleLineText,
+        isLookup: true,
+        lookupOptions: {
+          foreignTableId: 'tblForeign',
+          linkFieldId: 'fldLink',
+          lookupFieldId: 'fldLookup',
+        },
+      },
+      lookupField: {
+        type: FieldType.AutoNumber,
+        cellValueType: CellValueType.Number,
+        isMultipleCellValue: false,
+        options: {},
+      },
+      linkField: {
+        isMultipleCellValue: false,
+      },
+    });
+
+    expect(hydrated).toMatchObject({
+      type: FieldType.AutoNumber,
+      isLookup: true,
+      cellValueType: CellValueType.Number,
+      isMultipleCellValue: false,
+      lookupOptions: {
+        foreignTableId: 'tblForeign',
+        linkFieldId: 'fldLink',
+        lookupFieldId: 'fldLookup',
+      },
+    });
+  });
+
+  it('preserves customized lookup options once the field is already hydrated', () => {
+    const hydrated = hydrateLookupFieldState({
+      field: {
+        type: FieldType.Number,
+        isLookup: true,
+        cellValueType: CellValueType.Number,
+        isMultipleCellValue: false,
+        options: {
+          formatting: {
+            type: 'currency',
+            symbol: '$',
+          },
+        },
+      },
+      lookupField: {
+        type: FieldType.Number,
+        cellValueType: CellValueType.Number,
+        isMultipleCellValue: false,
+        options: {},
+      },
+      linkField: {
+        isMultipleCellValue: false,
+      },
+    });
+
+    expect(hydrated).toBeUndefined();
+  });
+});
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/hooks/hydrateLookupFieldState.ts b/apps/nextjs-app/src/features/app/components/field-setting/hooks/hydrateLookupFieldState.ts
new file mode 100644
index 0000000000..4e52d4a2ac
--- /dev/null
+++ b/apps/nextjs-app/src/features/app/components/field-setting/hooks/hydrateLookupFieldState.ts
@@ -0,0 +1,42 @@
+import { safeParseOptions } from '@teable/core';
+import type { IFieldVo } from '@teable/core';
+import type { IFieldEditorRo } from '../type';
+
+type LookupHydrationInput = {
+  field: IFieldEditorRo;
+  lookupField: Pick<IFieldVo, 'type' | 'cellValueType' | 'options' | 'isMultipleCellValue'>;
+  linkField?: Pick<IFieldVo, 'isMultipleCellValue'>;
+};
+
+export const hydrateLookupFieldState = ({
+  field,
+  lookupField,
+  linkField,
+}: LookupHydrationInput): IFieldEditorRo | undefined => {
+  if (!field.isLookup || field.isConditionalLookup) {
+    return;
+  }
+
+  const nextIsMultipleCellValue =
+    linkField?.isMultipleCellValue || lookupField.isMultipleCellValue || false;
+  const needsHydration =
+    field.type !== lookupField.type ||
+    field.cellValueType !== lookupField.cellValueType ||
+    field.isMultipleCellValue !== nextIsMultipleCellValue;
+
+  if (!needsHydration) {
+    return;
+  }
+
+  const optionsResult = safeParseOptions(lookupField.type, lookupField.options);
+
+  return {
+    ...field,
+    type: lookupField.type,
+    cellValueType: lookupField.cellValueType,
+    isMultipleCellValue: nextIsMultipleCellValue,
+    options:
+      field.options ??
+      (optionsResult.success ? (optionsResult.data as IFieldVo['options']) : undefined),
+  };
+};
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/options/LongTextOptions.tsx b/apps/nextjs-app/src/features/app/components/field-setting/options/LongTextOptions.tsx
index b459e9694d..56ac796675 100644
--- a/apps/nextjs-app/src/features/app/components/field-setting/options/LongTextOptions.tsx
+++ b/apps/nextjs-app/src/features/app/components/field-setting/options/LongTextOptions.tsx
@@ -35,30 +35,28 @@ export const LongTextOptions = (props: {
 
   return (
     <div className="form-control space-y-4 border-t pt-4">
+      <div className="flex w-full flex-col gap-2">
+        <Label className="text-sm font-medium">{t('table:field.editor.showAs')}</Label>
+        <Tabs value={selectedType} onValueChange={onShowAsChange} className="w-full">
+          <TabsList className="flex w-full gap-2">
+            <TabsTrigger value={textFlag} className="flex-1 font-normal">
+              {t('table:field.editor.text')}
+            </TabsTrigger>
+            <TabsTrigger value="markdown" className="flex-1 font-normal">
+              {t('table:field.editor.markdown')}
+            </TabsTrigger>
+          </TabsList>
+        </Tabs>
+      </div>
       {!isLookup && (
-        <>
-          <div className="flex w-full flex-col gap-2">
-            <Label className="text-sm font-medium">{t('table:field.editor.showAs')}</Label>
-            <Tabs value={selectedType} onValueChange={onShowAsChange} className="w-full">
-              <TabsList className="flex w-full gap-2">
-                <TabsTrigger value={textFlag} className="flex-1 font-normal">
-                  {t('table:field.editor.text')}
-                </TabsTrigger>
-                <TabsTrigger value="markdown" className="flex-1 font-normal">
-                  {t('table:field.editor.markdown')}
-                </TabsTrigger>
-              </TabsList>
-            </Tabs>
-          </div>
-          <DefaultValue onReset={() => onDefaultValueChange(undefined)}>
-            <Textarea
-              className="w-full"
-              value={options?.defaultValue || ''}
-              onChange={(e) => onDefaultValueChange(e.target.value)}
-              rows={3}
-            />
-          </DefaultValue>
-        </>
+        <DefaultValue onReset={() => onDefaultValueChange(undefined)}>
+          <Textarea
+            className="w-full"
+            value={options?.defaultValue || ''}
+            onChange={(e) => onDefaultValueChange(e.target.value)}
+            rows={3}
+          />
+        </DefaultValue>
       )}
     </div>
   );
diff --git a/apps/nextjs-app/src/features/app/context/ShareContext.tsx b/apps/nextjs-app/src/features/app/context/ShareContext.tsx
index cef4dcdd43..394ad33cf7 100644
--- a/apps/nextjs-app/src/features/app/context/ShareContext.tsx
+++ b/apps/nextjs-app/src/features/app/context/ShareContext.tsx
@@ -1,3 +1,4 @@
+import { useIsAnonymous } from '@teable/sdk';
 import { createContext, useContext } from 'react';
 
 interface IShareContext {
@@ -10,6 +11,8 @@ interface IShareContext {
   allowSave?: boolean;
   // Whether users can copy data from the shared base
   allowCopy?: boolean;
+  // Whether logged-in users can edit records
+  allowEdit?: boolean;
 }
 
 export const ShareContext = createContext<IShareContext>({});
@@ -35,3 +38,20 @@ export const useShareAllowCopy = () => {
   const { allowCopy } = useShareContext();
   return allowCopy ?? false;
 };
+
+export const useShareAllowEdit = () => {
+  const { allowEdit } = useShareContext();
+  return allowEdit ?? false;
+};
+
+/**
+ * Whether the current user effectively has edit permissions on this share link.
+ * Returns true only when allowEdit is enabled AND the user is logged in —
+ * anonymous users on an allowEdit link are treated as read-only.
+ */
+export const useShareEffectiveEdit = () => {
+  const { shareId } = useShareContext();
+  const allowEdit = useShareAllowEdit();
+  const isAnonymous = useIsAnonymous();
+  return Boolean(shareId && allowEdit && !isAnonymous);
+};
diff --git a/apps/nextjs-app/src/features/app/layouts/ShareBaseLayout.tsx b/apps/nextjs-app/src/features/app/layouts/ShareBaseLayout.tsx
index 1f14d7eb5f..ba60ab4e67 100644
--- a/apps/nextjs-app/src/features/app/layouts/ShareBaseLayout.tsx
+++ b/apps/nextjs-app/src/features/app/layouts/ShareBaseLayout.tsx
@@ -30,6 +30,7 @@ interface IShareBaseLayoutProps {
   shareNodeId?: string;
   allowSave?: boolean;
   allowCopy?: boolean;
+  allowEdit?: boolean;
 }
 
 export const ShareBaseLayout: React.FC<IShareBaseLayoutProps> = ({
@@ -41,6 +42,7 @@ export const ShareBaseLayout: React.FC<IShareBaseLayoutProps> = ({
   shareNodeId,
   allowSave,
   allowCopy,
+  allowEdit,
 }) => {
   const { baseId, tableId, viewId } = useBaseResource() as IBaseResourceTable;
   const sdkLocale = useSdkLocale();
@@ -69,8 +71,9 @@ export const ShareBaseLayout: React.FC<IShareBaseLayoutProps> = ({
       nodeId: shareNodeId,
       allowSave,
       allowCopy,
+      allowEdit,
     }),
-    [shareId, shareNodeId, allowSave, allowCopy]
+    [shareId, shareNodeId, allowSave, allowCopy, allowEdit]
   );
 
   // If not a share context, just render children (fallback)
diff --git a/packages/common-i18n/src/locales/de/space.json b/packages/common-i18n/src/locales/de/space.json
index 95f4e0e407..71478fee8f 100644
--- a/packages/common-i18n/src/locales/de/space.json
+++ b/packages/common-i18n/src/locales/de/space.json
@@ -140,8 +140,8 @@
     "empty": "Noch keine Bases"
   },
   "publishBase": {
-    "title": "Base in der Community veröffentlichen",
-    "description": "Veröffentlichen Sie Ihre Base mit einem Klick, Inspiration ist nicht länger einsam! Lassen Sie mehr Menschen Ihre Kreativität sehen, nutzen und remixen, und bauen Sie gemeinsam ein leistungsstärkeres Geschäft auf",
+    "title": "Im Vorlagenzentrum veröffentlichen",
+    "description": "Veröffentlichen Sie Ihre Base mit einem Klick im Vorlagenzentrum! Lassen Sie mehr Menschen Ihre Kreativität sehen, nutzen und remixen, und bauen Sie gemeinsam ein leistungsstärkeres Geschäft auf",
     "infoTitle": "Basisinformationen",
     "form": {
       "title": "Titel",
@@ -166,7 +166,7 @@
     "unPublish": "Veröffentlichung aufheben",
     "unPublishSuccess": "Veröffentlichung der Base erfolgreich aufgehoben!",
     "unPublishConfirmTitle": "Veröffentlichung aufheben bestätigen",
-    "unPublishConfirmDescription": "Sind Sie sicher, dass Sie die Veröffentlichung dieser Base aufheben möchten? Sie wird nicht mehr im Vorlagen-Center der Community sichtbar sein.",
+    "unPublishConfirmDescription": "Sind Sie sicher, dass Sie die Veröffentlichung dieser Base aufheben möchten? Sie wird nicht mehr im Vorlagenzentrum sichtbar sein.",
     "usageCount": "Nutzungsanzahl: ",
     "uploadCover": "Klicken, um Titelbild hochzuladen",
     "changeCover": "Klicken, um Titelbild zu ändern",
diff --git a/packages/common-i18n/src/locales/de/table.json b/packages/common-i18n/src/locales/de/table.json
index 848caab488..05f4603fe5 100644
--- a/packages/common-i18n/src/locales/de/table.json
+++ b/packages/common-i18n/src/locales/de/table.json
@@ -471,6 +471,18 @@
         "runCheck": "Prüfung starten",
         "recheck": "Erneut prüfen",
         "repair": "Reparieren",
+        "repairWarnings": "Nur Warnungen reparieren",
+        "repairWarningsAndErrors": "Warnungen und Fehler reparieren",
+        "repairRule": "Regel reparieren",
+        "repairUnavailable": "Diese Regel kann nicht automatisch repariert werden",
+        "manual": "Manuell",
+        "manualRepairNotice": "Dieses Problem muss manuell repariert werden",
+        "manualRepairNoticeWithCount": "{{count}} Probleme müssen manuell repariert werden. Klicken Sie rechts an der jeweiligen Regel auf „Manuell“, um den Reparaturdialog zu öffnen.",
+        "manualRepairDialogTitle": "Manuelle Reparatur erforderlich",
+        "manualRepairDialogDescription": "Dieses Problem kann nicht automatisch repariert werden. Prüfen Sie die Hinweise unten und wählen Sie, wie es behoben werden soll.",
+        "manualRepairDialogReason": "Warum eine manuelle Reparatur erforderlich ist",
+        "manualRepairDialogHint": "Dieser Dialog zeigt derzeit die von der Regel benötigten Reparaturoptionen. Die eigentliche Ausführung kann später auf diesem Vertrag aufbauen.",
+        "manualRepairDialogClose": "Schließen",
         "checking": "Schema wird geprüft...",
         "repairing": "Schema wird repariert...",
         "streamError": "Schema-Integritäts-Stream fehlgeschlagen.",
@@ -829,8 +841,12 @@
     "shareLink": "Freigabelink",
     "linkHolderLabel": "Die Person, die den Link erhalten hat",
     "linkHolderCanView": "Kann anzeigen",
+    "linkHolderCanViewDesc": "Anyone with the link can view the data",
     "linkHolderCanEdit": "Kann bearbeiten",
+    "linkHolderCanEditDesc": "Logged-in users can edit records in the table",
     "linkHolderCanCopyAndSave": "Kann als Kopie speichern",
+    "linkHolderCanCopyAndSaveDesc": "Anyone with the link can save a copy to their space",
+    "editRequiresLogin": "Users must log in to edit records",
     "passwordProtection": "Passwortschutz",
     "enterPassword": "Passwort eingeben",
     "selectNodes": "Tabellen auswählen",
diff --git a/packages/common-i18n/src/locales/en/common.json b/packages/common-i18n/src/locales/en/common.json
index 099239f84a..df6799542a 100644
--- a/packages/common-i18n/src/locales/en/common.json
+++ b/packages/common-i18n/src/locales/en/common.json
@@ -573,7 +573,16 @@
         "chatModelDescription": "The chat model to use, Tips: tool calling is required for teable ai features",
         "chatModels": {
           "lg": "Advanced chat model",
-          "lgDescription": "For planning, coding, and other complex task scenarios. Recommended: claude-sonnet-4.5"
+          "lgDescription": "For planning, coding, and other complex task scenarios. Recommended: claude-sonnet-4.5",
+          "md": "Standard",
+          "mdDescription": "For daily conversations and general tasks",
+          "sm": "Lightweight",
+          "smDescription": "For simple queries and quick responses",
+          "inheritHint": "Same as primary ({{model}})",
+          "modelTiers": "Model tiers",
+          "modelTiersDescription": "Optionally assign different models for standard and lightweight tasks. Unset tiers use the primary model above.",
+          "allInheriting": "All tiers using primary model",
+          "customized": "{{count}} customized"
         },
         "actions": {
           "title": "AI Capabilities",
diff --git a/packages/common-i18n/src/locales/en/space.json b/packages/common-i18n/src/locales/en/space.json
index 97da519964..4c33ca99d2 100644
--- a/packages/common-i18n/src/locales/en/space.json
+++ b/packages/common-i18n/src/locales/en/space.json
@@ -147,8 +147,8 @@
     "noBasesFound": "No bases found"
   },
   "publishBase": {
-    "title": "Publish Base to community",
-    "description": "One-click publish base, inspiration is no longer lonely! Let more people see, use, and Remix your creativity, and build a more powerful business together",
+    "title": "Publish to Template Center",
+    "description": "One-click publish base to the Template Center! Let more people see, use, and Remix your creativity, and build a more powerful business together",
     "infoTitle": "Basic info",
     "form": {
       "title": "Work title",
@@ -171,7 +171,7 @@
     "unPublish": "Unpublish",
     "unPublishSuccess": "Base unpublished successfully!",
     "unPublishConfirmTitle": "Confirm unpublish",
-    "unPublishConfirmDescription": "Are you sure you want to unpublish this base? It will no longer be visible in the community template center.",
+    "unPublishConfirmDescription": "Are you sure you want to unpublish this base? It will no longer be visible in the Template Center.",
     "usageCount": "Usage count: ",
     "uploadCover": "Click to upload cover image",
     "changeCover": "Click to change cover",
diff --git a/packages/common-i18n/src/locales/en/table.json b/packages/common-i18n/src/locales/en/table.json
index 50b80de82e..0c0d37d80d 100644
--- a/packages/common-i18n/src/locales/en/table.json
+++ b/packages/common-i18n/src/locales/en/table.json
@@ -562,6 +562,20 @@
         "runCheck": "Run Check",
         "recheck": "Re-check",
         "repair": "Repair",
+        "repairWarnings": "Repair warnings only",
+        "repairWarningsAndErrors": "Repair warnings and errors",
+        "repairRule": "Repair rule",
+        "repairUnavailable": "This rule cannot be repaired automatically",
+        "manual": "Manual",
+        "manualRepairNotice": "This issue needs manual repair",
+        "manualRepairNoticeWithCount": "{{count}} issues need manual repair. Use the \"Manual\" action on the right side of each rule to open the repair dialog.",
+        "manualRepairDialogTitle": "Manual repair required",
+        "manualRepairDialogDescription": "This issue cannot be repaired automatically. Review the guidance below and choose how it should be fixed.",
+        "manualRepairDialogReason": "Why manual repair is needed",
+        "manualRepairDialogHint": "This dialog currently guides the user through the repair choices required by the rule. Execution can be added on top of this contract later.",
+        "manualRepairDialogClose": "Close",
+        "manualRepairPreview": "Manual repair setup",
+        "manualRepairPreviewTip": "Manual repair is not submitted yet. This preview shows the options the rule asks the user to choose from.",
         "checking": "Checking schema...",
         "repairing": "Repairing schema...",
         "streamError": "Failed to stream schema integrity results.",
@@ -590,7 +604,9 @@
           "checkCompleted": "Schema integrity check completed",
           "baseCheckCompleted": "Base schema integrity check completed",
           "repairCompleted": "Schema integrity repair completed",
-          "baseRepairCompleted": "Base schema integrity repair completed"
+          "baseRepairCompleted": "Base schema integrity repair completed",
+          "skippedStatusNotSelected": "Skipped because this status level was not selected for repair",
+          "skippedRepairUnavailable": "Skipped because automatic repair is unavailable in the current state"
         },
         "rule": {
           "column": "Physical column",
@@ -629,7 +645,52 @@
           "systemColumnNotNull": "System column \"{{columnName}}\" should be NOT NULL",
           "systemColumnUnique": "System column \"{{columnName}}\" should have a UNIQUE index",
           "systemColumnPrimaryKey": "System column \"{{columnName}}\" should be PRIMARY KEY",
-          "systemColumnDefault": "System column \"{{columnName}}\" should have a default expression"
+          "systemColumnDefault": "System column \"{{columnName}}\" should have a default expression",
+          "columnUniqueMissing": "Field \"{{fieldName}}\" should be unique",
+          "columnUniqueMissingDescription": "Add a UNIQUE constraint to \"{{fieldName}}\" so duplicate values cannot be written.",
+          "columnUniqueIndexMismatch": "Field \"{{fieldName}}\" is missing the expected unique index",
+          "columnUniqueIndexMismatchDescription": "Rebuild the index for \"{{fieldName}}\" as a unique index so reads and writes follow the field's uniqueness rule.",
+          "foreignKeyMissing": "Field \"{{fieldName}}\" is missing its foreign key constraint",
+          "foreignKeyMissingDescription": "Restore the foreign key from \"{{fieldName}}\" to \"{{targetTableName}}\" so linked records stay consistent.",
+          "foreignKeyTargetTableMissing": "The linked table for \"{{fieldName}}\" cannot be found",
+          "foreignKeyTargetTableMissingDescription": "Automatic repair cannot restore the foreign key for \"{{fieldName}}\" because the target table \"{{targetPhysicalTableName}}\" does not exist.",
+          "referenceMissing": "Field \"{{fieldName}}\" is missing a reference mapping",
+          "referenceMissingDescription": "Restore the reference metadata between \"{{fieldName}}\" and its dependency field so lookup and relation updates can propagate correctly.",
+          "symmetricFieldTargetMissing": "The paired link field for \"{{fieldName}}\" cannot be found",
+          "symmetricFieldWrongType": "The paired field for \"{{fieldName}}\" is not a link field",
+          "symmetricFieldInvalidOptions": "The paired field for \"{{fieldName}}\" has invalid link configuration",
+          "symmetricFieldMissingBackReference": "The paired field for \"{{fieldName}}\" does not point back to the current field",
+          "symmetricFieldWrongBackReference": "The paired field for \"{{fieldName}}\" points to another field instead of the current one",
+          "symmetricFieldDuplicateUsage": "The symmetric link target \"{{symmetricFieldId}}\" is reused by \"{{conflictFieldName}}\"",
+          "symmetricFieldDuplicateUsageDescription": "Each two-way link pair must have a unique symmetric field. Choose which field should keep this relationship before repairing."
+        },
+        "repairMeta": {
+          "reason": {
+            "alreadyValid": "This rule is already valid",
+            "manualRule": "This rule requires a manual decision",
+            "statementGenerationFailed": "The system could not generate a safe repair statement",
+            "noStatements": "This rule has no automatic repair statement",
+            "symmetricFieldConflict": "This symmetric link conflict needs a manual choice",
+            "foreignKeyTargetTableMissing": "Automatic repair is unavailable because the linked table is missing"
+          },
+          "description": {
+            "symmetricFieldConflict": "More than one field points at the same symmetric link target. Pick which field should own the two-way relationship before repairing.",
+            "foreignKeyTargetTableMissing": "Check whether the linked table {{targetPhysicalTableName}} was deleted or renamed. Recreate the table, or update/remove the link configuration for \"{{fieldName}}\", then run the check again."
+          },
+          "manual": {
+            "apply": "Apply manual repair",
+            "symmetricField": {
+              "title": "Resolve symmetric link conflict",
+              "description": "Pick how this duplicate symmetric link should be repaired.",
+              "resolutionLabel": "Repair strategy",
+              "resolutionDescription": "Choose which field should keep the two-way link behavior.",
+              "option": {
+                "keepCurrent": "Keep the current field as the two-way link",
+                "keepDuplicate": "Keep the duplicate field as the two-way link",
+                "convertDuplicate": "Convert the duplicate field to a one-way link"
+              }
+            }
+          }
         },
         "phase": {
           "check": "Check results",
@@ -993,8 +1054,12 @@
     "shareLink": "Share link",
     "linkHolderLabel": "The person who obtained the link",
     "linkHolderCanView": "Can view",
+    "linkHolderCanViewDesc": "Anyone with the link can view the data",
     "linkHolderCanEdit": "Can edit",
+    "linkHolderCanEditDesc": "Logged-in users can edit records in the table",
     "linkHolderCanCopyAndSave": "Can save as copy",
+    "linkHolderCanCopyAndSaveDesc": "Anyone with the link can save a copy to their space",
+    "editRequiresLogin": "Users must log in to edit records",
     "passwordProtection": "Password Protection",
     "enterPassword": "Enter password",
     "selectNodes": "Select Tables",
@@ -1612,6 +1677,13 @@
       "removeFromQueue": "Remove",
       "queueFull": "Queue is full (max 10 messages)",
       "messageQueued": "Message queued"
+    },
+    "effort": {
+      "title": "Select reasoning effort",
+      "low": "Low",
+      "medium": "Medium",
+      "high": "High",
+      "max": "Max"
     }
   },
   "upload": {
diff --git a/packages/common-i18n/src/locales/es/space.json b/packages/common-i18n/src/locales/es/space.json
index be03e40dbd..36d4bd53d9 100644
--- a/packages/common-i18n/src/locales/es/space.json
+++ b/packages/common-i18n/src/locales/es/space.json
@@ -140,8 +140,8 @@
     "empty": "No hay bases aún"
   },
   "publishBase": {
-    "title": "Publicar Base en la comunidad",
-    "description": "Publica la base con un clic, ¡la inspiración ya no es solitaria! Deja que más personas vean, usen y hagan Remix de tu creatividad, y construyan juntos un negocio más poderoso",
+    "title": "Publicar en el centro de plantillas",
+    "description": "¡Publica la base en el centro de plantillas con un clic! Deja que más personas vean, usen y hagan Remix de tu creatividad, y construyan juntos un negocio más poderoso",
     "infoTitle": "Información básica",
     "form": {
       "title": "Título",
@@ -164,7 +164,7 @@
     "unPublish": "Despublicar",
     "unPublishSuccess": "¡Base despublicada con éxito!",
     "unPublishConfirmTitle": "Confirmar despublicación",
-    "unPublishConfirmDescription": "¿Estás seguro de que deseas despublicar esta base? Ya no será visible en el centro de plantillas de la comunidad.",
+    "unPublishConfirmDescription": "¿Estás seguro de que deseas despublicar esta base? Ya no será visible en el centro de plantillas.",
     "usageCount": "Recuento de uso: ",
     "uploadCover": "Clic para subir imagen de portada",
     "changeCover": "Clic para cambiar portada",
diff --git a/packages/common-i18n/src/locales/es/table.json b/packages/common-i18n/src/locales/es/table.json
index 353265ae96..1e20efa56f 100644
--- a/packages/common-i18n/src/locales/es/table.json
+++ b/packages/common-i18n/src/locales/es/table.json
@@ -468,6 +468,18 @@
         "runCheck": "Iniciar comprobación",
         "recheck": "Volver a comprobar",
         "repair": "Reparar",
+        "repairWarnings": "Reparar solo advertencias",
+        "repairWarningsAndErrors": "Reparar advertencias y errores",
+        "repairRule": "Reparar regla",
+        "repairUnavailable": "Esta regla no se puede reparar automáticamente",
+        "manual": "Manual",
+        "manualRepairNotice": "Este problema requiere reparación manual",
+        "manualRepairNoticeWithCount": "{{count}} problemas requieren reparación manual. Usa la acción «Manual» a la derecha de cada regla para abrir el diálogo de reparación.",
+        "manualRepairDialogTitle": "Se requiere reparación manual",
+        "manualRepairDialogDescription": "Este problema no se puede reparar automáticamente. Revisa la guía de abajo y elige cómo corregirlo.",
+        "manualRepairDialogReason": "Por qué se requiere reparación manual",
+        "manualRepairDialogHint": "Este diálogo muestra por ahora las opciones de reparación que exige la regla. La ejecución real podrá añadirse más adelante sobre este contrato.",
+        "manualRepairDialogClose": "Cerrar",
         "checking": "Comprobando esquema...",
         "repairing": "Reparando esquema...",
         "streamError": "Falló el flujo de integridad del esquema.",
@@ -818,8 +830,12 @@
     "shareLink": "Enlace de compartición",
     "linkHolderLabel": "La persona que obtuvo el enlace",
     "linkHolderCanView": "Puede ver",
+    "linkHolderCanViewDesc": "Anyone with the link can view the data",
     "linkHolderCanEdit": "Puede editar",
+    "linkHolderCanEditDesc": "Logged-in users can edit records in the table",
     "linkHolderCanCopyAndSave": "Puede guardar como copia",
+    "linkHolderCanCopyAndSaveDesc": "Anyone with the link can save a copy to their space",
+    "editRequiresLogin": "Users must log in to edit records",
     "passwordProtection": "Protección con contraseña",
     "enterPassword": "Introducir contraseña",
     "selectNodes": "Seleccionar tablas",
diff --git a/packages/common-i18n/src/locales/fr/space.json b/packages/common-i18n/src/locales/fr/space.json
index b3c6094e85..042d030ead 100644
--- a/packages/common-i18n/src/locales/fr/space.json
+++ b/packages/common-i18n/src/locales/fr/space.json
@@ -140,8 +140,8 @@
     "empty": "Aucune base pour le moment"
   },
   "publishBase": {
-    "title": "Publier la Base dans la communauté",
-    "description": "Publiez votre base en un clic, l'inspiration n'est plus solitaire ! Laissez plus de gens voir, utiliser et remixer votre créativité, et construisez ensemble une entreprise plus puissante",
+    "title": "Publier dans le centre de modèles",
+    "description": "Publiez votre base dans le centre de modèles en un clic ! Laissez plus de gens voir, utiliser et remixer votre créativité, et construisez ensemble une entreprise plus puissante",
     "infoTitle": "Infos de base",
     "form": {
       "title": "Titre",
@@ -164,7 +164,7 @@
     "unPublish": "Dépublier",
     "unPublishSuccess": "Base dépubliée avec succès !",
     "unPublishConfirmTitle": "Confirmer la dépublication",
-    "unPublishConfirmDescription": "Êtes-vous sûr de vouloir dépublier cette base ? Elle ne sera plus visible dans le centre de modèles de la communauté.",
+    "unPublishConfirmDescription": "Êtes-vous sûr de vouloir dépublier cette base ? Elle ne sera plus visible dans le centre de modèles.",
     "usageCount": "Nombre d'utilisations : ",
     "uploadCover": "Cliquez pour télécharger l'image de couverture",
     "changeCover": "Cliquez pour changer la couverture",
diff --git a/packages/common-i18n/src/locales/fr/table.json b/packages/common-i18n/src/locales/fr/table.json
index a38c86d293..20cbfd418c 100644
--- a/packages/common-i18n/src/locales/fr/table.json
+++ b/packages/common-i18n/src/locales/fr/table.json
@@ -462,6 +462,18 @@
         "runCheck": "Lancer la vérification",
         "recheck": "Vérifier à nouveau",
         "repair": "Réparer",
+        "repairWarnings": "Réparer uniquement les avertissements",
+        "repairWarningsAndErrors": "Réparer les avertissements et les erreurs",
+        "repairRule": "Réparer la règle",
+        "repairUnavailable": "Cette règle ne peut pas être réparée automatiquement",
+        "manual": "Manuel",
+        "manualRepairNotice": "Ce problème nécessite une réparation manuelle",
+        "manualRepairNoticeWithCount": "{{count}} problèmes nécessitent une réparation manuelle. Utilisez l’action « Manuel » à droite de chaque règle pour ouvrir la fenêtre de réparation.",
+        "manualRepairDialogTitle": "Réparation manuelle requise",
+        "manualRepairDialogDescription": "Ce problème ne peut pas être réparé automatiquement. Consultez les indications ci-dessous et choisissez comment le corriger.",
+        "manualRepairDialogReason": "Pourquoi une réparation manuelle est nécessaire",
+        "manualRepairDialogHint": "Cette fenêtre présente pour l’instant les options de réparation exigées par la règle. L’exécution réelle pourra être ajoutée plus tard sur cette base.",
+        "manualRepairDialogClose": "Fermer",
         "checking": "Vérification du schéma...",
         "repairing": "Réparation du schéma...",
         "streamError": "Échec du flux d'intégrité du schéma.",
@@ -808,8 +820,12 @@
     "shareLink": "Lien de partage",
     "linkHolderLabel": "La personne qui a obtenu le lien",
     "linkHolderCanView": "Peut consulter",
+    "linkHolderCanViewDesc": "Anyone with the link can view the data",
     "linkHolderCanEdit": "Peut modifier",
+    "linkHolderCanEditDesc": "Logged-in users can edit records in the table",
     "linkHolderCanCopyAndSave": "Peut enregistrer comme copie",
+    "linkHolderCanCopyAndSaveDesc": "Anyone with the link can save a copy to their space",
+    "editRequiresLogin": "Users must log in to edit records",
     "passwordProtection": "Protection par mot de passe",
     "enterPassword": "Entrer le mot de passe",
     "selectNodes": "Sélectionner les tables",
diff --git a/packages/common-i18n/src/locales/it/space.json b/packages/common-i18n/src/locales/it/space.json
index e0d813994f..e87d40159f 100644
--- a/packages/common-i18n/src/locales/it/space.json
+++ b/packages/common-i18n/src/locales/it/space.json
@@ -140,8 +140,8 @@
     "empty": "Nessuna base presente"
   },
   "publishBase": {
-    "title": "Pubblica Base nella community",
-    "description": "Pubblica la base con un clic, l'ispirazione non è più sola! Lascia che più persone vedano, usino e facciano Remix della tua creatività, costruendo insieme un business più potente",
+    "title": "Pubblica nel centro modelli",
+    "description": "Pubblica la base nel centro modelli con un clic! Lascia che più persone vedano, usino e facciano Remix della tua creatività, costruendo insieme un business più potente",
     "infoTitle": "Informazioni di base",
     "form": {
       "title": "Titolo",
@@ -164,7 +164,7 @@
     "unPublish": "Annulla pubblicazione",
     "unPublishSuccess": "Pubblicazione base annullata con successo!",
     "unPublishConfirmTitle": "Conferma annullamento pubblicazione",
-    "unPublishConfirmDescription": "Sei sicuro di voler annullare la pubblicazione di questa base? Non sarà più visibile nel centro modelli della community.",
+    "unPublishConfirmDescription": "Sei sicuro di voler annullare la pubblicazione di questa base? Non sarà più visibile nel centro modelli.",
     "usageCount": "Conteggio utilizzo: ",
     "uploadCover": "Clicca per caricare l'immagine di copertina",
     "changeCover": "Clicca per cambiare copertina",
diff --git a/packages/common-i18n/src/locales/it/table.json b/packages/common-i18n/src/locales/it/table.json
index 34b8d481b5..20d2c73c4f 100644
--- a/packages/common-i18n/src/locales/it/table.json
+++ b/packages/common-i18n/src/locales/it/table.json
@@ -471,6 +471,18 @@
         "runCheck": "Avvia controllo",
         "recheck": "Controlla di nuovo",
         "repair": "Ripara",
+        "repairWarnings": "Ripara solo gli avvisi",
+        "repairWarningsAndErrors": "Ripara avvisi ed errori",
+        "repairRule": "Ripara regola",
+        "repairUnavailable": "Questa regola non può essere riparata automaticamente",
+        "manual": "Manuale",
+        "manualRepairNotice": "Questo problema richiede una riparazione manuale",
+        "manualRepairNoticeWithCount": "{{count}} problemi richiedono una riparazione manuale. Usa l'azione \"Manuale\" a destra di ogni regola per aprire la finestra di riparazione.",
+        "manualRepairDialogTitle": "Riparazione manuale richiesta",
+        "manualRepairDialogDescription": "Questo problema non può essere riparato automaticamente. Consulta le indicazioni qui sotto e scegli come correggerlo.",
+        "manualRepairDialogReason": "Perché è necessaria una riparazione manuale",
+        "manualRepairDialogHint": "Questa finestra mostra per ora le opzioni di riparazione richieste dalla regola. L'esecuzione effettiva potrà essere aggiunta in seguito su questa base.",
+        "manualRepairDialogClose": "Chiudi",
         "checking": "Controllo dello schema...",
         "repairing": "Riparazione dello schema...",
         "streamError": "Flusso di integrità dello schema non riuscito.",
@@ -829,8 +841,12 @@
     "shareLink": "Link di condivisione",
     "linkHolderLabel": "La persona che ha ottenuto il link",
     "linkHolderCanView": "Può visualizzare",
+    "linkHolderCanViewDesc": "Anyone with the link can view the data",
     "linkHolderCanEdit": "Può modificare",
+    "linkHolderCanEditDesc": "Logged-in users can edit records in the table",
     "linkHolderCanCopyAndSave": "Può salvare come copia",
+    "linkHolderCanCopyAndSaveDesc": "Anyone with the link can save a copy to their space",
+    "editRequiresLogin": "Users must log in to edit records",
     "passwordProtection": "Protezione con password",
     "enterPassword": "Inserisci password",
     "selectNodes": "Seleziona tabelle",
diff --git a/packages/common-i18n/src/locales/ja/space.json b/packages/common-i18n/src/locales/ja/space.json
index ea31a9177c..25536003a0 100644
--- a/packages/common-i18n/src/locales/ja/space.json
+++ b/packages/common-i18n/src/locales/ja/space.json
@@ -140,8 +140,8 @@
     "empty": "まだBaseがありません"
   },
   "publishBase": {
-    "title": "コミュニティにBaseを公開",
-    "description": "ワンクリックでBaseを公開、インスピレーションはもう孤独ではありません！あなたの創造性をより多くの人に見てもらい、利用してもらい、Remixしてもらい、共により強力なビジネスを築きましょう。",
+    "title": "テンプレートセンターに公開",
+    "description": "ワンクリックでテンプレートセンターにBaseを公開！あなたの創造性をより多くの人に見てもらい、利用してもらい、Remixしてもらい、共により強力なビジネスを築きましょう。",
     "infoTitle": "基本情報",
     "form": {
       "title": "タイトル",
@@ -164,7 +164,7 @@
     "unPublish": "公開停止",
     "unPublishSuccess": "Baseの公開を停止しました！",
     "unPublishConfirmTitle": "公開停止の確認",
-    "unPublishConfirmDescription": "本当にこのBaseの公開を停止しますか？コミュニティのテンプレートセンターに表示されなくなります。",
+    "unPublishConfirmDescription": "本当にこのBaseの公開を停止しますか？テンプレートセンターに表示されなくなります。",
     "usageCount": "使用回数: ",
     "uploadCover": "クリックしてカバー画像をアップロード",
     "changeCover": "クリックしてカバーを変更",
diff --git a/packages/common-i18n/src/locales/ja/table.json b/packages/common-i18n/src/locales/ja/table.json
index 5b9c2b1003..d11ea104d6 100644
--- a/packages/common-i18n/src/locales/ja/table.json
+++ b/packages/common-i18n/src/locales/ja/table.json
@@ -462,6 +462,18 @@
         "runCheck": "チェック開始",
         "recheck": "再チェック",
         "repair": "修復",
+        "repairWarnings": "警告のみ修復",
+        "repairWarningsAndErrors": "警告とエラーを修復",
+        "repairRule": "このルールを修復",
+        "repairUnavailable": "このルールは自動修復できません",
+        "manual": "手動",
+        "manualRepairNotice": "この問題は手動で修復する必要があります",
+        "manualRepairNoticeWithCount": "{{count}} 件の問題は手動修復が必要です。各ルールの右側にある「手動」操作から修復ダイアログを開いてください。",
+        "manualRepairDialogTitle": "手動修復が必要です",
+        "manualRepairDialogDescription": "この問題は自動修復できません。以下の案内を確認し、どのように修復するか選択してください。",
+        "manualRepairDialogReason": "手動修復が必要な理由",
+        "manualRepairDialogHint": "このダイアログでは、現在はルールが要求する修復オプションのみを案内します。実行処理は後からこの契約の上に追加できます。",
+        "manualRepairDialogClose": "閉じる",
         "checking": "スキーマをチェックしています...",
         "repairing": "スキーマを修復しています...",
         "streamError": "スキーマ整合性ストリームに失敗しました。",
@@ -807,8 +819,12 @@
     "shareLink": "共有リンク",
     "linkHolderLabel": "リンクを取得した人",
     "linkHolderCanView": "閲覧可能",
+    "linkHolderCanViewDesc": "Anyone with the link can view the data",
     "linkHolderCanEdit": "編集可能",
+    "linkHolderCanEditDesc": "Logged-in users can edit records in the table",
     "linkHolderCanCopyAndSave": "コピーとして保存可能",
+    "linkHolderCanCopyAndSaveDesc": "Anyone with the link can save a copy to their space",
+    "editRequiresLogin": "Users must log in to edit records",
     "passwordProtection": "パスワード保護",
     "enterPassword": "パスワードを入力",
     "selectNodes": "テーブルを選択",
diff --git a/packages/common-i18n/src/locales/ru/space.json b/packages/common-i18n/src/locales/ru/space.json
index 0c53ea352b..da43cb85a3 100644
--- a/packages/common-i18n/src/locales/ru/space.json
+++ b/packages/common-i18n/src/locales/ru/space.json
@@ -140,8 +140,8 @@
     "empty": "Баз пока нет"
   },
   "publishBase": {
-    "title": "Опубликовать базу в сообществе",
-    "description": "Публикация базы в один клик, вдохновение больше не одиноко! Пусть больше людей увидят, используют и ремикшируют ваше творчество, создавая более мощный бизнес вместе",
+    "title": "Опубликовать в центре шаблонов",
+    "description": "Публикация базы в центре шаблонов в один клик! Пусть больше людей увидят, используют и ремикшируют ваше творчество, создавая более мощный бизнес вместе",
     "infoTitle": "Основная информация",
     "form": {
       "title": "Название",
@@ -164,7 +164,7 @@
     "unPublish": "Снять с публикации",
     "unPublishSuccess": "База успешно снята с публикации!",
     "unPublishConfirmTitle": "Подтвердите снятие с публикации",
-    "unPublishConfirmDescription": "Вы уверены, что хотите снять эту базу с публикации? Она больше не будет видна в центре шаблонов сообщества.",
+    "unPublishConfirmDescription": "Вы уверены, что хотите снять эту базу с публикации? Она больше не будет видна в центре шаблонов.",
     "usageCount": "Количество использований: ",
     "uploadCover": "Нажмите, чтобы загрузить обложку",
     "changeCover": "Нажмите, чтобы изменить обложку",
diff --git a/packages/common-i18n/src/locales/ru/table.json b/packages/common-i18n/src/locales/ru/table.json
index 01692316fb..743cde5897 100644
--- a/packages/common-i18n/src/locales/ru/table.json
+++ b/packages/common-i18n/src/locales/ru/table.json
@@ -462,6 +462,18 @@
         "runCheck": "Запустить проверку",
         "recheck": "Проверить снова",
         "repair": "Исправить",
+        "repairWarnings": "Исправить только предупреждения",
+        "repairWarningsAndErrors": "Исправить предупреждения и ошибки",
+        "repairRule": "Исправить правило",
+        "repairUnavailable": "Это правило нельзя исправить автоматически",
+        "manual": "Вручную",
+        "manualRepairNotice": "Эта проблема требует ручного исправления",
+        "manualRepairNoticeWithCount": "{{count}} проблем требуют ручного исправления. Используйте действие «Вручную» справа от нужного правила, чтобы открыть диалог исправления.",
+        "manualRepairDialogTitle": "Требуется ручное исправление",
+        "manualRepairDialogDescription": "Эту проблему нельзя исправить автоматически. Ознакомьтесь с подсказками ниже и выберите способ исправления.",
+        "manualRepairDialogReason": "Почему требуется ручное исправление",
+        "manualRepairDialogHint": "Сейчас это окно только показывает параметры исправления, которые требует правило. Позже на основе этого контракта можно добавить фактическое выполнение.",
+        "manualRepairDialogClose": "Закрыть",
         "checking": "Проверка схемы...",
         "repairing": "Исправление схемы...",
         "streamError": "Ошибка потока целостности схемы.",
@@ -808,8 +820,12 @@
     "shareLink": "Ссылка для общего доступа",
     "linkHolderLabel": "Человек, получивший ссылку",
     "linkHolderCanView": "Может просматривать",
+    "linkHolderCanViewDesc": "Anyone with the link can view the data",
     "linkHolderCanEdit": "Может редактировать",
+    "linkHolderCanEditDesc": "Logged-in users can edit records in the table",
     "linkHolderCanCopyAndSave": "Может сохранить как копию",
+    "linkHolderCanCopyAndSaveDesc": "Anyone with the link can save a copy to their space",
+    "editRequiresLogin": "Users must log in to edit records",
     "passwordProtection": "Защита паролем",
     "enterPassword": "Введите пароль",
     "selectNodes": "Выбрать таблицы",
diff --git a/packages/common-i18n/src/locales/tr/space.json b/packages/common-i18n/src/locales/tr/space.json
index dad9c88c71..2c391a0b57 100644
--- a/packages/common-i18n/src/locales/tr/space.json
+++ b/packages/common-i18n/src/locales/tr/space.json
@@ -140,8 +140,8 @@
     "empty": "Henüz üs yok"
   },
   "publishBase": {
-    "title": "Üssü toplulukta yayınla",
-    "description": "Tek tıkla üs yayınlama, ilham artık yalnız değil! Yaratıcılığınızı daha fazla kişinin görmesine, kullanmasına ve Remix yapmasına izin verin ve birlikte daha güçlü bir iş kurun",
+    "title": "Şablon Merkezinde Yayınla",
+    "description": "Tek tıkla üssünüzü şablon merkezinde yayınlayın! Yaratıcılığınızı daha fazla kişinin görmesine, kullanmasına ve Remix yapmasına izin verin ve birlikte daha güçlü bir iş kurun",
     "infoTitle": "Temel bilgiler",
     "form": {
       "title": "Başlık",
@@ -164,7 +164,7 @@
     "unPublish": "Yayından kaldır",
     "unPublishSuccess": "Üs başarıyla yayından kaldırıldı!",
     "unPublishConfirmTitle": "Yayından kaldırmayı onayla",
-    "unPublishConfirmDescription": "Bu üssü yayından kaldırmak istediğinizden emin misiniz? Artık topluluk şablon merkezinde görünmeyecek.",
+    "unPublishConfirmDescription": "Bu üssü yayından kaldırmak istediğinizden emin misiniz? Artık şablon merkezinde görünmeyecek.",
     "usageCount": "Kullanım sayısı: ",
     "uploadCover": "Kapak resmi yüklemek için tıklayın",
     "changeCover": "Kapağı değiştirmek için tıklayın",
diff --git a/packages/common-i18n/src/locales/tr/table.json b/packages/common-i18n/src/locales/tr/table.json
index 944b9ae22b..3ad07b495c 100644
--- a/packages/common-i18n/src/locales/tr/table.json
+++ b/packages/common-i18n/src/locales/tr/table.json
@@ -470,6 +470,18 @@
         "runCheck": "Kontrolü başlat",
         "recheck": "Tekrar kontrol et",
         "repair": "Onar",
+        "repairWarnings": "Yalnızca uyarıları onar",
+        "repairWarningsAndErrors": "Uyarıları ve hataları onar",
+        "repairRule": "Kuralı onar",
+        "repairUnavailable": "Bu kural otomatik olarak onarılamaz",
+        "manual": "Manuel",
+        "manualRepairNotice": "Bu sorun manuel onarım gerektiriyor",
+        "manualRepairNoticeWithCount": "{{count}} sorun manuel onarım gerektiriyor. Onarım penceresini açmak için her kuralın sağındaki \"Manuel\" eylemini kullanın.",
+        "manualRepairDialogTitle": "Manuel onarım gerekli",
+        "manualRepairDialogDescription": "Bu sorun otomatik olarak onarılamaz. Aşağıdaki yönlendirmeyi inceleyin ve nasıl düzeltileceğini seçin.",
+        "manualRepairDialogReason": "Neden manuel onarım gerekiyor",
+        "manualRepairDialogHint": "Bu pencere şu anda yalnızca kuralın istediği onarım seçeneklerini gösterir. Gerçek çalıştırma daha sonra bu sözleşmenin üzerine eklenebilir.",
+        "manualRepairDialogClose": "Kapat",
         "checking": "Şema kontrol ediliyor...",
         "repairing": "Şema onarılıyor...",
         "streamError": "Şema bütünlüğü sonuçları akış halinde alınamadı.",
@@ -836,8 +848,12 @@
     "shareLink": "Paylaşım bağlantısı",
     "linkHolderLabel": "Bağlantıyı alan kişi",
     "linkHolderCanView": "Görüntüleyebilir",
+    "linkHolderCanViewDesc": "Anyone with the link can view the data",
     "linkHolderCanEdit": "Düzenleyebilir",
+    "linkHolderCanEditDesc": "Logged-in users can edit records in the table",
     "linkHolderCanCopyAndSave": "Kopya olarak kaydedebilir",
+    "linkHolderCanCopyAndSaveDesc": "Anyone with the link can save a copy to their space",
+    "editRequiresLogin": "Users must log in to edit records",
     "passwordProtection": "Şifre koruması",
     "enterPassword": "Şifre girin",
     "selectNodes": "Tabloları seç",
diff --git a/packages/common-i18n/src/locales/uk/space.json b/packages/common-i18n/src/locales/uk/space.json
index e350ac472c..5fd411afc4 100644
--- a/packages/common-i18n/src/locales/uk/space.json
+++ b/packages/common-i18n/src/locales/uk/space.json
@@ -140,8 +140,8 @@
     "empty": "Баз поки немає"
   },
   "publishBase": {
-    "title": "Опублікувати базу в спільноті",
-    "description": "Публікація бази в один клік, натхнення більше не самотнє! Дозвольте більшій кількості людей бачити, використовувати та реміксувати вашу творчість, будуючи разом потужніший бізнес",
+    "title": "Опублікувати в центрі шаблонів",
+    "description": "Публікація бази в центрі шаблонів в один клік! Дозвольте більшій кількості людей бачити, використовувати та реміксувати вашу творчість, будуючи разом потужніший бізнес",
     "infoTitle": "Основна інформація",
     "form": {
       "title": "Назва",
@@ -164,7 +164,7 @@
     "unPublish": "Зняти з публікації",
     "unPublishSuccess": "Базу успішно знято з публікації!",
     "unPublishConfirmTitle": "Підтвердити зняття з публікації",
-    "unPublishConfirmDescription": "Ви впевнені, що хочете зняти цю базу з публікації? Вона більше не буде видимою в центрі шаблонів спільноти.",
+    "unPublishConfirmDescription": "Ви впевнені, що хочете зняти цю базу з публікації? Вона більше не буде видимою в центрі шаблонів.",
     "usageCount": "Кількість використань: ",
     "uploadCover": "Натисніть, щоб завантажити обкладинку",
     "changeCover": "Натисніть, щоб змінити обкладинку",
diff --git a/packages/common-i18n/src/locales/uk/table.json b/packages/common-i18n/src/locales/uk/table.json
index f0478b4eb4..ccbc1dda3f 100644
--- a/packages/common-i18n/src/locales/uk/table.json
+++ b/packages/common-i18n/src/locales/uk/table.json
@@ -471,6 +471,18 @@
         "runCheck": "Запустити перевірку",
         "recheck": "Перевірити знову",
         "repair": "Виправити",
+        "repairWarnings": "Виправити лише попередження",
+        "repairWarningsAndErrors": "Виправити попередження і помилки",
+        "repairRule": "Виправити правило",
+        "repairUnavailable": "Це правило не можна виправити автоматично",
+        "manual": "Вручну",
+        "manualRepairNotice": "Ця проблема потребує ручного виправлення",
+        "manualRepairNoticeWithCount": "{{count}} проблем потребують ручного виправлення. Скористайтеся дією «Вручну» праворуч від кожного правила, щоб відкрити діалог виправлення.",
+        "manualRepairDialogTitle": "Потрібне ручне виправлення",
+        "manualRepairDialogDescription": "Цю проблему не можна виправити автоматично. Перегляньте підказки нижче та виберіть спосіб виправлення.",
+        "manualRepairDialogReason": "Чому потрібне ручне виправлення",
+        "manualRepairDialogHint": "Наразі це вікно лише показує параметри виправлення, які вимагає правило. Пізніше на основі цього контракту можна додати фактичне виконання.",
+        "manualRepairDialogClose": "Закрити",
         "checking": "Перевірка схеми...",
         "repairing": "Виправлення схеми...",
         "streamError": "Не вдалося отримати потокові результати перевірки цілісності схеми.",
@@ -827,8 +839,12 @@
     "shareLink": "Посилання для спільного доступу",
     "linkHolderLabel": "Особа, яка отримала посилання",
     "linkHolderCanView": "Може переглядати",
+    "linkHolderCanViewDesc": "Anyone with the link can view the data",
     "linkHolderCanEdit": "Може редагувати",
+    "linkHolderCanEditDesc": "Logged-in users can edit records in the table",
     "linkHolderCanCopyAndSave": "Може зберегти як копію",
+    "linkHolderCanCopyAndSaveDesc": "Anyone with the link can save a copy to their space",
+    "editRequiresLogin": "Users must log in to edit records",
     "passwordProtection": "Захист паролем",
     "enterPassword": "Введіть пароль",
     "selectNodes": "Вибрати таблиці",
diff --git a/packages/common-i18n/src/locales/zh/common.json b/packages/common-i18n/src/locales/zh/common.json
index fa30e82969..02dfef95e5 100644
--- a/packages/common-i18n/src/locales/zh/common.json
+++ b/packages/common-i18n/src/locales/zh/common.json
@@ -573,7 +573,16 @@
         "chatModelDescription": "要使用的对话模型，提示：工具调用是 Teable AI 功能所必需的",
         "chatModels": {
           "lg": "高级对话模型",
-          "lgDescription": "用于规划、编码和其他复杂任务场景。推荐使用 claude-sonnet-4.5"
+          "lgDescription": "用于规划、编码和其他复杂任务场景。推荐使用 claude-sonnet-4.5",
+          "md": "标准",
+          "mdDescription": "用于日常对话和一般任务",
+          "sm": "轻量",
+          "smDescription": "用于简单查询和快速响应",
+          "inheritHint": "与主模型相同 ({{model}})",
+          "modelTiers": "模型分级",
+          "modelTiersDescription": "可为标准和轻量任务指定不同的模型，未设置的挡位将使用上方的主模型。",
+          "allInheriting": "所有挡位使用主模型",
+          "customized": "已自定义 {{count}} 个"
         },
         "actions": {
           "title": "AI 能力",
diff --git a/packages/common-i18n/src/locales/zh/space.json b/packages/common-i18n/src/locales/zh/space.json
index 9288d6c63d..dd467f2eb5 100644
--- a/packages/common-i18n/src/locales/zh/space.json
+++ b/packages/common-i18n/src/locales/zh/space.json
@@ -146,8 +146,8 @@
     "noBasesFound": "未找到数据库"
   },
   "publishBase": {
-    "title": "发布数据库到社区",
-    "description": "一键发布数据库，灵感不再孤单！让更多人看到、使用和 Remix 你的创意，一起构建更强大的业务",
+    "title": "发布到模版中心",
+    "description": "一键发布数据库到模版中心！让更多人看到、使用和 Remix 你的创意，一起构建更强大的业务",
     "infoTitle": "基本信息",
     "form": {
       "title": "作品名称",
@@ -170,7 +170,7 @@
     "unPublish": "取消发布",
     "unPublishSuccess": "取消发布成功！",
     "unPublishConfirmTitle": "确认取消发布",
-    "unPublishConfirmDescription": "确定要取消发布此数据库吗？取消发布后，该数据库将不再在社区模板中心显示。",
+    "unPublishConfirmDescription": "确定要取消发布此数据库吗？取消发布后，该数据库将不再在模版中心显示。",
     "usageCount": "使用次数：",
     "uploadCover": "点击上传封面图片",
     "changeCover": "点击更换封面",
diff --git a/packages/common-i18n/src/locales/zh/table.json b/packages/common-i18n/src/locales/zh/table.json
index 2efc759569..fb19975c06 100644
--- a/packages/common-i18n/src/locales/zh/table.json
+++ b/packages/common-i18n/src/locales/zh/table.json
@@ -563,6 +563,20 @@
         "runCheck": "开始检查",
         "recheck": "重新检查",
         "repair": "修复",
+        "repairWarnings": "仅修复警告",
+        "repairWarningsAndErrors": "修复警告和错误",
+        "repairRule": "修复此规则",
+        "repairUnavailable": "该规则暂不支持自动修复",
+        "manual": "手动处理",
+        "manualRepairNotice": "这个问题需要手动修复",
+        "manualRepairNoticeWithCount": "有 {{count}} 个问题需要手动修复。请点击对应规则右侧的“手动处理”按钮打开修复弹窗。",
+        "manualRepairDialogTitle": "需要手动修复",
+        "manualRepairDialogDescription": "这个问题无法自动修复。请先阅读下面的说明，再选择合适的处理方式。",
+        "manualRepairDialogReason": "为什么需要手动修复",
+        "manualRepairDialogHint": "当前弹窗先承载规则要求的修复说明和配置项，后续可以在这个契约上继续补真正的执行动作。",
+        "manualRepairDialogClose": "关闭",
+        "manualRepairPreview": "手动修复配置",
+        "manualRepairPreviewTip": "当前仅展示规则要求用户提供的修复选项，尚未真正提交执行。",
         "checking": "正在检查 schema...",
         "repairing": "正在修复 schema...",
         "streamError": "Schema 完整性流式请求失败。",
@@ -591,7 +605,9 @@
           "checkCompleted": "Schema 检查已完成",
           "baseCheckCompleted": "Base Schema 检查已完成",
           "repairCompleted": "Schema 修复已完成",
-          "baseRepairCompleted": "Base Schema 修复已完成"
+          "baseRepairCompleted": "Base Schema 修复已完成",
+          "skippedStatusNotSelected": "已跳过：当前未选择修复这个级别的问题",
+          "skippedRepairUnavailable": "已跳过：当前状态下无法自动修复"
         },
         "rule": {
           "column": "物理列",
@@ -630,7 +646,52 @@
           "systemColumnNotNull": "系统列 \"{{columnName}}\" 应为 NOT NULL",
           "systemColumnUnique": "系统列 \"{{columnName}}\" 应有唯一索引",
           "systemColumnPrimaryKey": "系统列 \"{{columnName}}\" 应为 PRIMARY KEY",
-          "systemColumnDefault": "系统列 \"{{columnName}}\" 应有默认表达式"
+          "systemColumnDefault": "系统列 \"{{columnName}}\" 应有默认表达式",
+          "columnUniqueMissing": "字段「{{fieldName}}」应保持唯一",
+          "columnUniqueMissingDescription": "需要为字段「{{fieldName}}」补上唯一约束，避免继续写入重复值。",
+          "columnUniqueIndexMismatch": "字段「{{fieldName}}」缺少预期的唯一索引",
+          "columnUniqueIndexMismatchDescription": "需要把字段「{{fieldName}}」的索引重建为唯一索引，才能保证唯一性规则真正生效。",
+          "foreignKeyMissing": "字段「{{fieldName}}」缺少外键约束",
+          "foreignKeyMissingDescription": "需要恢复字段「{{fieldName}}」到表「{{targetTableName}}」的外键约束，保证关联数据的一致性。",
+          "foreignKeyTargetTableMissing": "字段「{{fieldName}}」关联的目标表不存在",
+          "foreignKeyTargetTableMissingDescription": "外键目标表「{{targetPhysicalTableName}}」不存在，因此当前无法自动补上字段「{{fieldName}}」的外键约束。",
+          "referenceMissing": "字段「{{fieldName}}」缺少引用映射",
+          "referenceMissingDescription": "需要恢复字段「{{fieldName}}」与依赖字段之间的引用元数据，才能正确触发 lookup / relation 的联动更新。",
+          "symmetricFieldTargetMissing": "字段「{{fieldName}}」对应的对称关联字段不存在",
+          "symmetricFieldWrongType": "字段「{{fieldName}}」对应的对称字段不是关联字段",
+          "symmetricFieldInvalidOptions": "字段「{{fieldName}}」对应的对称字段配置不合法",
+          "symmetricFieldMissingBackReference": "字段「{{fieldName}}」对应的对称字段没有回指当前字段",
+          "symmetricFieldWrongBackReference": "字段「{{fieldName}}」对应的对称字段指向了其他字段，而不是当前字段",
+          "symmetricFieldDuplicateUsage": "对称关联目标「{{symmetricFieldId}}」同时被字段「{{conflictFieldName}}」占用",
+          "symmetricFieldDuplicateUsageDescription": "同一个双向关联只能有一组唯一的对称字段。修复前需要先决定应该由哪个字段保留这组双向关系。"
+        },
+        "repairMeta": {
+          "reason": {
+            "alreadyValid": "该规则当前已经是正确状态",
+            "manualRule": "该规则需要人工决策后才能修复",
+            "statementGenerationFailed": "系统无法安全生成修复语句",
+            "noStatements": "该规则没有可执行的自动修复语句",
+            "symmetricFieldConflict": "这个对称关联冲突需要先手动选择修复策略",
+            "foreignKeyTargetTableMissing": "当前无法自动修复：关联目标表不存在"
+          },
+          "description": {
+            "symmetricFieldConflict": "有多个字段同时指向同一个对称关联目标。需要先决定哪一个字段应该保留双向关联关系，再继续修复。",
+            "foreignKeyTargetTableMissing": "请先确认关联目标表 {{targetPhysicalTableName}} 是否已被删除或重命名。恢复目标表后可重新执行修复；如果该关联已经不再需要，请修改或删除字段「{{fieldName}}」的关联配置。"
+          },
+          "manual": {
+            "apply": "执行手动修复",
+            "symmetricField": {
+              "title": "处理对称关联冲突",
+              "description": "请选择这组重复对称关联应如何修复。",
+              "resolutionLabel": "修复策略",
+              "resolutionDescription": "选择哪个字段应该保留双向关联行为。",
+              "option": {
+                "keepCurrent": "保留当前字段为双向关联",
+                "keepDuplicate": "保留冲突字段为双向关联",
+                "convertDuplicate": "将冲突字段改为单向关联"
+              }
+            }
+          }
         },
         "phase": {
           "check": "检查结果",
@@ -995,8 +1056,12 @@
     "shareLink": "分享链接",
     "linkHolderLabel": "获得链接的人",
     "linkHolderCanView": "可查看",
+    "linkHolderCanViewDesc": "获得链接的人可以查看数据",
     "linkHolderCanEdit": "可编辑",
+    "linkHolderCanEditDesc": "登录用户可以编辑表格中的记录",
     "linkHolderCanCopyAndSave": "可另存为副本",
+    "linkHolderCanCopyAndSaveDesc": "获得链接的人可以将数据保存到自己的空间",
+    "editRequiresLogin": "用户必须登录才能编辑记录",
     "passwordProtection": "密码保护",
     "enterPassword": "输入密码",
     "selectNodes": "选择数据表",
@@ -1613,6 +1678,13 @@
       "removeFromQueue": "移除",
       "queueFull": "队列已满（最多 10 条消息）",
       "messageQueued": "消息已加入队列"
+    },
+    "effort": {
+      "title": "选择推理功能",
+      "low": "低",
+      "medium": "中",
+      "high": "高",
+      "max": "超高"
     }
   },
   "upload": {
diff --git a/packages/db-main-prisma/prisma/postgres/migrations/20260323000000_add_base_share_allow_edit/migration.sql b/packages/db-main-prisma/prisma/postgres/migrations/20260323000000_add_base_share_allow_edit/migration.sql
new file mode 100644
index 0000000000..b088415e30
--- /dev/null
+++ b/packages/db-main-prisma/prisma/postgres/migrations/20260323000000_add_base_share_allow_edit/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "base_share" ADD COLUMN "allow_edit" BOOLEAN;
diff --git a/packages/db-main-prisma/prisma/postgres/schema.prisma b/packages/db-main-prisma/prisma/postgres/schema.prisma
index b83c69ea91..a2b078e08c 100644
--- a/packages/db-main-prisma/prisma/postgres/schema.prisma
+++ b/packages/db-main-prisma/prisma/postgres/schema.prisma
@@ -835,6 +835,7 @@ model BaseShare {
   nodeId           String    @unique @map("node_id")
   allowSave        Boolean?  @map("allow_save")
   allowCopy        Boolean?  @map("allow_copy")
+  allowEdit        Boolean?  @map("allow_edit")
   enabled          Boolean   @default(true)
   createdTime      DateTime  @default(now()) @map("created_time")
   createdBy        String    @map("created_by")
diff --git a/packages/db-main-prisma/prisma/sqlite/migrations/20260323000000_add_base_share_allow_edit/migration.sql b/packages/db-main-prisma/prisma/sqlite/migrations/20260323000000_add_base_share_allow_edit/migration.sql
new file mode 100644
index 0000000000..b088415e30
--- /dev/null
+++ b/packages/db-main-prisma/prisma/sqlite/migrations/20260323000000_add_base_share_allow_edit/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "base_share" ADD COLUMN "allow_edit" BOOLEAN;
diff --git a/packages/db-main-prisma/prisma/sqlite/schema.prisma b/packages/db-main-prisma/prisma/sqlite/schema.prisma
index 4890cd2a28..7196e1bc1e 100644
--- a/packages/db-main-prisma/prisma/sqlite/schema.prisma
+++ b/packages/db-main-prisma/prisma/sqlite/schema.prisma
@@ -835,6 +835,7 @@ model BaseShare {
   nodeId           String    @unique @map("node_id")
   allowSave        Boolean?  @map("allow_save")
   allowCopy        Boolean?  @map("allow_copy")
+  allowEdit        Boolean?  @map("allow_edit")
   enabled          Boolean   @default(true)
   createdTime      DateTime  @default(now()) @map("created_time")
   createdBy        String    @map("created_by")
diff --git a/packages/db-main-prisma/prisma/template.prisma b/packages/db-main-prisma/prisma/template.prisma
index 5f08fe270b..bf9002af1e 100644
--- a/packages/db-main-prisma/prisma/template.prisma
+++ b/packages/db-main-prisma/prisma/template.prisma
@@ -835,6 +835,7 @@ model BaseShare {
   nodeId           String    @unique @map("node_id")
   allowSave        Boolean?  @map("allow_save")
   allowCopy        Boolean?  @map("allow_copy")
+  allowEdit        Boolean?  @map("allow_edit")
   enabled          Boolean   @default(true)
   createdTime      DateTime  @default(now()) @map("created_time")
   createdBy        String    @map("created_by")
diff --git a/packages/openapi/src/base-share/get.ts b/packages/openapi/src/base-share/get.ts
index faa81c8485..dc9725fff9 100644
--- a/packages/openapi/src/base-share/get.ts
+++ b/packages/openapi/src/base-share/get.ts
@@ -51,6 +51,7 @@ export const baseShareByNodeIdVoSchema = z.object({
   nodeId: z.string(),
   allowSave: z.boolean().nullable(),
   allowCopy: z.boolean().nullable(),
+  allowEdit: z.boolean().nullable(),
   enabled: z.boolean(),
 });
 
diff --git a/packages/openapi/src/base-share/types.ts b/packages/openapi/src/base-share/types.ts
index d51b8557f6..7473dc762d 100644
--- a/packages/openapi/src/base-share/types.ts
+++ b/packages/openapi/src/base-share/types.ts
@@ -8,6 +8,7 @@ export const baseShareVoSchema = z.object({
   nodeId: z.string(),
   allowSave: z.boolean().nullable(),
   allowCopy: z.boolean().nullable(),
+  allowEdit: z.boolean().nullable(),
   enabled: z.boolean(),
 });
 
@@ -16,14 +17,14 @@ export type IBaseShareVo = z.infer<typeof baseShareVoSchema>;
 // Input schemas need actual password for create/update
 // nodeId is required; allowSave, allowCopy, password are optional
 export const createBaseShareRoSchema = baseShareVoSchema
-  .pick({ nodeId: true, allowSave: true, allowCopy: true })
-  .partial({ allowSave: true, allowCopy: true })
+  .pick({ nodeId: true, allowSave: true, allowCopy: true, allowEdit: true })
+  .partial({ allowSave: true, allowCopy: true, allowEdit: true })
   .extend({ password: sharePasswordSchema.nullable().optional() });
 
 export type ICreateBaseShareRo = z.infer<typeof createBaseShareRoSchema>;
 
 export const updateBaseShareRoSchema = baseShareVoSchema
-  .pick({ allowSave: true, allowCopy: true, enabled: true })
+  .pick({ allowSave: true, allowCopy: true, allowEdit: true, enabled: true })
   .extend({ password: sharePasswordSchema.nullable().optional() })
   .partial();
 
@@ -35,6 +36,7 @@ export const baseShareMetaSchema = baseShareVoSchema.pick({
   nodeId: true,
   allowSave: true,
   allowCopy: true,
+  allowEdit: true,
 });
 
 export type IBaseShareMeta = z.infer<typeof baseShareMetaSchema>;
diff --git a/packages/openapi/src/integrity/schema-v2.ts b/packages/openapi/src/integrity/schema-v2.ts
index 92e83ad32e..5e473b5354 100644
--- a/packages/openapi/src/integrity/schema-v2.ts
+++ b/packages/openapi/src/integrity/schema-v2.ts
@@ -24,10 +24,98 @@ export type IV2SchemaIntegrityDecisionVo = z.infer<typeof v2SchemaIntegrityDecis
 
 export const v2SchemaIntegrityDetailsSchema = z.object({
   missing: z.array(z.string()).optional(),
+  missingItems: z
+    .array(
+      z.object({
+        code: z.string().optional(),
+        message: z.object({
+          key: z.string().optional(),
+          values: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
+          fallback: z.string().optional(),
+        }),
+        description: z
+          .object({
+            key: z.string().optional(),
+            values: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
+            fallback: z.string().optional(),
+          })
+          .optional(),
+      })
+    )
+    .optional(),
   extra: z.array(z.string()).optional(),
+  extraItems: z
+    .array(
+      z.object({
+        code: z.string().optional(),
+        message: z.object({
+          key: z.string().optional(),
+          values: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
+          fallback: z.string().optional(),
+        }),
+        description: z
+          .object({
+            key: z.string().optional(),
+            values: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
+            fallback: z.string().optional(),
+          })
+          .optional(),
+      })
+    )
+    .optional(),
   statementCount: z.number().optional(),
 });
 
+export const v2SchemaIntegrityI18nMessageSchema = z.object({
+  key: z.string().optional(),
+  values: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
+  fallback: z.string().optional(),
+});
+export type IV2SchemaIntegrityI18nMessage = z.infer<typeof v2SchemaIntegrityI18nMessageSchema>;
+
+export const v2SchemaIntegrityManualRepairSchemaPropertySchema = z.object({
+  type: z.enum(['string', 'boolean']),
+  widget: z.enum(['select', 'text', 'textarea', 'checkbox']).optional(),
+  title: v2SchemaIntegrityI18nMessageSchema.optional(),
+  description: v2SchemaIntegrityI18nMessageSchema.optional(),
+  options: z
+    .array(
+      z.object({
+        value: z.string(),
+        label: v2SchemaIntegrityI18nMessageSchema,
+        description: v2SchemaIntegrityI18nMessageSchema.optional(),
+      })
+    )
+    .optional(),
+  defaultValue: z.union([z.string(), z.boolean()]).optional(),
+});
+export type IV2SchemaIntegrityManualRepairSchemaProperty = z.infer<
+  typeof v2SchemaIntegrityManualRepairSchemaPropertySchema
+>;
+
+export const v2SchemaIntegrityManualRepairSchemaSchema = z.object({
+  type: z.literal('object'),
+  title: v2SchemaIntegrityI18nMessageSchema.optional(),
+  description: v2SchemaIntegrityI18nMessageSchema.optional(),
+  submitLabel: v2SchemaIntegrityI18nMessageSchema.optional(),
+  required: z.array(z.string()).optional(),
+  properties: z.record(z.string(), v2SchemaIntegrityManualRepairSchemaPropertySchema),
+});
+export type IV2SchemaIntegrityManualRepairSchema = z.infer<
+  typeof v2SchemaIntegrityManualRepairSchemaSchema
+>;
+
+export const v2SchemaIntegrityRepairCapabilitySchema = z.object({
+  available: z.boolean(),
+  mode: z.enum(['auto', 'manual']),
+  reason: v2SchemaIntegrityI18nMessageSchema.optional(),
+  description: v2SchemaIntegrityI18nMessageSchema.optional(),
+  manualRepairSchema: v2SchemaIntegrityManualRepairSchemaSchema.optional(),
+});
+export type IV2SchemaIntegrityRepairCapability = z.infer<
+  typeof v2SchemaIntegrityRepairCapabilitySchema
+>;
+
 export const v2SchemaIntegrityFilterStatusSchema = z.enum(['success', 'error', 'warn', 'skipped']);
 
 export type IV2SchemaIntegrityFilterStatus = z.infer<typeof v2SchemaIntegrityFilterStatusSchema>;
@@ -59,6 +147,7 @@ export const v2SchemaIntegrityCheckResultSchema = z.object({
   status: v2SchemaIntegrityCheckStatusSchema,
   message: z.string().optional(),
   details: v2SchemaIntegrityDetailsSchema.optional(),
+  repair: v2SchemaIntegrityRepairCapabilitySchema.optional(),
   required: z.boolean(),
   timestamp: z.number(),
   dependencies: z.array(z.string()).optional(),
@@ -95,6 +184,7 @@ export const v2SchemaIntegrityRepairResultSchema = z.object({
   outcome: v2SchemaIntegrityRepairOutcomeSchema.optional(),
   message: z.string().optional(),
   details: v2SchemaIntegrityDetailsSchema.optional(),
+  repair: v2SchemaIntegrityRepairCapabilitySchema.optional(),
   required: z.boolean(),
   timestamp: z.number(),
   dependencies: z.array(z.string()).optional(),
@@ -109,6 +199,7 @@ export const v2SchemaIntegrityRepairRoSchema = z
     ruleId: z.string().optional(),
     dryRun: z.boolean().optional(),
     statuses: z.array(v2SchemaIntegrityFilterStatusSchema).optional(),
+    targetStatuses: z.array(z.enum(['warn', 'error'])).optional(),
   })
   .superRefine((value, ctx) => {
     if (value.ruleId && !value.fieldId) {
@@ -125,6 +216,7 @@ export type IV2SchemaIntegrityRepairRo = z.infer<typeof v2SchemaIntegrityRepairR
 export const v2BaseSchemaIntegrityRepairRoSchema = z.object({
   dryRun: z.boolean().optional(),
   statuses: z.array(v2SchemaIntegrityFilterStatusSchema).optional(),
+  targetStatuses: z.array(z.enum(['warn', 'error'])).optional(),
 });
 
 export type IV2BaseSchemaIntegrityRepairRo = z.infer<typeof v2BaseSchemaIntegrityRepairRoSchema>;
diff --git a/packages/sdk/src/components/cell-value/CellValue.tsx b/packages/sdk/src/components/cell-value/CellValue.tsx
index c29ec44ad7..60cd626930 100644
--- a/packages/sdk/src/components/cell-value/CellValue.tsx
+++ b/packages/sdk/src/components/cell-value/CellValue.tsx
@@ -63,7 +63,7 @@ const renderLongText: RenderFn = ({ value, className, plainLongText, options })
     const normalized = normalizeMarkdownValue(value);
     return <CellMarkdown value={normalized} className={className} />;
   }
-  const strValue = typeof value === 'string' ? value : '';
+  const strValue = normalizeMarkdownValue(value);
   if (plainLongText) {
     const stripped = isMarkdown ? stripMarkdown(strValue) : strValue;
     const plainTextValue = stripped ? normalizeLongTextPlainPreview(stripped) : stripped;
diff --git a/packages/sdk/src/components/editor/long-text/ExpandMarkdownEditor.tsx b/packages/sdk/src/components/editor/long-text/ExpandMarkdownEditor.tsx
index e3d3561f38..83d2a9f67f 100644
--- a/packages/sdk/src/components/editor/long-text/ExpandMarkdownEditor.tsx
+++ b/packages/sdk/src/components/editor/long-text/ExpandMarkdownEditor.tsx
@@ -485,7 +485,7 @@ export const ExpandMarkdownEditor = ({
           <LongText className="size-4 shrink-0" />
           <span className="truncate">{title}</span>
           <span className="ml-auto" />
-          {!readonly && (
+          {!readonly && field && (
             <div
               className="flex cursor-default items-center gap-1.5"
               onPointerDown={(e) => e.stopPropagation()}
diff --git a/packages/sdk/src/components/editor/long-text/milkdown-selection-toolbar-plugin.ts b/packages/sdk/src/components/editor/long-text/milkdown-selection-toolbar-plugin.ts
index 58b7619ec1..3ddd66f869 100644
--- a/packages/sdk/src/components/editor/long-text/milkdown-selection-toolbar-plugin.ts
+++ b/packages/sdk/src/components/editor/long-text/milkdown-selection-toolbar-plugin.ts
@@ -255,6 +255,7 @@ export function createSelectionToolbarPlugin(options?: SelectionToolbarOptions):
 
     // Link input events
     linkInput.addEventListener('keydown', (e) => {
+      e.stopPropagation();
       if (e.key === 'Enter') {
         e.preventDefault();
         applyLink(view);
diff --git a/packages/sdk/src/components/editor/long-text/milkdown-toolbar-plugin.ts b/packages/sdk/src/components/editor/long-text/milkdown-toolbar-plugin.ts
index f8c2c91d81..e9ce4bbe45 100644
--- a/packages/sdk/src/components/editor/long-text/milkdown-toolbar-plugin.ts
+++ b/packages/sdk/src/components/editor/long-text/milkdown-toolbar-plugin.ts
@@ -290,6 +290,7 @@ export function createFloatingToolbarPlugin(): Plugin {
   let panel: HTMLDivElement | null = null;
   let toggleButton: HTMLButtonElement | null = null;
   let scrollWrapEl: HTMLElement | null = null;
+  let mountEl: HTMLElement | null = null;
   let items: ToolbarItem[] = [];
   let buttons: HTMLButtonElement[] = [];
   let expanded = false;
@@ -408,22 +409,19 @@ export function createFloatingToolbarPlugin(): Plugin {
   }
 
   function updateToolbarPosition(view: EditorView) {
-    if (!tooltip) return;
+    if (!tooltip || !mountEl) return;
     const cursorRect = view.coordsAtPos(view.state.selection.from);
+    const mountRect = mountEl.getBoundingClientRect();
     const editorRect = scrollWrapEl?.getBoundingClientRect() ?? view.dom.getBoundingClientRect();
     const toolbarHeight = tooltip.offsetHeight || 30;
-    const toolbarWidth = tooltip.offsetWidth || 30;
-    const minTop = editorRect.top;
-    const maxTop = Math.max(minTop, editorRect.bottom - toolbarHeight);
-    const desiredTop = cursorRect.top;
-    const desiredLeft = editorRect.left - 34;
+
+    // All coordinates relative to mountEl
+    const minTop = editorRect.top - mountRect.top;
+    const maxTop = Math.max(minTop, editorRect.bottom - mountRect.top - toolbarHeight);
+    const desiredTop = cursorRect.top - mountRect.top;
     const top = Math.max(minTop, Math.min(maxTop, desiredTop));
-    const left = Math.max(
-      editorRect.left - 34,
-      Math.min(editorRect.right - toolbarWidth, desiredLeft)
-    );
+
     tooltip.style.top = `${top}px`;
-    tooltip.style.left = `${left}px`;
   }
 
   function isMultiLineSelection(view: EditorView): boolean {
@@ -503,7 +501,10 @@ export function createFloatingToolbarPlugin(): Plugin {
 
       const scrollWrap = editorView.dom.closest('.milkdown-editor-wrap');
       scrollWrapEl = scrollWrap instanceof HTMLElement ? scrollWrap : null;
-      document.body.appendChild(tooltip);
+
+      // Mount inside the editor's positioned parent so ancestor overflow clips naturally
+      mountEl = scrollWrapEl?.parentElement ?? editorView.dom.parentElement;
+      (mountEl ?? document.body).appendChild(tooltip);
 
       if (scrollWrapEl) {
         const onScroll = () => updateTooltip(editorView);
@@ -538,6 +539,7 @@ export function createFloatingToolbarPlugin(): Plugin {
           panel = null;
           toggleButton = null;
           scrollWrapEl = null;
+          mountEl = null;
           items = [];
           buttons = [];
           expanded = false;
diff --git a/packages/sdk/src/components/editor/long-text/milkdown.css b/packages/sdk/src/components/editor/long-text/milkdown.css
index 36848ddaf4..900afa222a 100644
--- a/packages/sdk/src/components/editor/long-text/milkdown.css
+++ b/packages/sdk/src/components/editor/long-text/milkdown.css
@@ -374,13 +374,12 @@
 
 /* Milkdown floating toolbar */
 .milkdown-floating-toolbar {
-  position: fixed;
+  position: absolute;
   left: -34px;
-  top: 8px;
-  z-index: 1200;
+  top: 0;
+  z-index: 1;
   pointer-events: auto;
   display: block;
-  transition: top 0.08s linear;
 }
 
 .milkdown-toolbar-toggle {
diff --git a/packages/sdk/src/components/grid-enhancements/editor/GridMarkdownEditor.tsx b/packages/sdk/src/components/grid-enhancements/editor/GridMarkdownEditor.tsx
index cfa3d0e350..612cf43483 100644
--- a/packages/sdk/src/components/grid-enhancements/editor/GridMarkdownEditor.tsx
+++ b/packages/sdk/src/components/grid-enhancements/editor/GridMarkdownEditor.tsx
@@ -55,6 +55,35 @@ const focusTextarea = (el: HTMLTextAreaElement, initialSearch: string | undefine
 const getReadonlyClassName = (canExpand: boolean, base: string) =>
   `pointer-events-auto ${canExpand ? 'max-h-64 overflow-auto' : 'overflow-hidden'} ${base}`;
 
+const useReadonlyScrollFix = (canScroll: boolean, cellKey: string) => {
+  const ref = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    if (ref.current) {
+      ref.current.scrollTop = 0;
+    }
+  }, [cellKey]);
+
+  useEffect(() => {
+    const el = ref.current;
+    if (!el || !canScroll) return;
+
+    const handleWheel = (e: WheelEvent) => {
+      if (el.scrollHeight <= el.clientHeight) return;
+      const atTop = el.scrollTop <= 0;
+      const atBottom = el.scrollTop + el.clientHeight >= el.scrollHeight - 1;
+      if ((e.deltaY > 0 && !atBottom) || (e.deltaY < 0 && !atTop)) {
+        e.stopPropagation();
+      }
+    };
+
+    el.addEventListener('wheel', handleWheel);
+    return () => el.removeEventListener('wheel', handleWheel);
+  }, [canScroll]);
+
+  return ref;
+};
+
 interface IGridMarkdownEditorProps extends IWrapperEditorProps, IEditorProps {
   readonlyExpandable?: boolean;
 }
@@ -82,6 +111,7 @@ const GridMarkdownEditorBase: ForwardRefRenderFunction<
   const isReadonly = Boolean(cell.readonly);
   const canExpandReadonly = Boolean(isReadonly && readonlyExpandable);
   const isMarkdown = isMarkdownShowAs(field.options);
+  const readonlyScrollRef = useReadonlyScrollFix(canExpandReadonly, record.id);
   const wrapperRef = useRef<HTMLDivElement>(null);
   const textareaRef = useRef<HTMLTextAreaElement>(null);
   const fallbackFocusRef = useRef<HTMLInputElement>(null);
@@ -224,6 +254,7 @@ const GridMarkdownEditorBase: ForwardRefRenderFunction<
       >
         {isMarkdown && (
           <div
+            ref={isMarkdown && canExpandReadonly ? readonlyScrollRef : undefined}
             className={
               isReadonly
                 ? getReadonlyClassName(canExpandReadonly, 'rounded-md px-2 pt-1 text-sm')
@@ -243,6 +274,7 @@ const GridMarkdownEditorBase: ForwardRefRenderFunction<
         )}
         {!isMarkdown && isReadonly && (
           <div
+            ref={!isMarkdown && canExpandReadonly ? readonlyScrollRef : undefined}
             className={getReadonlyClassName(
               canExpandReadonly,
               'rounded-md px-2 pt-1 text-[13px] leading-[1.4rem]'
diff --git a/packages/sdk/src/context/view/PersonalViewProvider.tsx b/packages/sdk/src/context/view/PersonalViewProvider.tsx
index add71d3ba5..a047c6d730 100644
--- a/packages/sdk/src/context/view/PersonalViewProvider.tsx
+++ b/packages/sdk/src/context/view/PersonalViewProvider.tsx
@@ -1,11 +1,10 @@
 import type { IFieldVo, ISort, ITableActionKey, IViewVo, StatisticsFunc } from '@teable/core';
 import type { IGetRecordsRo, IAggregationRo } from '@teable/openapi';
-import { useCallback, useContext, useMemo } from 'react';
+import { useCallback, useMemo } from 'react';
 import { useFields, useTableId, useTableListener, useView } from '../../hooks';
 import { validatePersonalViewProps } from '../../utils/personalView';
-import { ShareViewContext } from '../table';
 import { PersonalViewContext } from './PersonalViewContext';
-import { usePersonalViewStore } from './store';
+import { useResolvedPersonalViewStore } from './store';
 
 interface IPersonalViewProviderProps {
   children: React.ReactNode;
@@ -16,8 +15,7 @@ export const PersonalViewProvider = ({ children }: IPersonalViewProviderProps) =
   const tableId = useTableId();
   const visibleFields = useFields();
   const fields = useFields({ withHidden: true, withDenied: true });
-  const { shareId } = useContext(ShareViewContext) ?? {};
-  const { personalViewMap, setPersonalViewMap } = usePersonalViewStore();
+  const { personalViewMap, setPersonalViewMap } = useResolvedPersonalViewStore();
 
   const viewId = view?.id ?? '';
   const cachedView = personalViewMap?.[viewId];
@@ -25,7 +23,7 @@ export const PersonalViewProvider = ({ children }: IPersonalViewProviderProps) =
   const visibleFieldIds = visibleFields.map(({ id }) => id);
 
   const { personalViewCommonQuery, personalViewAggregationQuery } = useMemo(() => {
-    if (!cachedView || shareId) {
+    if (!cachedView) {
       return { personalViewCommonQuery: undefined, personalViewAggregationQuery: undefined };
     }
 
@@ -64,7 +62,7 @@ export const PersonalViewProvider = ({ children }: IPersonalViewProviderProps) =
       personalViewCommonQuery: commonQuery,
       personalViewAggregationQuery: aggregationQuery,
     };
-  }, [cachedView, shareId, visibleFieldIds]);
+  }, [cachedView, visibleFieldIds]);
 
   const updatePersonalView = useCallback(
     (actionKey: string, payload?: Record<string, unknown>) => {
diff --git a/packages/sdk/src/context/view/PersonalViewProxy.tsx b/packages/sdk/src/context/view/PersonalViewProxy.tsx
index 68365bb168..fa95a0b89b 100644
--- a/packages/sdk/src/context/view/PersonalViewProxy.tsx
+++ b/packages/sdk/src/context/view/PersonalViewProxy.tsx
@@ -5,7 +5,7 @@ import { generateLocalId, useGridCollapsedGroupStore } from '../../components';
 import { useTableId, useViews } from '../../hooks';
 import type { IViewInstance } from '../../model/view/factory';
 import { createViewInstance } from '../../model/view/factory';
-import { usePersonalViewStore } from './store';
+import { useResolvedPersonalViewStore } from './store';
 import { ViewContext } from './ViewContext';
 
 interface IPersonalViewProxyProps {
@@ -45,7 +45,7 @@ export const PersonalViewProxy = (props: IPersonalViewProxyProps) => {
   const views = useViews();
   const tableId = useTableId();
   const { setCollapsedGroupMap } = useGridCollapsedGroupStore();
-  const { personalViewMap, isPersonalView, setPersonalViewMap } = usePersonalViewStore();
+  const { personalViewMap, isPersonalView, setPersonalViewMap } = useResolvedPersonalViewStore();
 
   const generateProxyView = useCallback(
     (view: IViewInstance, serverData?: IViewVo[]) => {
diff --git a/packages/sdk/src/context/view/index.ts b/packages/sdk/src/context/view/index.ts
index 8b422aa1f3..6bfa38b7d5 100644
--- a/packages/sdk/src/context/view/index.ts
+++ b/packages/sdk/src/context/view/index.ts
@@ -2,3 +2,4 @@ export * from './ViewContext';
 export * from './ViewProvider';
 export * from './PersonalViewProxy';
 export * from './PersonalViewProvider';
+export { ShareSessionViewStoreProvider } from './store';
diff --git a/packages/sdk/src/context/view/store/ShareSessionViewStore.tsx b/packages/sdk/src/context/view/store/ShareSessionViewStore.tsx
new file mode 100644
index 0000000000..5de55fca13
--- /dev/null
+++ b/packages/sdk/src/context/view/store/ShareSessionViewStore.tsx
@@ -0,0 +1,63 @@
+import React, { createContext, useCallback, useContext, useRef, useState } from 'react';
+
+export interface IPersonalViewStoreApi {
+  personalViewMap: Record<string, Record<string, unknown>>;
+  isPersonalView: (viewId: string) => boolean;
+  setPersonalViewMap: (
+    viewId: string,
+    updater: (prev: Record<string, unknown>) => Record<string, unknown>
+  ) => void;
+  removePersonalView: (viewId: string) => void;
+}
+
+const ShareSessionViewStoreContext = createContext<IPersonalViewStoreApi | null>(null);
+
+export const useShareSessionViewStore = () => useContext(ShareSessionViewStoreContext);
+
+export const ShareSessionViewStoreProvider = ({
+  children,
+  initialViewMap,
+}: {
+  children: React.ReactNode;
+  initialViewMap?: Record<string, Record<string, unknown>>;
+}) => {
+  const initialRef = useRef(initialViewMap);
+  const [personalViewMap, setMap] = useState<Record<string, Record<string, unknown>>>(
+    () => initialRef.current ?? {}
+  );
+
+  const isPersonalView = useCallback(
+    (viewId: string) => Boolean(personalViewMap[viewId]),
+    [personalViewMap]
+  );
+
+  const setPersonalViewMap = useCallback(
+    (viewId: string, updater: (prev: Record<string, unknown>) => Record<string, unknown>) => {
+      setMap((prev) => ({
+        ...prev,
+        [viewId]: updater(prev[viewId] ?? {}),
+      }));
+    },
+    []
+  );
+
+  const removePersonalView = useCallback((viewId: string) => {
+    setMap((prev) => {
+      const { [viewId]: _, ...rest } = prev;
+      return rest;
+    });
+  }, []);
+
+  const value: IPersonalViewStoreApi = {
+    personalViewMap,
+    isPersonalView,
+    setPersonalViewMap,
+    removePersonalView,
+  };
+
+  return (
+    <ShareSessionViewStoreContext.Provider value={value}>
+      {children}
+    </ShareSessionViewStoreContext.Provider>
+  );
+};
diff --git a/packages/sdk/src/context/view/store/index.ts b/packages/sdk/src/context/view/store/index.ts
index 531603f6ad..9f309395ed 100644
--- a/packages/sdk/src/context/view/store/index.ts
+++ b/packages/sdk/src/context/view/store/index.ts
@@ -1 +1,2 @@
 export * from './usePersonalViewStore';
+export * from './ShareSessionViewStore';
diff --git a/packages/sdk/src/context/view/store/usePersonalViewStore.ts b/packages/sdk/src/context/view/store/usePersonalViewStore.ts
index d9034ad086..ca3f6f2c64 100644
--- a/packages/sdk/src/context/view/store/usePersonalViewStore.ts
+++ b/packages/sdk/src/context/view/store/usePersonalViewStore.ts
@@ -1,6 +1,8 @@
 import { create } from 'zustand';
 import { persist } from 'zustand/middleware';
 import { LocalStorageKeys } from '../../../config';
+import type { IPersonalViewStoreApi } from './ShareSessionViewStore';
+import { useShareSessionViewStore } from './ShareSessionViewStore';
 
 interface IPersonalViewState {
   personalViewMap: Record<string, Record<string, unknown>>;
@@ -12,6 +14,16 @@ interface IPersonalViewState {
   removePersonalView: (viewId: string) => void;
 }
 
+/**
+ * Checks for a session-only override (share mode) first,
+ * falls back to the Zustand localStorage store.
+ */
+export const useResolvedPersonalViewStore = (): IPersonalViewStoreApi => {
+  const sessionStore = useShareSessionViewStore();
+  const zustandStore = usePersonalViewStore();
+  return sessionStore ?? zustandStore;
+};
+
 export const usePersonalViewStore = create<IPersonalViewState>()(
   persist(
     (set, get) => ({
diff --git a/packages/sdk/src/hooks/use-personal-view.ts b/packages/sdk/src/hooks/use-personal-view.ts
index c32c32bd11..af66e43759 100644
--- a/packages/sdk/src/hooks/use-personal-view.ts
+++ b/packages/sdk/src/hooks/use-personal-view.ts
@@ -1,14 +1,14 @@
 import { useCallback, useContext } from 'react';
 import { type IProxyPersonalView } from '../context';
 import { PersonalViewContext } from '../context/view/PersonalViewContext';
-import { usePersonalViewStore } from '../context/view/store';
+import { useResolvedPersonalViewStore } from '../context/view/store';
 import { generatePersonalViewProps } from '../utils/personalView';
 import { useView } from './use-view';
 
 export const usePersonalView = () => {
   const { isPersonalView, personalViewMap, personalViewCommonQuery, personalViewAggregationQuery } =
     useContext(PersonalViewContext);
-  const { removePersonalView, setPersonalViewMap } = usePersonalViewStore();
+  const { removePersonalView, setPersonalViewMap } = useResolvedPersonalViewStore();
 
   const view = useView();
   const viewId = view?.id ?? '';
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/ComputedFieldSelectExpressionVisitor.systemFields.spec.ts b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/ComputedFieldSelectExpressionVisitor.systemFields.spec.ts
new file mode 100644
index 0000000000..ccc271748a
--- /dev/null
+++ b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/ComputedFieldSelectExpressionVisitor.systemFields.spec.ts
@@ -0,0 +1,245 @@
+import {
+  BaseId,
+  DbFieldName,
+  FieldId,
+  FieldName,
+  LinkFieldConfig,
+  LookupField,
+  LookupOptions,
+  Table,
+  TableId,
+  TableName,
+} from '@teable/v2-core';
+import { Pg16TypeValidationStrategy } from '@teable/v2-formula-sql-pg';
+import {
+  DummyDriver,
+  Kysely,
+  PostgresAdapter,
+  PostgresIntrospector,
+  PostgresQueryCompiler,
+} from 'kysely';
+import { describe, expect, it } from 'vitest';
+
+import type { DynamicDB } from '../ITableRecordQueryBuilder';
+import { ComputedTableRecordQueryBuilder } from './ComputedTableRecordQueryBuilder';
+
+const BASE_ID = `bse${'a'.repeat(16)}`;
+const TABLE_ID = `tbl${'b'.repeat(16)}`;
+const TEXT_FIELD_ID = `fld${'c'.repeat(16)}`;
+const AUTO_NUMBER_FIELD_ID = `fld${'d'.repeat(16)}`;
+const CREATED_TIME_FIELD_ID = `fld${'e'.repeat(16)}`;
+const LAST_MODIFIED_TIME_FIELD_ID = `fld${'f'.repeat(16)}`;
+
+const typeValidationStrategy = new Pg16TypeValidationStrategy();
+
+const createTestDb = () =>
+  new Kysely<DynamicDB>({
+    dialect: {
+      createAdapter: () => new PostgresAdapter(),
+      createDriver: () => new DummyDriver(),
+      createIntrospector: (db) => new PostgresIntrospector(db),
+      createQueryCompiler: () => new PostgresQueryCompiler(),
+    },
+  });
+
+const compileQuery = (db: Kysely<DynamicDB>, builder: ComputedTableRecordQueryBuilder) => {
+  const result = builder.build();
+  if (result.isErr()) throw new Error(result.error.message);
+  return result.value.compile().sql;
+};
+
+const createTableWithSystemFields = () => {
+  const baseId = BaseId.create(BASE_ID)._unsafeUnwrap();
+  const tableId = TableId.create(TABLE_ID)._unsafeUnwrap();
+  const textFieldId = FieldId.create(TEXT_FIELD_ID)._unsafeUnwrap();
+  const autoNumberFieldId = FieldId.create(AUTO_NUMBER_FIELD_ID)._unsafeUnwrap();
+  const createdTimeFieldId = FieldId.create(CREATED_TIME_FIELD_ID)._unsafeUnwrap();
+  const lastModifiedTimeFieldId = FieldId.create(LAST_MODIFIED_TIME_FIELD_ID)._unsafeUnwrap();
+
+  const builder = Table.builder()
+    .withId(tableId)
+    .withBaseId(baseId)
+    .withName(TableName.create('SystemFieldsTable')._unsafeUnwrap());
+
+  builder
+    .field()
+    .singleLineText()
+    .withId(textFieldId)
+    .withName(FieldName.create('Name')._unsafeUnwrap())
+    .primary()
+    .done();
+  builder
+    .field()
+    .autoNumber()
+    .withId(autoNumberFieldId)
+    .withName(FieldName.create('Auto Number')._unsafeUnwrap())
+    .done();
+  builder
+    .field()
+    .createdTime()
+    .withId(createdTimeFieldId)
+    .withName(FieldName.create('Created Time')._unsafeUnwrap())
+    .done();
+  builder
+    .field()
+    .lastModifiedTime()
+    .withId(lastModifiedTimeFieldId)
+    .withName(FieldName.create('Last Modified Time')._unsafeUnwrap())
+    .done();
+  builder.view().defaultGrid().done();
+
+  const table = builder.build()._unsafeUnwrap();
+  const [textField] = table.getFields();
+  textField.setDbFieldName(DbFieldName.rehydrate('col_name')._unsafeUnwrap())._unsafeUnwrap();
+  table
+    .getField((field) => field.id().equals(autoNumberFieldId))
+    ._unsafeUnwrap()
+    .setDbFieldName(DbFieldName.rehydrate('col_auto_number')._unsafeUnwrap())
+    ._unsafeUnwrap();
+  table
+    .getField((field) => field.id().equals(createdTimeFieldId))
+    ._unsafeUnwrap()
+    .setDbFieldName(DbFieldName.rehydrate('col_created_time')._unsafeUnwrap())
+    ._unsafeUnwrap();
+  table
+    .getField((field) => field.id().equals(lastModifiedTimeFieldId))
+    ._unsafeUnwrap()
+    .setDbFieldName(DbFieldName.rehydrate('col_last_modified_time')._unsafeUnwrap())
+    ._unsafeUnwrap();
+
+  return table;
+};
+
+describe('ComputedTableRecordQueryBuilder with system scalar fields', () => {
+  it('reads autoNumber and time fields from system columns', () => {
+    const db = createTestDb();
+    const table = createTableWithSystemFields();
+
+    const sql = compileQuery(
+      db,
+      new ComputedTableRecordQueryBuilder(db, { typeValidationStrategy }).from(table)
+    );
+
+    expect(sql).toContain('"t"."__auto_number" as "col_auto_number"');
+    expect(sql).toContain('"t"."__created_time" as "col_created_time"');
+    expect(sql).toContain('"t"."__last_modified_time" as "col_last_modified_time"');
+  });
+
+  it('reads lookup autoNumber from the foreign __auto_number column', () => {
+    const db = createTestDb();
+    const baseId = BaseId.create(BASE_ID)._unsafeUnwrap();
+    const hostTableId = TableId.create(`tbl${'h'.repeat(16)}`)._unsafeUnwrap();
+    const foreignTableId = TableId.create(`tbl${'i'.repeat(16)}`)._unsafeUnwrap();
+    const foreignTitleFieldId = FieldId.create(`fld${'g'.repeat(16)}`)._unsafeUnwrap();
+    const foreignAutoNumberFieldId = FieldId.create(`fld${'h'.repeat(16)}`)._unsafeUnwrap();
+    const hostTitleFieldId = FieldId.create(`fld${'i'.repeat(16)}`)._unsafeUnwrap();
+    const hostLinkFieldId = FieldId.create(`fld${'j'.repeat(16)}`)._unsafeUnwrap();
+    const hostLookupFieldId = FieldId.create(`fld${'k'.repeat(16)}`)._unsafeUnwrap();
+
+    const foreignBuilder = Table.builder()
+      .withId(foreignTableId)
+      .withBaseId(baseId)
+      .withName(TableName.create('LookupSource')._unsafeUnwrap());
+    foreignBuilder
+      .field()
+      .singleLineText()
+      .withId(foreignTitleFieldId)
+      .withName(FieldName.create('Name')._unsafeUnwrap())
+      .primary()
+      .done();
+    foreignBuilder
+      .field()
+      .autoNumber()
+      .withId(foreignAutoNumberFieldId)
+      .withName(FieldName.create('Auto Number')._unsafeUnwrap())
+      .done();
+    foreignBuilder.view().defaultGrid().done();
+
+    const foreignTable = foreignBuilder.build()._unsafeUnwrap();
+    foreignTable
+      .getField((field) => field.id().equals(foreignTitleFieldId))
+      ._unsafeUnwrap()
+      .setDbFieldName(DbFieldName.rehydrate('col_source_name')._unsafeUnwrap())
+      ._unsafeUnwrap();
+    foreignTable
+      .getField((field) => field.id().equals(foreignAutoNumberFieldId))
+      ._unsafeUnwrap()
+      .setDbFieldName(DbFieldName.rehydrate('col_source_auto_number')._unsafeUnwrap())
+      ._unsafeUnwrap();
+
+    const linkConfig = LinkFieldConfig.create({
+      relationship: 'manyOne',
+      foreignTableId: foreignTableId.toString(),
+      lookupFieldId: foreignTitleFieldId.toString(),
+      symmetricFieldId: `fld${'l'.repeat(16)}`,
+    })._unsafeUnwrap();
+    const lookupOptions = LookupOptions.create({
+      linkFieldId: hostLinkFieldId.toString(),
+      foreignTableId: foreignTableId.toString(),
+      lookupFieldId: foreignAutoNumberFieldId.toString(),
+    })._unsafeUnwrap();
+
+    const hostBuilder = Table.builder()
+      .withId(hostTableId)
+      .withBaseId(baseId)
+      .withName(TableName.create('LookupHost')._unsafeUnwrap());
+    hostBuilder
+      .field()
+      .singleLineText()
+      .withId(hostTitleFieldId)
+      .withName(FieldName.create('Name')._unsafeUnwrap())
+      .primary()
+      .done();
+    hostBuilder
+      .field()
+      .link()
+      .withId(hostLinkFieldId)
+      .withName(FieldName.create('Source')._unsafeUnwrap())
+      .withConfig(linkConfig)
+      .done();
+    hostBuilder.view().defaultGrid().done();
+
+    const baseHostTable = hostBuilder.build()._unsafeUnwrap();
+    const hostLookupField = LookupField.create({
+      id: hostLookupFieldId,
+      name: FieldName.create('Lookup Auto Number')._unsafeUnwrap(),
+      lookupOptions,
+      innerField: foreignTable
+        .getField((field) => field.id().equals(foreignAutoNumberFieldId))
+        ._unsafeUnwrap(),
+      isMultipleCellValue: true,
+    })._unsafeUnwrap();
+    const hostTable = baseHostTable
+      .addField(hostLookupField, {
+        foreignTables: [foreignTable],
+      })
+      ._unsafeUnwrap();
+    hostTable
+      .getField((field) => field.id().equals(hostTitleFieldId))
+      ._unsafeUnwrap()
+      .setDbFieldName(DbFieldName.rehydrate('col_host_name')._unsafeUnwrap())
+      ._unsafeUnwrap();
+    hostTable
+      .getField((field) => field.id().equals(hostLinkFieldId))
+      ._unsafeUnwrap()
+      .setDbFieldName(DbFieldName.rehydrate('col_host_link')._unsafeUnwrap())
+      ._unsafeUnwrap();
+    hostTable
+      .getField((field) => field.id().equals(hostLookupFieldId))
+      ._unsafeUnwrap()
+      .setDbFieldName(DbFieldName.rehydrate('col_lookup_auto_number')._unsafeUnwrap())
+      ._unsafeUnwrap();
+
+    const sql = compileQuery(
+      db,
+      new ComputedTableRecordQueryBuilder(db, {
+        typeValidationStrategy,
+        foreignTables: new Map([[foreignTable.id().toString(), foreignTable]]),
+      }).from(hostTable)
+    );
+
+    expect(sql).toContain('"f"."__auto_number"');
+    expect(sql).toContain('as "col_lookup_auto_number"');
+    expect(sql).not.toContain('"f"."col_source_auto_number"');
+  });
+});
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/ComputedFieldSelectExpressionVisitor.ts b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/ComputedFieldSelectExpressionVisitor.ts
index a0a6fa1144..f5a72ac6a4 100644
--- a/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/ComputedFieldSelectExpressionVisitor.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/ComputedFieldSelectExpressionVisitor.ts
@@ -249,6 +249,15 @@ export class ComputedFieldSelectExpressionVisitor
     );
   }
 
+  private systemScalarColumn(
+    field: Field,
+    systemColumn: string
+  ): Result<AliasedRawBuilder<unknown, string>, DomainError> {
+    return this.getColAlias(field).map((colAlias) =>
+      sql`${sql.ref(`${this.tableAlias}.${systemColumn}`)}`.as(colAlias)
+    );
+  }
+
   private userColumn(field: Field): Result<AliasedRawBuilder<unknown, string>, DomainError> {
     return this.getColAlias(field).map((colAlias) => {
       const colRef = sql.ref(`${this.tableAlias}.${colAlias}`);
@@ -374,19 +383,21 @@ export class ComputedFieldSelectExpressionVisitor
   visitCreatedTimeField(
     field: CreatedTimeField
   ): Result<AliasedRawBuilder<unknown, string>, DomainError> {
-    return this.simpleColumn(field);
+    return this.systemScalarColumn(field, '__created_time');
   }
 
   visitLastModifiedTimeField(
     field: LastModifiedTimeField
   ): Result<AliasedRawBuilder<unknown, string>, DomainError> {
-    return this.simpleColumn(field);
+    return field.isTrackAll()
+      ? this.systemScalarColumn(field, '__last_modified_time')
+      : this.simpleColumn(field);
   }
 
   visitAutoNumberField(
     field: AutoNumberField
   ): Result<AliasedRawBuilder<unknown, string>, DomainError> {
-    return this.simpleColumn(field);
+    return this.systemScalarColumn(field, '__auto_number');
   }
 
   visitCreatedByField(
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/ComputedTableRecordQueryBuilder.spec.ts b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/ComputedTableRecordQueryBuilder.spec.ts
index a2b35e18b7..cc0a24b7e6 100644
--- a/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/ComputedTableRecordQueryBuilder.spec.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/ComputedTableRecordQueryBuilder.spec.ts
@@ -186,7 +186,7 @@ describe('ComputedTableRecordQueryBuilder', () => {
 
       expect(sql).toMatchInlineSnapshot(
         `
-        "select "t"."__id" as "__id", "t"."__version" as "__version", "t"."col_single_line_text" as "col_single_line_text", "t"."col_long_text" as "col_long_text", "t"."col_number" as "col_number", "t"."col_rating" as "col_rating", "t"."col_single_select" as "col_single_select", "t"."col_multiple_select" as "col_multiple_select", "t"."col_checkbox" as "col_checkbox", "t"."col_attachment" as "col_attachment", "t"."col_date" as "col_date", "t"."col_created_time" as "col_created_time", "t"."col_last_modified_time" as "col_last_modified_time", 
+        "select "t"."__id" as "__id", "t"."__version" as "__version", "t"."col_single_line_text" as "col_single_line_text", "t"."col_long_text" as "col_long_text", "t"."col_number" as "col_number", "t"."col_rating" as "col_rating", "t"."col_single_select" as "col_single_select", "t"."col_multiple_select" as "col_multiple_select", "t"."col_checkbox" as "col_checkbox", "t"."col_attachment" as "col_attachment", "t"."col_date" as "col_date", "t"."__created_time" as "col_created_time", "t"."__last_modified_time" as "col_last_modified_time", 
                 case
                   when "t"."col_user" is null then null
                   when jsonb_typeof(to_jsonb("t"."col_user")) = 'array' then (
@@ -238,7 +238,7 @@ describe('ComputedTableRecordQueryBuilder', () => {
                 )
                 from public.users u
                 where u.id = "t"."__last_modified_by"
-              ) as "col_last_modified_by", "t"."col_auto_number" as "col_auto_number", "t"."col_button" as "col_button" from "bseaaaaaaaaaaaaaaaa"."tblmmmmmmmmmmmmmmmm" as "t""
+              ) as "col_last_modified_by", "t"."__auto_number" as "col_auto_number", "t"."col_button" as "col_button" from "bseaaaaaaaaaaaaaaaa"."tblmmmmmmmmmmmmmmmm" as "t""
       `
       );
       expect(parameters).toEqual(Array(4).fill('/api/attachments/read/public/avatar/'));
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/ComputedTableRecordQueryBuilder.ts b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/ComputedTableRecordQueryBuilder.ts
index ff15a62412..9f21e0f19d 100644
--- a/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/ComputedTableRecordQueryBuilder.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/ComputedTableRecordQueryBuilder.ts
@@ -1108,6 +1108,67 @@ export class ComputedTableRecordQueryBuilder implements ITableRecordQueryBuilder
     return `"${escapeIdentifier(tableAlias)}"."${escapeIdentifier(columnName)}"`;
   }
 
+  private buildSystemUserJsonExpr(tableAlias: string, systemColumn: string): RawBuilder<unknown> {
+    const systemColRef = sql.ref(`${tableAlias}.${systemColumn}`);
+    const avatarPrefix = '/api/attachments/read/public/avatar/';
+
+    return sql`(
+      select jsonb_build_object(
+        'id', u.id,
+        'title', u.name,
+        'email', u.email,
+        'avatarUrl', ${avatarPrefix} || u.id
+      )
+      from public.users u
+      where u.id = ${systemColRef}
+    )`;
+  }
+
+  private getFieldSourceExpr(
+    field: {
+      type: () => FieldType;
+      dbFieldName: () => Result<{ value: () => Result<string, DomainError> }, DomainError>;
+    },
+    tableAlias: string
+  ): Result<{ expr: RawBuilder<unknown>; isJsonbStorage?: boolean }, DomainError> {
+    if (field.type().equals(FieldType.autoNumber())) {
+      return ok({ expr: sql.ref(`${tableAlias}.__auto_number`) });
+    }
+
+    if (field.type().equals(FieldType.createdTime())) {
+      return ok({ expr: sql.ref(`${tableAlias}.__created_time`) });
+    }
+
+    if (field.type().equals(FieldType.createdBy())) {
+      return ok({
+        expr: this.buildSystemUserJsonExpr(tableAlias, '__created_by'),
+        isJsonbStorage: true,
+      });
+    }
+
+    if (
+      field.type().equals(FieldType.lastModifiedTime()) &&
+      (field as { isTrackAll?: () => boolean }).isTrackAll?.()
+    ) {
+      return ok({ expr: sql.ref(`${tableAlias}.__last_modified_time`) });
+    }
+
+    if (
+      field.type().equals(FieldType.lastModifiedBy()) &&
+      (field as { isTrackAll?: () => boolean }).isTrackAll?.()
+    ) {
+      return ok({
+        expr: this.buildSystemUserJsonExpr(tableAlias, '__last_modified_by'),
+        isJsonbStorage: true,
+      });
+    }
+
+    return field
+      .dbFieldName()
+      .andThen((dbFieldName) => dbFieldName.value())
+      .map((columnName) => ({ expr: sql.ref(`${tableAlias}.${columnName}`) }));
+  }
+
   private getForeignColRef(
     foreignTable: Table,
     foreignFieldId: FieldId,
@@ -1116,10 +1177,7 @@ export class ComputedTableRecordQueryBuilder implements ITableRecordQueryBuilder
     return foreignTable
       .getField((f) => f.id().equals(foreignFieldId))
       .andThen((field) =>
-        field
-          .dbFieldName()
-          .andThen((dbFieldName) => dbFieldName.value())
-          .map((columnName) => sql`${sql.ref(`${tableAlias}.${columnName}`)}`)
+        this.getFieldSourceExpr(field, tableAlias).map(({ expr }) => sql`${expr}`)
       );
   }
 
@@ -1235,11 +1293,8 @@ export class ComputedTableRecordQueryBuilder implements ITableRecordQueryBuilder
     return foreignTable
       .getField((f) => f.id().equals(foreignFieldId))
       .andThen((foreignField) =>
-        foreignField
-          .dbFieldName()
-          .andThen((dbFieldName) => dbFieldName.value())
-          .andThen((columnName) => {
-            const colRef = sql.ref(`${tableAlias}.${columnName}`);
+        this.getFieldSourceExpr(foreignField, tableAlias).andThen(
+          ({ expr: colRef, isJsonbStorage: sourceIsJsonb }) => {
             // Build orderBy expression - handle both LinkOrderBy and simple format
             const orderByExpr = orderBy
               ? 'source' in orderBy
@@ -1253,7 +1308,8 @@ export class ComputedTableRecordQueryBuilder implements ITableRecordQueryBuilder
             // Don't assume lookup/link fields are always JSONB - they might be TEXT if looking up text values
             const dbFieldTypeResult = foreignField.dbFieldType().andThen((t) => t.value());
             const isJsonbStorage =
-              dbFieldTypeResult.isOk() && dbFieldTypeResult.value.toUpperCase() === 'JSON';
+              sourceIsJsonb ??
+              (dbFieldTypeResult.isOk() && dbFieldTypeResult.value.toUpperCase() === 'JSON');
 
             if (isJsonbStorage) {
               const aggExpr = sql`jsonb_agg(${colRef}::jsonb${orderByRef}) FILTER (WHERE ${colRef} IS NOT NULL)`;
@@ -1296,7 +1352,8 @@ export class ComputedTableRecordQueryBuilder implements ITableRecordQueryBuilder
             return ok(
               isMultiValue ? aggExpr.as(outputAlias) : sql`${aggExpr} -> 0`.as(outputAlias)
             );
-          })
+          }
+        )
       );
   }
 
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/query-builder/insert/RecordInsertBuilder.ts b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/insert/RecordInsertBuilder.ts
index a5645af1ac..fb81b3df17 100644
--- a/packages/v2/adapter-table-repository-postgres/src/record/query-builder/insert/RecordInsertBuilder.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/insert/RecordInsertBuilder.ts
@@ -134,6 +134,8 @@ export interface RecordInsertBuilderContext {
   lastModifiedByName?: string;
   lastModifiedByEmail?: string;
   autoNumber?: number;
+  /** When true, generate SQL to fill missing link titles via JOIN */
+  fillLinkTitles?: boolean;
 }
 
 /**
@@ -354,6 +356,29 @@ export class RecordInsertBuilder {
               }
               extraSeedRecordsMap.set(tableIdStr, entry);
             }
+
+            // Fill missing titles by JOINing foreign table's primary field.
+            // Only when fillLinkTitles is enabled (typecast mode from API).
+            if (context.fillLinkTitles) {
+              const linkItems = Array.isArray(rawValue)
+                ? (rawValue as Array<{ id: string; title?: string }>)
+                : [];
+              const hasMissingTitles = linkItems.some(
+                (item: { id?: string; title?: string }) =>
+                  item && typeof item === 'object' && item.id && !item.title
+              );
+              if (hasMissingTitles && linkItems.length > 0) {
+                const fillResult = builder.buildFillLinkTitleSql(
+                  table,
+                  linkField,
+                  dbFieldName,
+                  context.recordId
+                );
+                if (fillResult.isOk() && fillResult.value) {
+                  additionalStatements.push(fillResult.value);
+                }
+              }
+            }
           }
         } else {
           // Fallback: just use raw value
@@ -610,8 +635,82 @@ export class RecordInsertBuilder {
   }
 
   /**
-   * Build an UPDATE statement to populate user fields after INSERT.
-   * This uses a subquery to fetch user info from the users table.
+   * Build an UPDATE SQL to fill missing link titles by JOINing the foreign table's primary field.
+   */
+  private buildFillLinkTitleSql(
+    table: Table,
+    linkField: LinkField,
+    linkDbFieldName: string,
+    recordId: string
+  ): Result<CompiledSqlStatement | null, DomainError> {
+    const builder = this;
+    return safeTry<CompiledSqlStatement | null, DomainError>(function* () {
+      const foreignTableIdStr = linkField.foreignTableId().toString();
+      const lookupFieldIdStr = linkField.lookupFieldId().toString();
+
+      // Derive table names
+      const dbTableNameResult = table.dbTableName();
+      if (dbTableNameResult.isErr()) return ok(null);
+      const dbTableNameValue = dbTableNameResult.value.value();
+      if (dbTableNameValue.isErr()) return ok(null);
+      const tableName = dbTableNameValue.value;
+
+      // Derive the foreign table's DB name.
+      // For cross-base links, linkField.baseId() gives the foreign base ID.
+      const foreignBaseId = linkField.baseId();
+      const schemaParts = tableName.split('.');
+      const currentSchema = schemaParts.length > 1 ? schemaParts[0]! : 'public';
+      const foreignSchema = foreignBaseId ? foreignBaseId.toString() : currentSchema;
+      const foreignDbTableName = `${foreignSchema}.${foreignTableIdStr}`;
+
+      const lookupColSubquery = sql`(SELECT db_field_name FROM field WHERE id = ${sql.value(lookupFieldIdStr)} AND deleted_time IS NULL LIMIT 1)`;
+
+      const isMultiple = linkField.isMultipleValue();
+
+      const fillSql = isMultiple
+        ? sql`UPDATE ${sql.table(tableName)} SET ${sql.ref(linkDbFieldName)} = sub.new_val
+            FROM (
+              SELECT jsonb_agg(
+                jsonb_build_object(
+                  'id', elem->>'id',
+                  'title', COALESCE(
+                    elem->>'title',
+                    (SELECT val::text FROM jsonb_each_text(to_jsonb(ft.*) - '__id' - '__auto_number' - '__created_time' - '__last_modified_time' - '__created_by' - '__last_modified_by' - '__version') AS x(col, val)
+                     WHERE col = ${lookupColSubquery} LIMIT 1)
+                  )
+                )
+                ORDER BY elem_idx
+              ) as new_val
+              FROM jsonb_array_elements(
+                (SELECT ${sql.ref(linkDbFieldName)}::jsonb FROM ${sql.table(tableName)} WHERE __id = ${sql.value(recordId)})
+              ) WITH ORDINALITY AS arr(elem, elem_idx)
+              LEFT JOIN ${sql.table(foreignDbTableName)} ft ON ft.__id = (elem->>'id')
+            ) sub
+            WHERE ${sql.table(tableName)}.__id = ${sql.value(recordId)}`
+        : sql`UPDATE ${sql.table(tableName)} SET ${sql.ref(linkDbFieldName)} = sub.new_val
+            FROM (
+              SELECT jsonb_build_object(
+                'id', (src.${sql.ref(linkDbFieldName)}::jsonb)->>'id',
+                'title', COALESCE(
+                  (src.${sql.ref(linkDbFieldName)}::jsonb)->>'title',
+                  (SELECT val::text FROM jsonb_each_text(to_jsonb(ft.*) - '__id' - '__auto_number' - '__created_time' - '__last_modified_time' - '__created_by' - '__last_modified_by' - '__version') AS x(col, val)
+                   WHERE col = ${lookupColSubquery} LIMIT 1)
+                )
+              ) as new_val
+              FROM ${sql.table(tableName)} src
+              LEFT JOIN ${sql.table(foreignDbTableName)} ft ON ft.__id = ((src.${sql.ref(linkDbFieldName)}::jsonb)->>'id')
+              WHERE src.__id = ${sql.value(recordId)}
+            ) sub
+            WHERE ${sql.table(tableName)}.__id = ${sql.value(recordId)}`;
+
+      return ok({
+        description: `Fill missing link titles for field ${linkDbFieldName}`,
+        compiled: fillSql.compile(builder.db),
+      });
+    });
+  }
+
+  /**
    *
    * @param tableName - The fully qualified table name (schema.table)
    * @param recordId - The record ID to update
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/repository/PostgresTableRecordRepository.ts b/packages/v2/adapter-table-repository-postgres/src/record/repository/PostgresTableRecordRepository.ts
index d9054cb6c1..bec4736dab 100644
--- a/packages/v2/adapter-table-repository-postgres/src/record/repository/PostgresTableRecordRepository.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/record/repository/PostgresTableRecordRepository.ts
@@ -843,6 +843,7 @@ export class PostgresTableRecordRepository implements core.ITableRecordRepositor
               ...(restoreValues?.autoNumber !== undefined
                 ? { autoNumber: restoreValues.autoNumber }
                 : {}),
+              ...(options?.fillLinkTitles ? { fillLinkTitles: true } : {}),
             },
           });
 
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/visitors/CellValueMutateVisitor.ts b/packages/v2/adapter-table-repository-postgres/src/record/visitors/CellValueMutateVisitor.ts
index 992cf677c7..4073daece3 100644
--- a/packages/v2/adapter-table-repository-postgres/src/record/visitors/CellValueMutateVisitor.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/record/visitors/CellValueMutateVisitor.ts
@@ -567,14 +567,30 @@ export class CellValueMutateVisitor implements ICellValueSpecVisitor {
       }
 
       // Parse link items
-      const linkItems: Array<{ id: string }> = [];
+      const linkItems: Array<{ id: string; title?: string }> = [];
       if (rawValue !== null && rawValue !== undefined) {
         const items = Array.isArray(rawValue)
-          ? (rawValue as Array<{ id: string }>)
-          : [rawValue as { id: string }];
+          ? (rawValue as Array<{ id: string; title?: string }>)
+          : [rawValue as { id: string; title?: string }];
         linkItems.push(...items.filter((item) => item && typeof item === 'object' && 'id' in item));
       }
 
+      // Fill missing titles via SQL JOIN to foreign table's primary field.
+      // Only run when the spec carries foreignTableId (user-provided link values from API).
+      // Computed pipeline and system-generated link values already have titles resolved.
+      const hasMissingTitles =
+        spec.foreignTableId != null && linkItems.some((item) => item.id && !item.title);
+      if (hasMissingTitles && linkItems.length > 0) {
+        const fillTitleResult = yield* visitor.buildFillLinkTitleStatement(
+          linkField,
+          linkItems,
+          fieldId
+        );
+        if (fillTitleResult) {
+          visitor.additionalStatements.push(fillTitleResult);
+        }
+      }
+
       const relationship = linkField.relationship().toString();
       const hasOrderColumn = linkField.hasOrderColumn();
       const orderColumnName = hasOrderColumn ? yield* linkField.orderColumnName() : null;
@@ -743,6 +759,86 @@ export class CellValueMutateVisitor implements ICellValueSpecVisitor {
 
   // --- Link field by title (typecast mode) ---
 
+  /**
+   * Build an UPDATE statement that fills missing titles in a link field's JSON value
+   * by JOINing the foreign table's primary (lookup) field.
+   *
+   * For multiple-value links:
+   *   UPDATE main_table SET col = (
+   *     SELECT jsonb_agg(jsonb_build_object('id', elem->>'id', 'title', COALESCE(elem->>'title', ft."Lookup_Col")) ORDER BY idx)
+   *     FROM jsonb_array_elements(col::jsonb) WITH ORDINALITY AS arr(elem, idx)
+   *     LEFT JOIN "schema"."foreignTable" ft ON ft.__id = elem->>'id'
+   *   ) WHERE __id = $recordId
+   */
+  private buildFillLinkTitleStatement(
+    linkField: LinkField,
+    _linkItems: Array<{ id: string; title?: string }>,
+    fieldId: FieldId
+  ): Result<CompiledQuery | null, DomainError> {
+    const visitor = this;
+
+    return safeTry<CompiledQuery | null, DomainError>(function* () {
+      const foreignTableIdStr = linkField.foreignTableId().toString();
+      const lookupFieldIdStr = linkField.lookupFieldId().toString();
+
+      // Get the link field's own DB column name
+      const linkFieldObj = visitor.table.getField((f) => f.id().equals(fieldId))._unsafeUnwrap();
+      const linkDbFieldName = yield* visitor.resolveDbFieldName(linkFieldObj);
+
+      // Derive the foreign table's DB name.
+      // For cross-base links, linkField.baseId() gives the foreign base ID.
+      // For same-base links, use the current table's schema.
+      const foreignBaseId = linkField.baseId();
+      const schemaParts = visitor.tableName.split('.');
+      const currentSchema = schemaParts.length > 1 ? schemaParts[0]! : 'public';
+      const foreignSchema = foreignBaseId ? foreignBaseId.toString() : currentSchema;
+      const foreignDbTableName = `${foreignSchema}.${foreignTableIdStr}`;
+
+      // Get the lookup field's DB column name via subquery on field meta
+      const lookupColSubquery = sql`(SELECT db_field_name FROM field WHERE id = ${sql.value(lookupFieldIdStr)} AND deleted_time IS NULL LIMIT 1)`;
+
+      const isMultiple = linkField.isMultipleValue();
+
+      const fillSql = isMultiple
+        ? sql`UPDATE ${sql.table(visitor.tableName)} SET ${sql.ref(linkDbFieldName)} = sub.new_val
+          FROM (
+            SELECT jsonb_agg(
+              jsonb_build_object(
+                'id', elem->>'id',
+                'title', COALESCE(
+                  elem->>'title',
+                  (SELECT val::text FROM jsonb_each_text(to_jsonb(ft.*) - '__id' - '__auto_number' - '__created_time' - '__last_modified_time' - '__created_by' - '__last_modified_by' - '__version') AS x(col, val)
+                   WHERE col = ${lookupColSubquery} LIMIT 1)
+                )
+              )
+              ORDER BY elem_idx
+            ) as new_val
+            FROM jsonb_array_elements(
+              (SELECT ${sql.ref(linkDbFieldName)}::jsonb FROM ${sql.table(visitor.tableName)} WHERE __id = ${sql.value(visitor.ctx.recordId)})
+            ) WITH ORDINALITY AS arr(elem, elem_idx)
+            LEFT JOIN ${sql.table(foreignDbTableName)} ft ON ft.__id = (elem->>'id')
+          ) sub
+          WHERE ${sql.table(visitor.tableName)}.__id = ${sql.value(visitor.ctx.recordId)}`
+        : sql`UPDATE ${sql.table(visitor.tableName)} SET ${sql.ref(linkDbFieldName)} = sub.new_val
+          FROM (
+            SELECT jsonb_build_object(
+              'id', (src.${sql.ref(linkDbFieldName)}::jsonb)->>'id',
+              'title', COALESCE(
+                (src.${sql.ref(linkDbFieldName)}::jsonb)->>'title',
+                (SELECT val::text FROM jsonb_each_text(to_jsonb(ft.*) - '__id' - '__auto_number' - '__created_time' - '__last_modified_time' - '__created_by' - '__last_modified_by' - '__version') AS x(col, val)
+                 WHERE col = ${lookupColSubquery} LIMIT 1)
+              )
+            ) as new_val
+            FROM ${sql.table(visitor.tableName)} src
+            LEFT JOIN ${sql.table(foreignDbTableName)} ft ON ft.__id = ((src.${sql.ref(linkDbFieldName)}::jsonb)->>'id')
+            WHERE src.__id = ${sql.value(visitor.ctx.recordId)}
+          ) sub
+          WHERE ${sql.table(visitor.tableName)}.__id = ${sql.value(visitor.ctx.recordId)}`;
+
+      return ok(fillSql.compile(visitor.db));
+    });
+  }
+
   /**
    * Handle SetLinkValueByTitleSpec - used when typecast mode provides titles instead of IDs.
    *
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/checker/SchemaCheckResult.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/checker/SchemaCheckResult.ts
index 4a6e1ef676..aeeaef256f 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/checker/SchemaCheckResult.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/checker/SchemaCheckResult.ts
@@ -1,3 +1,5 @@
+import type { SchemaRuleDetailItem, SchemaRuleRepairHint } from '../core/ISchemaRule';
+
 /**
  * Status of a schema check result.
  */
@@ -31,9 +33,14 @@ export interface SchemaCheckResult {
   /** Detailed information about missing/extra schema objects */
   details?: {
     missing?: ReadonlyArray<string>;
+    missingItems?: ReadonlyArray<SchemaRuleDetailItem>;
     extra?: ReadonlyArray<string>;
+    extraItems?: ReadonlyArray<SchemaRuleDetailItem>;
   };
 
+  /** Repair capability metadata for this rule. */
+  repair?: SchemaRuleRepairHint;
+
   /** Whether this rule is required or optional */
   required: boolean;
 
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/checker/SchemaChecker.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/checker/SchemaChecker.ts
index 67b829b879..c4c1a4b3ec 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/checker/SchemaChecker.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/checker/SchemaChecker.ts
@@ -3,6 +3,7 @@ import type { V1TeableDatabase } from '@teable/v2-postgres-schema';
 import type { Kysely } from 'kysely';
 
 import type { SchemaIntrospector } from '../context/SchemaIntrospector';
+import { getRuleRepairHint } from '../core/RuleRepairMetadata';
 import {
   createSchemaRulePlanner,
   getSchemaRulePlanningStageDescription,
@@ -110,14 +111,26 @@ export class SchemaChecker {
           } else {
             const details = {
               missing: validation.missing,
+              missingItems: validation.missingItems,
               extra: validation.extra,
+              extraItems: validation.extraItems,
             };
+            const repairResult = getRuleRepairHint(rule, ctx, validation, {
+              skipStatementCheck: true,
+            });
+            const repair = repairResult.isOk() ? repairResult.value : undefined;
 
             if (rule.required) {
-              yield errorResult(pending, 'Schema validation failed', details);
+              yield {
+                ...errorResult(pending, 'Schema validation failed', details),
+                repair,
+              };
               validatedRules.set(rule.id, false);
             } else {
-              yield warnResult(pending, 'Schema element missing', details);
+              yield {
+                ...warnResult(pending, 'Schema element missing', details),
+                repair,
+              };
               validatedRules.set(rule.id, true);
             }
           }
@@ -205,21 +218,36 @@ export class SchemaChecker {
             yield successResult(pending);
             validatedRules.set(rule.id, true);
           } else {
-            const details = { missing: validation.missing, extra: validation.extra };
+            const details = {
+              missing: validation.missing,
+              missingItems: validation.missingItems,
+              extra: validation.extra,
+              extraItems: validation.extraItems,
+            };
+            const repairResult = getRuleRepairHint(rule, ctx, validation, {
+              skipStatementCheck: true,
+            });
+            const repair = repairResult.isOk() ? repairResult.value : undefined;
 
             if (rule.required) {
-              yield errorResult(
-                pending,
-                `Schema validation failed: ${validation.missing?.join(', ') || 'unknown issue'}`,
-                details
-              );
+              yield {
+                ...errorResult(
+                  pending,
+                  `Schema validation failed: ${validation.missing?.join(', ') || 'unknown issue'}`,
+                  details
+                ),
+                repair,
+              };
               validatedRules.set(rule.id, false);
             } else {
-              yield warnResult(
-                pending,
-                `Optional schema element missing: ${validation.missing?.join(', ')}`,
-                details
-              );
+              yield {
+                ...warnResult(
+                  pending,
+                  `Optional schema element missing: ${validation.missing?.join(', ')}`,
+                  details
+                ),
+                repair,
+              };
               validatedRules.set(rule.id, true);
             }
           }
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/core/ISchemaRule.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/core/ISchemaRule.ts
index c02aaf2b42..07e64bfb54 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/core/ISchemaRule.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/core/ISchemaRule.ts
@@ -12,6 +12,52 @@ export type TableSchemaStatementBuilder = {
   compile: (executorProvider: QueryExecutorProvider) => CompiledQuery;
 };
 
+export type SchemaRuleI18nValue = string | number | boolean;
+
+export interface SchemaRuleI18nMessage {
+  key?: string;
+  values?: Readonly<Record<string, SchemaRuleI18nValue>>;
+  fallback?: string;
+}
+
+export interface SchemaRuleDetailItem {
+  code?: string;
+  message: SchemaRuleI18nMessage;
+  description?: SchemaRuleI18nMessage;
+}
+
+export interface SchemaRuleManualRepairOption {
+  value: string;
+  label: SchemaRuleI18nMessage;
+  description?: SchemaRuleI18nMessage;
+}
+
+export interface SchemaRuleManualRepairSchemaProperty {
+  type: 'string' | 'boolean';
+  widget?: 'select' | 'text' | 'textarea' | 'checkbox';
+  title?: SchemaRuleI18nMessage;
+  description?: SchemaRuleI18nMessage;
+  options?: ReadonlyArray<SchemaRuleManualRepairOption>;
+  defaultValue?: string | boolean;
+}
+
+export interface SchemaRuleManualRepairSchema {
+  type: 'object';
+  title?: SchemaRuleI18nMessage;
+  description?: SchemaRuleI18nMessage;
+  submitLabel?: SchemaRuleI18nMessage;
+  required?: ReadonlyArray<string>;
+  properties: Readonly<Record<string, SchemaRuleManualRepairSchemaProperty>>;
+}
+
+export interface SchemaRuleRepairHint {
+  available: boolean;
+  mode: 'auto' | 'manual';
+  reason?: SchemaRuleI18nMessage;
+  description?: SchemaRuleI18nMessage;
+  manualRepairSchema?: SchemaRuleManualRepairSchema;
+}
+
 /**
  * Result of validating a schema rule against the current database state.
  */
@@ -20,8 +66,12 @@ export type SchemaRuleValidationResult = {
   valid: boolean;
   /** Descriptions of missing schema objects (columns, indexes, etc.) */
   missing?: ReadonlyArray<string>;
+  /** Structured, localizable descriptions of missing schema objects */
+  missingItems?: ReadonlyArray<SchemaRuleDetailItem>;
   /** Descriptions of extra/unexpected schema objects */
   extra?: ReadonlyArray<string>;
+  /** Structured, localizable descriptions of extra schema objects */
+  extraItems?: ReadonlyArray<SchemaRuleDetailItem>;
 };
 
 /**
@@ -71,6 +121,16 @@ export interface ISchemaRule {
    */
   readonly repairMode?: 'auto' | 'manual';
 
+  /**
+   * Optional structured repair metadata for UI consumers.
+   * Manual rules can return a reason and a form-like schema describing
+   * the user choices needed to proceed with repair.
+   */
+  getRepairHint?(
+    ctx: SchemaRuleContext,
+    validation: SchemaRuleValidationResult
+  ): Result<SchemaRuleRepairHint | undefined, DomainError>;
+
   /**
    * Validates whether the current database state satisfies this rule.
    * Queries information_schema to check for columns, indexes, constraints, etc.
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/core/ManualRepairSchema.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/core/ManualRepairSchema.ts
new file mode 100644
index 0000000000..ae8826c869
--- /dev/null
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/core/ManualRepairSchema.ts
@@ -0,0 +1,171 @@
+import { err, ok } from 'neverthrow';
+import type { Result } from 'neverthrow';
+import { z } from 'zod';
+
+import type {
+  SchemaRuleI18nMessage,
+  SchemaRuleManualRepairOption,
+  SchemaRuleManualRepairSchema,
+  SchemaRuleManualRepairSchemaProperty,
+} from './ISchemaRule';
+
+type ZodTypeAny = z.ZodTypeAny;
+type ZodObjectShape = z.ZodRawShape;
+
+type ManualRepairFormMeta = {
+  title?: SchemaRuleI18nMessage;
+  description?: SchemaRuleI18nMessage;
+  submitLabel?: SchemaRuleI18nMessage;
+};
+
+type ManualRepairFieldMeta = {
+  title?: SchemaRuleI18nMessage;
+  description?: SchemaRuleI18nMessage;
+  widget?: SchemaRuleManualRepairSchemaProperty['widget'];
+  options?: Readonly<Record<string, SchemaRuleManualRepairOption>>;
+};
+
+const formMetaRegistry = new WeakMap<ZodTypeAny, ManualRepairFormMeta>();
+const fieldMetaRegistry = new WeakMap<ZodTypeAny, ManualRepairFieldMeta>();
+
+type UnwrappedSchema = {
+  schema: ZodTypeAny;
+  required: boolean;
+  defaultValue?: string | boolean;
+};
+
+const unwrapSchema = (schema: ZodTypeAny): UnwrappedSchema => {
+  let current = schema;
+  let required = true;
+  let defaultValue: string | boolean | undefined;
+
+  for (;;) {
+    if (current instanceof z.ZodOptional || current instanceof z.ZodNullable) {
+      required = false;
+      current = current.unwrap();
+      continue;
+    }
+
+    if (current instanceof z.ZodDefault) {
+      const rawDefaultValue = current._def.defaultValue;
+      const candidate = typeof rawDefaultValue === 'function' ? rawDefaultValue() : rawDefaultValue;
+      if (typeof candidate === 'string' || typeof candidate === 'boolean') {
+        defaultValue = candidate;
+      }
+      current = current._def.innerType;
+      continue;
+    }
+
+    return {
+      schema: current,
+      required,
+      defaultValue,
+    };
+  }
+};
+
+const serializeFieldSchema = (
+  schema: ZodTypeAny,
+  key: string
+): Result<{ property: SchemaRuleManualRepairSchemaProperty; required: boolean }, Error> => {
+  const { schema: unwrapped, required, defaultValue } = unwrapSchema(schema);
+  const meta = fieldMetaRegistry.get(unwrapped) ?? fieldMetaRegistry.get(schema);
+
+  if (unwrapped instanceof z.ZodEnum) {
+    return ok({
+      required,
+      property: {
+        type: 'string',
+        widget: meta?.widget ?? 'select',
+        title: meta?.title,
+        description: meta?.description,
+        options: unwrapped.options.map(
+          (value: string): SchemaRuleManualRepairOption =>
+            meta?.options?.[value] ?? {
+              value,
+              label: { fallback: value },
+            }
+        ),
+        defaultValue,
+      },
+    });
+  }
+
+  if (unwrapped instanceof z.ZodBoolean) {
+    return ok({
+      required,
+      property: {
+        type: 'boolean',
+        widget: meta?.widget ?? 'checkbox',
+        title: meta?.title,
+        description: meta?.description,
+        defaultValue,
+      },
+    });
+  }
+
+  if (unwrapped instanceof z.ZodString) {
+    return ok({
+      required,
+      property: {
+        type: 'string',
+        widget: meta?.widget ?? 'text',
+        title: meta?.title,
+        description: meta?.description,
+        defaultValue,
+      },
+    });
+  }
+
+  return err(
+    new Error(`Unsupported manual repair schema property "${key}" (${unwrapped._def.typeName})`)
+  );
+};
+
+export const withManualRepairFormMeta = <T extends z.AnyZodObject>(
+  schema: T,
+  meta: ManualRepairFormMeta
+): T => {
+  formMetaRegistry.set(schema, meta);
+  return schema;
+};
+
+export const withManualRepairFieldMeta = <T extends ZodTypeAny>(
+  schema: T,
+  meta: ManualRepairFieldMeta
+): T => {
+  fieldMetaRegistry.set(schema, meta);
+  return schema;
+};
+
+export const serializeManualRepairSchema = (
+  schema: z.AnyZodObject
+): Result<SchemaRuleManualRepairSchema, Error> => {
+  const shape: ZodObjectShape = schema.shape;
+  const formMeta = formMetaRegistry.get(schema);
+  const properties: Record<string, SchemaRuleManualRepairSchemaProperty> = {};
+  const required: string[] = [];
+
+  for (const [key, propertySchema] of Object.entries(shape)) {
+    const propertyResult = serializeFieldSchema(propertySchema, key);
+    if (propertyResult.isErr()) {
+      return err(propertyResult.error);
+    }
+
+    const { property, required: isRequired } = propertyResult.value;
+    properties[key] = property;
+
+    if (isRequired) {
+      required.push(key);
+    }
+  }
+
+  return ok({
+    type: 'object',
+    title: formMeta?.title,
+    description: formMeta?.description,
+    submitLabel: formMeta?.submitLabel,
+    required: required.length ? required : undefined,
+    properties,
+  });
+};
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/core/RuleRepairMetadata.spec.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/core/RuleRepairMetadata.spec.ts
new file mode 100644
index 0000000000..234f4bc4bd
--- /dev/null
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/core/RuleRepairMetadata.spec.ts
@@ -0,0 +1,205 @@
+import type { DomainError } from '@teable/v2-core';
+import { err, ok } from 'neverthrow';
+import { describe, expect, it, vi } from 'vitest';
+import { z } from 'zod';
+
+import type { SchemaRuleContext } from '../context/SchemaRuleContext';
+import type { ISchemaRule, SchemaRuleRepairHint, SchemaRuleValidationResult } from './ISchemaRule';
+import {
+  serializeManualRepairSchema,
+  withManualRepairFieldMeta,
+  withManualRepairFormMeta,
+} from './ManualRepairSchema';
+import { getRuleRepairHint } from './RuleRepairMetadata';
+
+const createRule = (overrides: Partial<ISchemaRule> = {}): ISchemaRule => ({
+  id: 'rule:test',
+  description: 'Test rule',
+  dependencies: [],
+  required: true,
+  repairMode: 'auto',
+  isValid: vi.fn(async () => ok<SchemaRuleValidationResult, DomainError>({ valid: true })),
+  up: vi.fn(() => ok([])),
+  down: vi.fn(() => ok([])),
+  ...overrides,
+});
+
+describe('RuleRepairMetadata', () => {
+  describe('serializeManualRepairSchema', () => {
+    it('should serialize zod-backed manual repair schema metadata', () => {
+      const schema = withManualRepairFormMeta(
+        z.object({
+          resolution: withManualRepairFieldMeta(z.enum(['keep', 'drop']).default('keep'), {
+            widget: 'select',
+            title: { fallback: 'Resolution' },
+            description: { fallback: 'Choose how to resolve the conflict.' },
+            options: {
+              keep: {
+                value: 'keep',
+                label: { fallback: 'Keep current' },
+              },
+              drop: {
+                value: 'drop',
+                label: { fallback: 'Drop duplicate' },
+              },
+            },
+          }),
+          note: withManualRepairFieldMeta(z.string().optional(), {
+            widget: 'textarea',
+            title: { fallback: 'Note' },
+          }),
+          confirm: withManualRepairFieldMeta(z.boolean(), {
+            title: { fallback: 'Confirm' },
+          }),
+        }),
+        {
+          title: { fallback: 'Manual repair' },
+          description: { fallback: 'Provide the required repair choices.' },
+          submitLabel: { fallback: 'Apply repair' },
+        }
+      );
+
+      const result = serializeManualRepairSchema(schema);
+
+      expect(result.isOk()).toBe(true);
+      expect(result._unsafeUnwrap()).toEqual({
+        type: 'object',
+        title: { fallback: 'Manual repair' },
+        description: { fallback: 'Provide the required repair choices.' },
+        submitLabel: { fallback: 'Apply repair' },
+        required: ['resolution', 'confirm'],
+        properties: {
+          resolution: {
+            type: 'string',
+            widget: 'select',
+            title: { fallback: 'Resolution' },
+            description: { fallback: 'Choose how to resolve the conflict.' },
+            options: [
+              { value: 'keep', label: { fallback: 'Keep current' } },
+              { value: 'drop', label: { fallback: 'Drop duplicate' } },
+            ],
+            defaultValue: 'keep',
+          },
+          note: {
+            type: 'string',
+            widget: 'textarea',
+            title: { fallback: 'Note' },
+            description: undefined,
+            defaultValue: undefined,
+          },
+          confirm: {
+            type: 'boolean',
+            widget: 'checkbox',
+            title: { fallback: 'Confirm' },
+            description: undefined,
+            defaultValue: undefined,
+          },
+        },
+      });
+    });
+
+    it('should return an error instead of throwing for unsupported property types', () => {
+      const schema = z.object({
+        count: z.number(),
+      });
+
+      const result = serializeManualRepairSchema(schema);
+
+      expect(result.isErr()).toBe(true);
+      expect(result._unsafeUnwrapErr().message).toContain(
+        'Unsupported manual repair schema property "count"'
+      );
+    });
+
+    it('should support zod default metadata stored as a direct value', () => {
+      const resolution = z.enum(['keep', 'drop']).default('keep');
+      const defaultSchema = resolution as typeof resolution & {
+        _def: typeof resolution._def & { defaultValue: string };
+      };
+      defaultSchema._def.defaultValue = 'keep';
+
+      const schema = z.object({
+        resolution: withManualRepairFieldMeta(defaultSchema, {
+          widget: 'select',
+          title: { fallback: 'Resolution' },
+          options: {
+            keep: {
+              value: 'keep',
+              label: { fallback: 'Keep current' },
+            },
+            drop: {
+              value: 'drop',
+              label: { fallback: 'Drop duplicate' },
+            },
+          },
+        }),
+      });
+
+      const result = serializeManualRepairSchema(schema);
+
+      expect(result.isOk()).toBe(true);
+      expect(result._unsafeUnwrap().properties.resolution.defaultValue).toBe('keep');
+    });
+  });
+
+  describe('getRuleRepairHint', () => {
+    it('should skip statement generation during check-time hint computation', () => {
+      const up = vi.fn(() => ok([]));
+      const rule = createRule({ up });
+
+      const result = getRuleRepairHint(
+        rule,
+        {} as SchemaRuleContext,
+        { valid: false },
+        { skipStatementCheck: true }
+      );
+
+      expect(result.isOk()).toBe(true);
+      expect(result._unsafeUnwrap()).toEqual({
+        available: true,
+        mode: 'auto',
+      });
+      expect(up).not.toHaveBeenCalled();
+    });
+
+    it('should prefer the rule-provided repair hint without calling up', () => {
+      const up = vi.fn(() => ok([]));
+      const customHint: SchemaRuleRepairHint = {
+        available: false,
+        mode: 'manual',
+        reason: { fallback: 'Needs user choice' },
+      };
+      const rule = createRule({
+        up,
+        getRepairHint: () => ok(customHint),
+      });
+
+      const result = getRuleRepairHint(rule, {} as SchemaRuleContext, { valid: false });
+
+      expect(result.isOk()).toBe(true);
+      expect(result._unsafeUnwrap()).toEqual(customHint);
+      expect(up).not.toHaveBeenCalled();
+    });
+
+    it('should surface statement-generation failures as unavailable manual repair', () => {
+      const rule = createRule({
+        up: vi.fn(() => err(new Error('boom'))),
+      });
+
+      const result = getRuleRepairHint(rule, {} as SchemaRuleContext, { valid: false });
+
+      expect(result.isOk()).toBe(true);
+      expect(result._unsafeUnwrap()).toEqual({
+        available: false,
+        mode: 'manual',
+        reason: {
+          key: 'table:table.integrity.v2.repairMeta.reason.statementGenerationFailed',
+          fallback: 'Repair statements could not be generated.',
+        },
+        description: {
+          fallback: 'boom',
+        },
+      });
+    });
+  });
+});
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/core/RuleRepairMetadata.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/core/RuleRepairMetadata.ts
new file mode 100644
index 0000000000..6645a7bfff
--- /dev/null
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/core/RuleRepairMetadata.ts
@@ -0,0 +1,101 @@
+import type { DomainError } from '@teable/v2-core';
+import { err, ok } from 'neverthrow';
+import type { Result } from 'neverthrow';
+
+import type { SchemaRuleContext } from '../context/SchemaRuleContext';
+import type {
+  ISchemaRule,
+  SchemaRuleI18nMessage,
+  SchemaRuleRepairHint,
+  SchemaRuleValidationResult,
+} from './ISchemaRule';
+
+const createMessage = (
+  key: string,
+  fallback: string,
+  values?: Readonly<Record<string, string | number | boolean>>
+): SchemaRuleI18nMessage => ({
+  key,
+  fallback,
+  values,
+});
+
+export const getRuleRepairHint = (
+  rule: ISchemaRule,
+  ctx: SchemaRuleContext,
+  validation: SchemaRuleValidationResult,
+  options?: {
+    skipStatementCheck?: boolean;
+  }
+): Result<SchemaRuleRepairHint, DomainError> => {
+  if (validation.valid) {
+    return ok({
+      available: false,
+      mode: rule.repairMode === 'manual' ? 'manual' : 'auto',
+      reason: createMessage(
+        'table:table.integrity.v2.repairMeta.reason.alreadyValid',
+        'The schema is already valid.'
+      ),
+    });
+  }
+
+  if (rule.getRepairHint) {
+    const hintResult = rule.getRepairHint(ctx, validation);
+    if (hintResult.isErr()) {
+      return err(hintResult.error);
+    }
+
+    if (hintResult.value) {
+      return ok(hintResult.value);
+    }
+  }
+
+  if (rule.repairMode === 'manual') {
+    return ok({
+      available: false,
+      mode: 'manual',
+      reason: createMessage(
+        'table:table.integrity.v2.repairMeta.reason.manualRule',
+        'This rule requires manual repair.'
+      ),
+    });
+  }
+
+  if (options?.skipStatementCheck) {
+    return ok({
+      available: true,
+      mode: 'auto',
+    });
+  }
+
+  const statementsResult = rule.up(ctx);
+  if (statementsResult.isErr()) {
+    return ok({
+      available: false,
+      mode: 'manual',
+      reason: createMessage(
+        'table:table.integrity.v2.repairMeta.reason.statementGenerationFailed',
+        'Repair statements could not be generated.'
+      ),
+      description: {
+        fallback: statementsResult.error.message,
+      },
+    });
+  }
+
+  if (statementsResult.value.length === 0) {
+    return ok({
+      available: false,
+      mode: 'manual',
+      reason: createMessage(
+        'table:table.integrity.v2.repairMeta.reason.noStatements',
+        'No automatic repair statements are available.'
+      ),
+    });
+  }
+
+  return ok({
+    available: true,
+    mode: 'auto',
+  });
+};
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/core/index.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/core/index.ts
index 4942b93a29..5df3874586 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/core/index.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/core/index.ts
@@ -1,5 +1,6 @@
 export type {
   ISchemaRule,
+  SchemaRuleRepairHint,
   SchemaRuleValidationResult,
   TableSchemaStatementBuilder,
 } from './ISchemaRule';
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/ColumnUniqueConstraintRule.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/ColumnUniqueConstraintRule.ts
index bba40ae9c9..2c8f82d89f 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/ColumnUniqueConstraintRule.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/ColumnUniqueConstraintRule.ts
@@ -51,6 +51,7 @@ export class ColumnUniqueConstraintRule implements ISchemaRule {
       const columnName = yield* resolveColumnName(ctx.field);
       const schemaName = ctx.schema ?? 'public';
       const indexName = self.getIndexName(ctx.tableName, columnName);
+      const fieldName = self.field.name().toString();
 
       // Check for unique index
       const indexResult = await ctx.introspector.getIndex(ctx.schema, indexName);
@@ -71,12 +72,52 @@ export class ColumnUniqueConstraintRule implements ISchemaRule {
             missing: [
               `column "${schemaName}"."${ctx.tableName}"."${columnName}" should have UNIQUE constraint`,
             ],
+            missingItems: [
+              {
+                code: 'column_unique_missing',
+                message: {
+                  key: 'table:table.integrity.v2.detail.columnUniqueMissing',
+                  values: {
+                    fieldName,
+                  },
+                  fallback: `Field "${fieldName}" should be unique.`,
+                },
+                description: {
+                  key: 'table:table.integrity.v2.detail.columnUniqueMissingDescription',
+                  values: {
+                    fieldName,
+                  },
+                  fallback:
+                    'A unique index is missing, so duplicate values can be written for this field.',
+                },
+              },
+            ],
           });
         }
       } else if (!index.isUnique) {
         return ok({
           valid: false,
           missing: [`index "${indexName}" exists but is not unique`],
+          missingItems: [
+            {
+              code: 'column_unique_not_unique',
+              message: {
+                key: 'table:table.integrity.v2.detail.columnUniqueIndexMismatch',
+                values: {
+                  fieldName,
+                },
+                fallback: `Field "${fieldName}" is indexed, but the index is not unique.`,
+              },
+              description: {
+                key: 'table:table.integrity.v2.detail.columnUniqueIndexMismatchDescription',
+                values: {
+                  fieldName,
+                },
+                fallback:
+                  'This field expects uniqueness, but the current database index still allows duplicates.',
+              },
+            },
+          ],
         });
       }
 
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/ForeignKeyRule.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/ForeignKeyRule.ts
index e28e1b56fb..5f71bee3a7 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/ForeignKeyRule.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/ForeignKeyRule.ts
@@ -5,6 +5,7 @@ import type { Result } from 'neverthrow';
 import type { SchemaRuleContext } from '../context/SchemaRuleContext';
 import type {
   ISchemaRule,
+  SchemaRuleRepairHint,
   SchemaRuleValidationResult,
   TableSchemaStatementBuilder,
 } from '../core/ISchemaRule';
@@ -85,6 +86,10 @@ export class ForeignKeyRule implements ISchemaRule {
   async isValid(ctx: SchemaRuleContext): Promise<Result<SchemaRuleValidationResult, DomainError>> {
     const constraintName = this.constraintName;
     const localTable = this.getLocalTable(ctx);
+    const fieldName = this.field.name().toString();
+    const targetTableName = this.targetTableName;
+    const targetPhysicalTableName = this.targetTable.tableName;
+    const targetTableSchema = this.targetTable.schema;
     return safeTry<SchemaRuleValidationResult, DomainError>(async function* () {
       const existsResult = await ctx.introspector.foreignKeyExists(
         localTable.schema,
@@ -93,13 +98,132 @@ export class ForeignKeyRule implements ISchemaRule {
       );
       const exists = yield* existsResult;
 
+      if (!exists) {
+        const targetExistsResult = await ctx.introspector.tableExists(
+          targetTableSchema,
+          targetPhysicalTableName
+        );
+        const targetExists = yield* targetExistsResult;
+
+        if (!targetExists) {
+          return ok({
+            valid: false,
+            missing: [
+              `foreign key constraint ${constraintName}`,
+              `target table ${targetPhysicalTableName} does not exist`,
+            ],
+            missingItems: [
+              {
+                code: 'foreign_key_missing',
+                message: {
+                  key: 'table:table.integrity.v2.detail.foreignKeyMissing',
+                  values: {
+                    fieldName,
+                  },
+                  fallback: `Field "${fieldName}" is missing its foreign key constraint.`,
+                },
+                description: {
+                  key: 'table:table.integrity.v2.detail.foreignKeyMissingDescription',
+                  values: {
+                    fieldName,
+                    targetTableName,
+                  },
+                  fallback: `Without the foreign key constraint, "${fieldName}" can reference rows that no longer exist in ${targetTableName}.`,
+                },
+              },
+              {
+                code: 'foreign_key_target_table_missing',
+                message: {
+                  key: 'table:table.integrity.v2.detail.foreignKeyTargetTableMissing',
+                  values: {
+                    fieldName,
+                    targetTableName,
+                  },
+                  fallback: `The linked table for "${fieldName}" no longer exists.`,
+                },
+                description: {
+                  key: 'table:table.integrity.v2.detail.foreignKeyTargetTableMissingDescription',
+                  values: {
+                    fieldName,
+                    targetTableName,
+                    targetPhysicalTableName,
+                  },
+                  fallback: `Automatic repair cannot recreate the foreign key because the target table "${targetPhysicalTableName}" is missing.`,
+                },
+              },
+            ],
+          });
+        }
+      }
+
       return ok({
         valid: exists,
         missing: exists ? [] : [`foreign key constraint ${constraintName}`],
+        missingItems: exists
+          ? []
+          : [
+              {
+                code: 'foreign_key_missing',
+                message: {
+                  key: 'table:table.integrity.v2.detail.foreignKeyMissing',
+                  values: {
+                    fieldName,
+                  },
+                  fallback: `Field "${fieldName}" is missing its foreign key constraint.`,
+                },
+                description: {
+                  key: 'table:table.integrity.v2.detail.foreignKeyMissingDescription',
+                  values: {
+                    fieldName,
+                    targetTableName,
+                  },
+                  fallback: `Without the foreign key constraint, "${fieldName}" can reference rows that no longer exist in ${targetTableName}.`,
+                },
+              },
+            ],
       });
     });
   }
 
+  getRepairHint(
+    _ctx: SchemaRuleContext,
+    validation: SchemaRuleValidationResult
+  ): Result<SchemaRuleRepairHint | undefined, DomainError> {
+    const targetTableMissing = validation.missingItems?.some(
+      (item) => item.code === 'foreign_key_target_table_missing'
+    );
+
+    if (!targetTableMissing) {
+      return ok(undefined);
+    }
+
+    const fieldName = this.field.name().toString();
+    const targetTableName = this.targetTableName;
+    const targetPhysicalTableName = this.targetTable.tableName;
+
+    return ok({
+      available: false,
+      mode: 'auto',
+      reason: {
+        key: 'table:table.integrity.v2.repairMeta.reason.foreignKeyTargetTableMissing',
+        values: {
+          fieldName,
+          targetTableName,
+        },
+        fallback: `Automatic repair is unavailable because the linked table for "${fieldName}" is missing.`,
+      },
+      description: {
+        key: 'table:table.integrity.v2.repairMeta.description.foreignKeyTargetTableMissing',
+        values: {
+          fieldName,
+          targetTableName,
+          targetPhysicalTableName,
+        },
+        fallback: `Check whether the linked table "${targetPhysicalTableName}" was deleted or renamed. Recreate the table, or update/remove the link field configuration for "${fieldName}", then run the check again.`,
+      },
+    });
+  }
+
   up(ctx: SchemaRuleContext): Result<ReadonlyArray<TableSchemaStatementBuilder>, DomainError> {
     const sourceTable = this.getLocalTable(ctx);
     return ok([
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/LinkSymmetricFieldRule.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/LinkSymmetricFieldRule.ts
index 1dd6544d05..fc36b9fcbc 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/LinkSymmetricFieldRule.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/LinkSymmetricFieldRule.ts
@@ -1,13 +1,20 @@
 import type { DomainError, LinkField } from '@teable/v2-core';
 import { ok } from 'neverthrow';
 import type { Result } from 'neverthrow';
+import { z } from 'zod';
 
 import type { SchemaRuleContext } from '../context/SchemaRuleContext';
 import type {
   ISchemaRule,
+  SchemaRuleRepairHint,
   SchemaRuleValidationResult,
   TableSchemaStatementBuilder,
 } from '../core/ISchemaRule';
+import {
+  serializeManualRepairSchema,
+  withManualRepairFieldMeta,
+  withManualRepairFormMeta,
+} from '../core/ManualRepairSchema';
 
 /**
  * Schema rule for validating Link field symmetric relationship integrity.
@@ -25,6 +32,64 @@ export class LinkSymmetricFieldRule implements ISchemaRule {
   readonly required = true;
   readonly repairMode = 'manual' as const;
 
+  private readonly manualRepairSchema = withManualRepairFormMeta(
+    z.object({
+      resolution: withManualRepairFieldMeta(
+        z.enum(['keep_current_link', 'keep_duplicate_link', 'convert_duplicate_to_one_way']),
+        {
+          widget: 'select',
+          title: {
+            key: 'table:table.integrity.v2.repairMeta.manual.symmetricField.resolutionLabel',
+            fallback: 'Repair strategy',
+          },
+          description: {
+            key: 'table:table.integrity.v2.repairMeta.manual.symmetricField.resolutionDescription',
+            fallback:
+              'Decide which field keeps the current two-way link, or convert the duplicate link into a one-way link before repairing.',
+          },
+          options: {
+            keep_current_link: {
+              value: 'keep_current_link',
+              label: {
+                key: 'table:table.integrity.v2.repairMeta.manual.symmetricField.option.keepCurrent',
+                fallback: 'Keep the current link as the two-way source',
+              },
+            },
+            keep_duplicate_link: {
+              value: 'keep_duplicate_link',
+              label: {
+                key: 'table:table.integrity.v2.repairMeta.manual.symmetricField.option.keepDuplicate',
+                fallback: 'Keep the duplicate link instead',
+              },
+            },
+            convert_duplicate_to_one_way: {
+              value: 'convert_duplicate_to_one_way',
+              label: {
+                key: 'table:table.integrity.v2.repairMeta.manual.symmetricField.option.convertDuplicate',
+                fallback: 'Convert the duplicate link to one-way',
+              },
+            },
+          },
+        }
+      ).default('keep_current_link'),
+    }),
+    {
+      title: {
+        key: 'table:table.integrity.v2.repairMeta.manual.symmetricField.title',
+        fallback: 'Resolve symmetric field conflict',
+      },
+      description: {
+        key: 'table:table.integrity.v2.repairMeta.manual.symmetricField.description',
+        fallback:
+          'This rule cannot be repaired automatically. The user must choose how to handle the duplicate two-way link.',
+      },
+      submitLabel: {
+        key: 'table:table.integrity.v2.repairMeta.manual.apply',
+        fallback: 'Apply manual repair',
+      },
+    }
+  );
+
   private constructor(
     private readonly field: LinkField,
     private readonly symmetricFieldId: string
@@ -71,7 +136,25 @@ export class LinkSymmetricFieldRule implements ISchemaRule {
       missing.push(
         `symmetricFieldId "${symmetricFieldId}" does not exist (field may have been deleted)`
       );
-      return ok({ valid: false, missing });
+      return ok({
+        valid: false,
+        missing,
+        missingItems: [
+          {
+            code: 'symmetric_field_missing',
+            message: {
+              key: 'table:table.integrity.v2.detail.symmetricFieldTargetMissing',
+              values: {
+                fieldName: this.field.name().toString(),
+              },
+              fallback: `The paired link field for "${this.field.name().toString()}" does not exist.`,
+            },
+            description: {
+              fallback: missing[0],
+            },
+          },
+        ],
+      });
     }
 
     // 2. Check if symmetric field is a link type
@@ -79,7 +162,27 @@ export class LinkSymmetricFieldRule implements ISchemaRule {
       missing.push(
         `symmetricFieldId "${symmetricFieldId}" (${symmetricFieldResult.name}) is type "${symmetricFieldResult.type}", expected "link"`
       );
-      return ok({ valid: false, missing });
+      return ok({
+        valid: false,
+        missing,
+        missingItems: [
+          {
+            code: 'symmetric_field_wrong_type',
+            message: {
+              key: 'table:table.integrity.v2.detail.symmetricFieldWrongType',
+              values: {
+                fieldName: this.field.name().toString(),
+                targetFieldName: symmetricFieldResult.name,
+                targetFieldType: symmetricFieldResult.type,
+              },
+              fallback: `The paired field "${symmetricFieldResult.name}" is not a link field.`,
+            },
+            description: {
+              fallback: missing[0],
+            },
+          },
+        ],
+      });
     }
 
     // 3. Check bidirectional consistency: symmetric field should point back to this field
@@ -94,7 +197,25 @@ export class LinkSymmetricFieldRule implements ISchemaRule {
         missing.push(
           `symmetricFieldId "${symmetricFieldId}" (${symmetricFieldResult.name}) has invalid JSON in options column`
         );
-        return ok({ valid: false, missing });
+        return ok({
+          valid: false,
+          missing,
+          missingItems: [
+            {
+              code: 'symmetric_field_invalid_options',
+              message: {
+                key: 'table:table.integrity.v2.detail.symmetricFieldInvalidOptions',
+                values: {
+                  targetFieldName: symmetricFieldResult.name,
+                },
+                fallback: `The paired field "${symmetricFieldResult.name}" has invalid link metadata.`,
+              },
+              description: {
+                fallback: missing[0],
+              },
+            },
+          ],
+        });
       }
     }
 
@@ -103,14 +224,52 @@ export class LinkSymmetricFieldRule implements ISchemaRule {
       missing.push(
         `symmetricFieldId "${symmetricFieldId}" (${symmetricFieldResult.name}) has no symmetricFieldId (broken bidirectional link)`
       );
-      return ok({ valid: false, missing });
+      return ok({
+        valid: false,
+        missing,
+        missingItems: [
+          {
+            code: 'symmetric_field_no_back_reference',
+            message: {
+              key: 'table:table.integrity.v2.detail.symmetricFieldMissingBackReference',
+              values: {
+                fieldName: this.field.name().toString(),
+                targetFieldName: symmetricFieldResult.name,
+              },
+              fallback: `The paired field "${symmetricFieldResult.name}" no longer points back to "${this.field.name().toString()}".`,
+            },
+            description: {
+              fallback: missing[0],
+            },
+          },
+        ],
+      });
     }
 
     if (backReference !== currentFieldId) {
       missing.push(
         `symmetricFieldId "${symmetricFieldId}" (${symmetricFieldResult.name}) points to "${backReference}", expected "${currentFieldId}" (broken bidirectional link)`
       );
-      return ok({ valid: false, missing });
+      return ok({
+        valid: false,
+        missing,
+        missingItems: [
+          {
+            code: 'symmetric_field_wrong_back_reference',
+            message: {
+              key: 'table:table.integrity.v2.detail.symmetricFieldWrongBackReference',
+              values: {
+                fieldName: this.field.name().toString(),
+                targetFieldName: symmetricFieldResult.name,
+              },
+              fallback: `The paired field "${symmetricFieldResult.name}" points to another field instead of "${this.field.name().toString()}".`,
+            },
+            description: {
+              fallback: missing[0],
+            },
+          },
+        ],
+      });
     }
 
     // 4. Check for duplicate symmetric field references (uniqueness)
@@ -133,7 +292,31 @@ export class LinkSymmetricFieldRule implements ISchemaRule {
       missing.push(
         `symmetricFieldId "${symmetricFieldId}" is also used by: ${duplicates} (should be unique)`
       );
-      return ok({ valid: false, missing });
+      return ok({
+        valid: false,
+        missing,
+        missingItems: [
+          {
+            code: 'symmetric_field_duplicate_usage',
+            message: {
+              key: 'table:table.integrity.v2.detail.symmetricFieldDuplicateUsage',
+              values: {
+                fieldName: this.field.name().toString(),
+                duplicateFields: duplicateResult.map((r) => r.name).join(', '),
+              },
+              fallback: `The paired link target for "${this.field.name().toString()}" is reused by another link field.`,
+            },
+            description: {
+              key: 'table:table.integrity.v2.detail.symmetricFieldDuplicateUsageDescription',
+              values: {
+                duplicateFields: duplicateResult.map((r) => r.name).join(', '),
+                symmetricFieldId,
+              },
+              fallback: missing[0],
+            },
+          },
+        ],
+      });
     }
 
     return ok({ valid: true });
@@ -153,4 +336,32 @@ export class LinkSymmetricFieldRule implements ISchemaRule {
   down(_ctx: SchemaRuleContext): Result<ReadonlyArray<TableSchemaStatementBuilder>, DomainError> {
     return ok([]);
   }
+
+  getRepairHint(
+    _ctx: SchemaRuleContext,
+    validation: SchemaRuleValidationResult
+  ): Result<SchemaRuleRepairHint | undefined, DomainError> {
+    const duplicateMessage = validation.missingItems?.find(
+      (item) => item.code === 'symmetric_field_duplicate_usage'
+    );
+    const duplicateSchemaResult = duplicateMessage
+      ? serializeManualRepairSchema(this.manualRepairSchema)
+      : undefined;
+
+    return ok({
+      available: false,
+      mode: 'manual',
+      reason: {
+        key: 'table:table.integrity.v2.repairMeta.reason.symmetricFieldConflict',
+        fallback:
+          'This two-way link needs a user decision because more than one field shares the same symmetric target.',
+      },
+      description: duplicateMessage?.description ?? {
+        key: 'table:table.integrity.v2.repairMeta.description.symmetricFieldConflict',
+        fallback:
+          'Choose which link should keep the existing symmetric pairing, and decide how the duplicate field should be adjusted.',
+      },
+      manualRepairSchema: duplicateSchemaResult?.isOk() ? duplicateSchemaResult.value : undefined,
+    });
+  }
 }
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/ReferenceRule.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/ReferenceRule.ts
index 59cb5b151c..c53e58d282 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/ReferenceRule.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/ReferenceRule.ts
@@ -117,6 +117,24 @@ export class ReferenceRule implements ISchemaRule {
       return ok({
         valid: false,
         missing: missingRefs,
+        missingItems: missingRefs.map((missingRef) => ({
+          code: 'reference_missing',
+          message: {
+            key: 'table:table.integrity.v2.detail.referenceMissing',
+            values: {
+              fieldName: this.field.name().toString(),
+            },
+            fallback: `A dependency reference is missing for "${this.field.name().toString()}".`,
+          },
+          description: {
+            key: 'table:table.integrity.v2.detail.referenceMissingDescription',
+            values: {
+              fieldName: this.field.name().toString(),
+              reference: missingRef,
+            },
+            fallback: missingRef,
+          },
+        })),
       });
     }
 
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/SchemaRules.pglite.spec.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/SchemaRules.pglite.spec.ts
index 422eca4b9f..10556d6945 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/SchemaRules.pglite.spec.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/SchemaRules.pglite.spec.ts
@@ -1158,6 +1158,56 @@ describe('Schema Rules Unit Tests with PGlite', () => {
       }
       expect((await rule.isValid(ctx))._unsafeUnwrap().valid).toBe(false);
     });
+
+    it('should mark repair as unavailable when the target table is missing', async () => {
+      await createTestTable(SOURCE_TABLE, ['fk_col TEXT']);
+
+      const fieldResult = createRealField('fk004', 'Link', 'fk_col');
+      const field = fieldResult._unsafeUnwrap();
+
+      const fkColumnRule = FkColumnRule.forField(field, 'fk_col', TARGET_TABLE);
+      const rule = ForeignKeyRule.forField(
+        field,
+        'fk_col',
+        { schema: TEST_SCHEMA, tableName: TARGET_TABLE },
+        fkColumnRule,
+        TARGET_TABLE
+      );
+      const ctx = createContext(SOURCE_TABLE, field);
+
+      const validation = await rule.isValid(ctx);
+      expect(validation.isOk()).toBe(true);
+      expect(
+        validation
+          ._unsafeUnwrap()
+          .missingItems?.some((item) => item.code === 'foreign_key_target_table_missing')
+      ).toBe(true);
+
+      const repairHint = rule.getRepairHint(ctx, validation._unsafeUnwrap());
+      expect(repairHint.isOk()).toBe(true);
+      expect(repairHint._unsafeUnwrap()).toEqual({
+        available: false,
+        mode: 'auto',
+        reason: {
+          key: 'table:table.integrity.v2.repairMeta.reason.foreignKeyTargetTableMissing',
+          values: {
+            fieldName: 'Link',
+            targetTableName: TARGET_TABLE,
+          },
+          fallback:
+            'Automatic repair is unavailable because the linked table for "Link" is missing.',
+        },
+        description: {
+          key: 'table:table.integrity.v2.repairMeta.description.foreignKeyTargetTableMissing',
+          values: {
+            fieldName: 'Link',
+            targetTableName: TARGET_TABLE,
+            targetPhysicalTableName: TARGET_TABLE,
+          },
+          fallback: `Check whether the linked table "${TARGET_TABLE}" was deleted or renamed. Recreate the table, or update/remove the link field configuration for "Link", then run the check again.`,
+        },
+      });
+    });
   });
 
   describe('OrderColumnRule', () => {
@@ -2129,6 +2179,40 @@ describe('Schema Rules Unit Tests with PGlite', () => {
   });
 
   describe('SchemaRepairer', () => {
+    const expectRuleRepairLifecycle = async (params: {
+      table: Table;
+      fieldId: string;
+      ruleId: string;
+      expectedStatus?: 'warn' | 'error';
+      verifyAfterRepair?: () => Promise<void>;
+    }) => {
+      const { table, fieldId, ruleId, expectedStatus = 'error', verifyAfterRepair } = params;
+
+      const checker = createSchemaChecker({ db, introspector, schema: TEST_SCHEMA });
+      const initialCheckResults = await collectFinalResults(checker.checkField(table, fieldId));
+
+      expect(initialCheckResults.find((result) => result.ruleId === ruleId)?.status).toBe(
+        expectedStatus
+      );
+
+      const repairer = createSchemaRepairer({ db, introspector, schema: TEST_SCHEMA });
+      const repairResults = await collectFinalRepairResults(
+        repairer.repairRule(table, fieldId, ruleId)
+      );
+
+      expect(repairResults.find((result) => result.ruleId === ruleId)?.status).toBe('success');
+      expect(repairResults.find((result) => result.ruleId === ruleId)?.outcome).toBe('repaired');
+
+      const repairedCheckResults = await collectFinalResults(checker.checkField(table, fieldId));
+      expect(repairedCheckResults.find((result) => result.ruleId === ruleId)?.status).toBe(
+        'success'
+      );
+
+      if (verifyAfterRepair) {
+        await verifyAfterRepair();
+      }
+    };
+
     it('should report missing system __id uniqueness when checking system rules', async () => {
       const tableName = 'test_schema_system_rule_check';
       await createExplicitTestTable(tableName, [
@@ -2309,6 +2393,26 @@ describe('Schema Rules Unit Tests with PGlite', () => {
       expect(checkResults.every((result) => result.status === 'success')).toBe(true);
     });
 
+    it('should include repair hint metadata in check results for failing auto-repair rules', async () => {
+      const tableName = 'test_schema_check_repair_hint';
+      await createTestTable(tableName);
+
+      const field = createRealField('hint001', 'Name', 'name_col')._unsafeUnwrap();
+      const table = createTableAggregate(tableName, field);
+      const checker = createSchemaChecker({ db, introspector, schema: TEST_SCHEMA });
+
+      const results = await collectFinalResults(checker.checkField(table, field.id().toString()));
+      const columnRule = results.find(
+        (result) => result.ruleId === `column:${field.id().toString()}`
+      );
+
+      expect(columnRule?.status).toBe('error');
+      expect(columnRule?.repair).toEqual({
+        available: true,
+        mode: 'auto',
+      });
+    });
+
     it('should repair a missing column when repairing a field', async () => {
       const tableName = 'test_schema_repair_field';
       await createTestTable(tableName);
@@ -2331,6 +2435,107 @@ describe('Schema Rules Unit Tests with PGlite', () => {
       expect(results[0].ruleId).toBe(`column:${field.id().toString()}`);
     });
 
+    it('should skip error repairs when targetStatuses only includes warnings', async () => {
+      const tableName = 'test_schema_repair_target_status';
+      await createTestTable(tableName);
+
+      const field = createRealField('target001', 'Title', 'title_col')._unsafeUnwrap();
+      const table = createTableAggregate(tableName, field);
+      const repairer = createSchemaRepairer({
+        db,
+        introspector,
+        schema: TEST_SCHEMA,
+      });
+
+      const results = await collectFinalRepairResults(
+        repairer.repairRule(table, field.id().toString(), `column:${field.id().toString()}`, {
+          targetStatuses: ['warn'],
+        })
+      );
+
+      expect(results).toHaveLength(1);
+      expect(results[0].status).toBe('skipped');
+      expect(results[0].outcome).toBe('skipped');
+
+      const checker = createSchemaChecker({ db, introspector, schema: TEST_SCHEMA });
+      const checkResults = await collectFinalResults(
+        checker.checkField(table, field.id().toString())
+      );
+      expect(
+        checkResults.find((result) => result.ruleId === `column:${field.id().toString()}`)?.status
+      ).toBe('error');
+    });
+
+    it('should expose unrecoverable foreign key issues during check and skip repair', async () => {
+      const sourceTableName = 'test_schema_fk_unavailable_source';
+      const targetTableName = createValidTableId('tgt_fk_unavailable');
+      const fkColumnName = '__fk_unavailable_rule';
+
+      await createTestTable(sourceTableName, ['link_value JSONB', `"${fkColumnName}" TEXT`]);
+
+      const field = createRealLinkField({
+        id: 'fkunava1',
+        name: 'Unavailable FK Rule',
+        dbFieldName: 'link_value',
+        relationship: 'manyOne',
+        foreignTableId: targetTableName,
+        fkHostTableName: sourceTableName,
+        selfKeyName: '__id',
+        foreignKeyName: fkColumnName,
+        hasOrderColumn: false,
+      })._unsafeUnwrap();
+      const table = createTableAggregate(sourceTableName, field);
+
+      const checker = createSchemaChecker({ db, introspector, schema: TEST_SCHEMA });
+      const checkResults = await collectFinalResults(
+        checker.checkField(table, field.id().toString())
+      );
+      const checkResult = checkResults.find(
+        (result) => result.ruleId === `fk:${field.id().toString()}:${fkColumnName}`
+      );
+
+      expect(checkResult?.status).toBe('warn');
+      expect(checkResult?.repair).toEqual({
+        available: false,
+        mode: 'auto',
+        reason: {
+          key: 'table:table.integrity.v2.repairMeta.reason.foreignKeyTargetTableMissing',
+          values: {
+            fieldName: 'Unavailable FK Rule',
+            targetTableName: targetTableName,
+          },
+          fallback:
+            'Automatic repair is unavailable because the linked table for "Unavailable FK Rule" is missing.',
+        },
+        description: {
+          key: 'table:table.integrity.v2.repairMeta.description.foreignKeyTargetTableMissing',
+          values: {
+            fieldName: 'Unavailable FK Rule',
+            targetTableName: targetTableName,
+            targetPhysicalTableName: targetTableName,
+          },
+          fallback: `Check whether the linked table "${targetTableName}" was deleted or renamed. Recreate the table, or update/remove the link field configuration for "Unavailable FK Rule", then run the check again.`,
+        },
+      });
+
+      const repairer = createSchemaRepairer({ db, introspector, schema: TEST_SCHEMA });
+      const repairResults = await collectFinalRepairResults(
+        repairer.repairRule(
+          table,
+          field.id().toString(),
+          `fk:${field.id().toString()}:${fkColumnName}`
+        )
+      );
+      const repairResult = repairResults.find(
+        (result) => result.ruleId === `fk:${field.id().toString()}:${fkColumnName}`
+      );
+
+      expect(repairResult?.status).toBe('skipped');
+      expect(repairResult?.outcome).toBe('skipped');
+      expect(repairResult?.message).toBe('Skipped: repair unavailable');
+      expect(repairResult?.repair?.available).toBe(false);
+    });
+
     it('should repair generated-column metadata drift for stored columns', async () => {
       const tableName = 'test_schema_repair_generated_meta';
       await createTestTable(tableName, [
@@ -2766,5 +2971,552 @@ describe('Schema Rules Unit Tests with PGlite', () => {
       const repairedRule = repairedCheckResults.find((result) => result.ruleId === ruleId);
       expect(repairedRule?.status).toBe('success');
     });
+
+    describe('rule-specific auto repair coverage', () => {
+      it('should repair a missing system column through repairRule', async () => {
+        const tableName = 'test_schema_system_column_rule';
+        await createExplicitTestTable(tableName, [
+          '__id TEXT NOT NULL UNIQUE',
+          '__auto_number SERIAL PRIMARY KEY',
+          '__created_time TIMESTAMPTZ NOT NULL DEFAULT NOW()',
+          '__created_by TEXT NOT NULL',
+          '__last_modified_by TEXT',
+          '__version INTEGER NOT NULL',
+          'name_col TEXT',
+        ]);
+
+        const field = createRealField('syscol001', 'Name', 'name_col')._unsafeUnwrap();
+        const table = createTableAggregate(tableName, field);
+
+        await expectRuleRepairLifecycle({
+          table,
+          fieldId: SYSTEM_RULE_FIELD_ID,
+          ruleId: 'system_column:__last_modified_time',
+        });
+      });
+
+      it('should repair a missing system NOT NULL constraint through repairRule', async () => {
+        const tableName = 'test_schema_system_not_null_rule';
+        await createExplicitTestTable(tableName, [
+          '__id TEXT NOT NULL UNIQUE',
+          '__auto_number SERIAL PRIMARY KEY',
+          '__created_time TIMESTAMPTZ NOT NULL DEFAULT NOW()',
+          '__last_modified_time TIMESTAMPTZ',
+          '__created_by TEXT NOT NULL',
+          '__last_modified_by TEXT',
+          '__version INTEGER',
+          'name_col TEXT',
+        ]);
+
+        const field = createRealField('sysnn001', 'Name', 'name_col')._unsafeUnwrap();
+        const table = createTableAggregate(tableName, field);
+
+        await expectRuleRepairLifecycle({
+          table,
+          fieldId: SYSTEM_RULE_FIELD_ID,
+          ruleId: 'system_not_null:__version',
+        });
+      });
+
+      it('should repair a missing system default through repairRule', async () => {
+        const tableName = 'test_schema_system_default_rule';
+        await createExplicitTestTable(tableName, [
+          '__id TEXT NOT NULL UNIQUE',
+          '__auto_number SERIAL PRIMARY KEY',
+          '__created_time TIMESTAMPTZ NOT NULL',
+          '__last_modified_time TIMESTAMPTZ',
+          '__created_by TEXT NOT NULL',
+          '__last_modified_by TEXT',
+          '__version INTEGER NOT NULL',
+          'name_col TEXT',
+        ]);
+
+        const field = createRealField('sysdef001', 'Name', 'name_col')._unsafeUnwrap();
+        const table = createTableAggregate(tableName, field);
+
+        await expectRuleRepairLifecycle({
+          table,
+          fieldId: SYSTEM_RULE_FIELD_ID,
+          ruleId: 'system_default:__created_time',
+        });
+      });
+
+      it('should repair a missing optional column unique rule through repairRule', async () => {
+        const tableName = 'test_schema_column_unique_rule';
+        await createTestTable(tableName, ['email_col TEXT']);
+
+        const field = createRealField('coluniq01', 'Email', 'email_col', {
+          unique: true,
+        })._unsafeUnwrap();
+        const table = createTableAggregate(tableName, field);
+
+        await expectRuleRepairLifecycle({
+          table,
+          fieldId: field.id().toString(),
+          ruleId: `column_unique:${field.id().toString()}`,
+          expectedStatus: 'warn',
+        });
+      });
+
+      it('should repair a missing NOT NULL rule through repairRule', async () => {
+        const tableName = 'test_schema_not_null_rule';
+        await createTestTable(tableName, ['name_col TEXT']);
+
+        const field = createRealField('notnull01', 'Name', 'name_col', {
+          notNull: true,
+        })._unsafeUnwrap();
+        const table = createTableAggregate(tableName, field);
+
+        await expectRuleRepairLifecycle({
+          table,
+          fieldId: field.id().toString(),
+          ruleId: `not_null:${field.id().toString()}`,
+          expectedStatus: 'warn',
+        });
+      });
+
+      it('should repair a missing generated column through repairRule', async () => {
+        const tableName = 'test_schema_generated_column_rule';
+        await createTestTable(tableName, ['__created_time TIMESTAMPTZ DEFAULT NOW()']);
+
+        const field = createCreatedTimeFieldWithGeneratedMeta(
+          'gencol01',
+          'CreatedTime',
+          'created_time_col',
+          true
+        )._unsafeUnwrap();
+        const table = createTableAggregate(tableName, field);
+
+        await sql`INSERT INTO field (id, name, meta) VALUES (${field.id().toString()}, 'CreatedTime', '{}') ON CONFLICT (id) DO NOTHING`.execute(
+          db
+        );
+
+        await expectRuleRepairLifecycle({
+          table,
+          fieldId: field.id().toString(),
+          ruleId: `generated_column:${field.id().toString()}`,
+        });
+      });
+
+      it('should repair a missing link value column through repairRule', async () => {
+        const sourceTableName = createValidTableId('src_link_value_rule');
+        const targetTableName = createValidTableId('tgt_link_value_rule');
+
+        await createTestTable(sourceTableName);
+        await createTestTable(targetTableName);
+
+        const field = createRealLinkField({
+          id: 'lnkval001',
+          name: 'Link Value Rule',
+          dbFieldName: 'link_value',
+          relationship: 'oneMany',
+          foreignTableId: targetTableName,
+          fkHostTableName: 'junction_link_value_rule',
+          selfKeyName: '__fk_link_value_self',
+          foreignKeyName: '__fk_link_value_foreign',
+          isOneWay: true,
+          hasOrderColumn: false,
+        })._unsafeUnwrap();
+        const table = createTableAggregate(sourceTableName, field);
+
+        await expectRuleRepairLifecycle({
+          table,
+          fieldId: field.id().toString(),
+          ruleId: `link_value_column:${field.id().toString()}`,
+        });
+      });
+
+      it('should repair a missing foreign key column through repairRule', async () => {
+        const sourceTableName = createValidTableId('src_fk_column_rule');
+        const targetTableName = createValidTableId('tgt_fk_column_rule');
+        const fkColumnName = '__fk_column_rule';
+
+        await createTestTable(targetTableName);
+        await createTestTable(sourceTableName, ['link_value JSONB']);
+        await sql
+          .raw(
+            `
+            INSERT INTO ${TEST_SCHEMA}.${sourceTableName} (__id, link_value)
+            VALUES ('rec_source_a', '{"id":"rec_target_a","title":"Target A"}'::jsonb)
+          `
+          )
+          .execute(db);
+        await sql
+          .raw(
+            `
+            INSERT INTO ${TEST_SCHEMA}.${targetTableName} (__id)
+            VALUES ('rec_target_a')
+          `
+          )
+          .execute(db);
+
+        const field = createRealLinkField({
+          id: 'fkcol001',
+          name: 'FK Column Rule',
+          dbFieldName: 'link_value',
+          relationship: 'manyOne',
+          foreignTableId: targetTableName,
+          fkHostTableName: sourceTableName,
+          selfKeyName: '__id',
+          foreignKeyName: fkColumnName,
+          hasOrderColumn: false,
+        })._unsafeUnwrap();
+        const table = createTableAggregate(sourceTableName, field);
+
+        await expectRuleRepairLifecycle({
+          table,
+          fieldId: field.id().toString(),
+          ruleId: `fk_column:${field.id().toString()}`,
+          expectedStatus: 'warn',
+          verifyAfterRepair: async () => {
+            const rows = await sql<{ fk_value: string | null }>`
+              SELECT ${sql.id(fkColumnName)} AS fk_value
+              FROM ${sql.id(TEST_SCHEMA)}.${sql.id(sourceTableName)}
+              WHERE __id = 'rec_source_a'
+            `.execute(db);
+
+            expect(rows.rows[0]?.fk_value).toBe('rec_target_a');
+          },
+        });
+      });
+
+      it('should repair a missing index rule through repairRule', async () => {
+        const sourceTableName = createValidTableId('src_index_rule');
+        const targetTableName = createValidTableId('tgt_index_rule');
+        const fkColumnName = '__fk_index_rule';
+
+        await createTestTable(targetTableName);
+        await createTestTable(sourceTableName, ['link_value JSONB', `"${fkColumnName}" TEXT`]);
+
+        const field = createRealLinkField({
+          id: 'index001',
+          name: 'Index Rule',
+          dbFieldName: 'link_value',
+          relationship: 'manyOne',
+          foreignTableId: targetTableName,
+          fkHostTableName: sourceTableName,
+          selfKeyName: '__id',
+          foreignKeyName: fkColumnName,
+          hasOrderColumn: false,
+        })._unsafeUnwrap();
+        const table = createTableAggregate(sourceTableName, field);
+
+        await expectRuleRepairLifecycle({
+          table,
+          fieldId: field.id().toString(),
+          ruleId: `index:${field.id().toString()}:${fkColumnName}`,
+          expectedStatus: 'warn',
+        });
+      });
+
+      it('should repair a missing unique index rule through repairRule', async () => {
+        const sourceTableName = createValidTableId('src_unique_index_rule');
+        const targetTableName = createValidTableId('tgt_unique_index_rule');
+        const fkColumnName = '__fk_unique_index_rule';
+
+        await createTestTable(targetTableName);
+        await createTestTable(sourceTableName, ['link_value JSONB', `"${fkColumnName}" TEXT`]);
+
+        const field = createRealLinkField({
+          id: 'uidxrl01',
+          name: 'Unique Index Rule',
+          dbFieldName: 'link_value',
+          relationship: 'oneOne',
+          foreignTableId: targetTableName,
+          fkHostTableName: sourceTableName,
+          selfKeyName: '__id',
+          foreignKeyName: fkColumnName,
+          hasOrderColumn: false,
+        })._unsafeUnwrap();
+        const table = createTableAggregate(sourceTableName, field);
+
+        await expectRuleRepairLifecycle({
+          table,
+          fieldId: field.id().toString(),
+          ruleId: `unique_index:${field.id().toString()}:${fkColumnName}`,
+          expectedStatus: 'warn',
+        });
+      });
+
+      it('should repair a missing foreign key constraint rule through repairRule', async () => {
+        const sourceTableName = createValidTableId('src_foreign_key_rule');
+        const targetTableName = createValidTableId('tgt_foreign_key_rule');
+        const fkColumnName = '__fk_foreign_key_rule';
+
+        await createTestTable(targetTableName);
+        await createTestTable(sourceTableName, ['link_value JSONB', `"${fkColumnName}" TEXT`]);
+
+        const field = createRealLinkField({
+          id: 'fkcnst01',
+          name: 'Foreign Key Rule',
+          dbFieldName: 'link_value',
+          relationship: 'manyOne',
+          foreignTableId: targetTableName,
+          fkHostTableName: sourceTableName,
+          selfKeyName: '__id',
+          foreignKeyName: fkColumnName,
+          hasOrderColumn: false,
+        })._unsafeUnwrap();
+        const table = createTableAggregate(sourceTableName, field);
+
+        await expectRuleRepairLifecycle({
+          table,
+          fieldId: field.id().toString(),
+          ruleId: `fk:${field.id().toString()}:${fkColumnName}`,
+          expectedStatus: 'warn',
+        });
+      });
+
+      it('should repair a missing order column rule through repairRule', async () => {
+        const sourceTableName = createValidTableId('src_order_rule');
+        const targetTableName = createValidTableId('tgt_order_rule');
+        const fkColumnName = '__fk_order_rule';
+        const orderColumnName = '__fk_order_rule_order';
+
+        await createTestTable(targetTableName);
+        await createTestTable(sourceTableName, ['link_value JSONB', `"${fkColumnName}" TEXT`]);
+
+        const field = createRealLinkField({
+          id: 'order001',
+          name: 'Order Rule',
+          dbFieldName: 'link_value',
+          relationship: 'manyOne',
+          foreignTableId: targetTableName,
+          fkHostTableName: sourceTableName,
+          selfKeyName: '__id',
+          foreignKeyName: fkColumnName,
+          hasOrderColumn: true,
+        })._unsafeUnwrap();
+        const table = createTableAggregate(sourceTableName, field);
+
+        await expectRuleRepairLifecycle({
+          table,
+          fieldId: field.id().toString(),
+          ruleId: `order_column:${field.id().toString()}`,
+          verifyAfterRepair: async () => {
+            const column = await introspector.getColumn(
+              TEST_SCHEMA,
+              sourceTableName,
+              orderColumnName
+            );
+            expect(column._unsafeUnwrap()).toBeTruthy();
+          },
+        });
+      });
+
+      it('should repair missing field metadata through repairRule', async () => {
+        const sourceTableName = createValidTableId('src_field_meta_rule');
+        const targetTableName = createValidTableId('tgt_field_meta_rule');
+        const fkColumnName = '__fk_field_meta_rule';
+        const orderColumnName = '__fk_field_meta_rule_order';
+
+        await createTestTable(targetTableName);
+        await createTestTable(sourceTableName, [
+          'link_value JSONB',
+          `"${fkColumnName}" TEXT`,
+          `"${orderColumnName}" DOUBLE PRECISION`,
+        ]);
+
+        const field = createRealLinkField({
+          id: 'fldmeta01',
+          name: 'Field Meta Rule',
+          dbFieldName: 'link_value',
+          relationship: 'manyOne',
+          foreignTableId: targetTableName,
+          fkHostTableName: sourceTableName,
+          selfKeyName: '__id',
+          foreignKeyName: fkColumnName,
+          hasOrderColumn: true,
+        })._unsafeUnwrap();
+        const table = createTableAggregate(sourceTableName, field);
+
+        await sql`INSERT INTO field (id, name, meta) VALUES (${field.id().toString()}, 'Field Meta Rule', '{}') ON CONFLICT (id) DO UPDATE SET meta = '{}'::jsonb`.execute(
+          db
+        );
+
+        await expectRuleRepairLifecycle({
+          table,
+          fieldId: field.id().toString(),
+          ruleId: `field_meta:${field.id().toString()}`,
+          verifyAfterRepair: async () => {
+            const record = await sql<{ meta: Record<string, unknown> }>`
+              SELECT meta
+              FROM field
+              WHERE id = ${field.id().toString()}
+            `.execute(db);
+
+            expect(record.rows[0]?.meta).toMatchObject({ hasOrderColumn: true });
+          },
+        });
+      });
+
+      it('should repair a missing junction table unique rule through repairRule', async () => {
+        const sourceTableName = createValidTableId('src_junction_unique_rule');
+        const targetTableName = createValidTableId('tgt_junction_unique_rule');
+        const junctionTableName = 'junction_unique_rule';
+        const selfKeyName = '__fk_junction_unique_self';
+        const foreignKeyName = '__fk_junction_unique_foreign';
+
+        await createTestTable(sourceTableName, ['link_value JSONB']);
+        await createTestTable(targetTableName);
+        await createExplicitTestTable(junctionTableName, [
+          '__id SERIAL PRIMARY KEY',
+          `${selfKeyName} TEXT`,
+          `${foreignKeyName} TEXT`,
+        ]);
+        await sql
+          .raw(
+            `ALTER TABLE ${TEST_SCHEMA}.${junctionTableName}
+             ADD CONSTRAINT fk_${selfKeyName}
+             FOREIGN KEY (${selfKeyName}) REFERENCES ${TEST_SCHEMA}.${sourceTableName}(__id) ON DELETE CASCADE`
+          )
+          .execute(db);
+        await sql
+          .raw(
+            `ALTER TABLE ${TEST_SCHEMA}.${junctionTableName}
+             ADD CONSTRAINT fk_${foreignKeyName}
+             FOREIGN KEY (${foreignKeyName}) REFERENCES ${TEST_SCHEMA}.${targetTableName}(__id) ON DELETE CASCADE`
+          )
+          .execute(db);
+
+        const field = createRealLinkField({
+          id: 'jctuniq01',
+          name: 'Junction Unique Rule',
+          dbFieldName: 'link_value',
+          relationship: 'oneMany',
+          foreignTableId: targetTableName,
+          fkHostTableName: junctionTableName,
+          selfKeyName,
+          foreignKeyName,
+          isOneWay: true,
+          hasOrderColumn: false,
+        })._unsafeUnwrap();
+        const table = createTableAggregate(sourceTableName, field);
+
+        await expectRuleRepairLifecycle({
+          table,
+          fieldId: field.id().toString(),
+          ruleId: `junction_unique:${field.id().toString()}`,
+          expectedStatus: 'warn',
+        });
+      });
+
+      it('should repair a missing junction index rule through repairRule', async () => {
+        const sourceTableName = createValidTableId('src_junction_index_rule');
+        const targetTableName = createValidTableId('tgt_junction_index_rule');
+        const junctionTableName = 'junction_index_rule';
+        const selfKeyName = '__fk_junction_index_self';
+        const foreignKeyName = '__fk_junction_index_foreign';
+
+        await createTestTable(sourceTableName, ['link_value JSONB']);
+        await createTestTable(targetTableName);
+        await createExplicitTestTable(junctionTableName, [
+          '__id SERIAL PRIMARY KEY',
+          `${selfKeyName} TEXT`,
+          `${foreignKeyName} TEXT`,
+          '__order DOUBLE PRECISION',
+        ]);
+        await sql
+          .raw(
+            `ALTER TABLE ${TEST_SCHEMA}.${junctionTableName}
+             ADD CONSTRAINT uniq_${selfKeyName}_${foreignKeyName} UNIQUE (${selfKeyName}, ${foreignKeyName})`
+          )
+          .execute(db);
+        await sql
+          .raw(
+            `ALTER TABLE ${TEST_SCHEMA}.${junctionTableName}
+             ADD CONSTRAINT fk_${selfKeyName}
+             FOREIGN KEY (${selfKeyName}) REFERENCES ${TEST_SCHEMA}.${sourceTableName}(__id) ON DELETE CASCADE`
+          )
+          .execute(db);
+        await sql
+          .raw(
+            `ALTER TABLE ${TEST_SCHEMA}.${junctionTableName}
+             ADD CONSTRAINT fk_${foreignKeyName}
+             FOREIGN KEY (${foreignKeyName}) REFERENCES ${TEST_SCHEMA}.${targetTableName}(__id) ON DELETE CASCADE`
+          )
+          .execute(db);
+
+        const field = createRealLinkField({
+          id: 'jctidx001',
+          name: 'Junction Index Rule',
+          dbFieldName: 'link_value',
+          relationship: 'manyMany',
+          foreignTableId: targetTableName,
+          fkHostTableName: junctionTableName,
+          selfKeyName,
+          foreignKeyName,
+          hasOrderColumn: true,
+        })._unsafeUnwrap();
+        const table = createTableAggregate(sourceTableName, field);
+
+        await expectRuleRepairLifecycle({
+          table,
+          fieldId: field.id().toString(),
+          ruleId: `junction_index:${field.id().toString()}:self`,
+          expectedStatus: 'warn',
+        });
+      });
+
+      it('should repair a missing junction foreign key rule through repairRule', async () => {
+        const sourceTableName = createValidTableId('src_junction_fk_rule');
+        const targetTableName = createValidTableId('tgt_junction_fk_rule');
+        const junctionTableName = 'junction_fk_rule';
+        const selfKeyName = '__fk_junction_fk_self';
+        const foreignKeyName = '__fk_junction_fk_foreign';
+
+        await createTestTable(sourceTableName, ['link_value JSONB']);
+        await createTestTable(targetTableName);
+        await createExplicitTestTable(junctionTableName, [
+          '__id SERIAL PRIMARY KEY',
+          `${selfKeyName} TEXT`,
+          `${foreignKeyName} TEXT`,
+          '__order DOUBLE PRECISION',
+        ]);
+        await sql
+          .raw(
+            `ALTER TABLE ${TEST_SCHEMA}.${junctionTableName}
+             ADD CONSTRAINT uniq_${selfKeyName}_${foreignKeyName} UNIQUE (${selfKeyName}, ${foreignKeyName})`
+          )
+          .execute(db);
+        await sql
+          .raw(
+            `CREATE INDEX index_${selfKeyName} ON ${TEST_SCHEMA}.${junctionTableName}(${selfKeyName})`
+          )
+          .execute(db);
+        await sql
+          .raw(
+            `CREATE INDEX index_${foreignKeyName} ON ${TEST_SCHEMA}.${junctionTableName}(${foreignKeyName})`
+          )
+          .execute(db);
+        await sql
+          .raw(
+            `ALTER TABLE ${TEST_SCHEMA}.${junctionTableName}
+             ADD CONSTRAINT fk_${foreignKeyName}
+             FOREIGN KEY (${foreignKeyName}) REFERENCES ${TEST_SCHEMA}.${targetTableName}(__id) ON DELETE CASCADE`
+          )
+          .execute(db);
+
+        const field = createRealLinkField({
+          id: 'jctfk001',
+          name: 'Junction Foreign Key Rule',
+          dbFieldName: 'link_value',
+          relationship: 'manyMany',
+          foreignTableId: targetTableName,
+          fkHostTableName: junctionTableName,
+          selfKeyName,
+          foreignKeyName,
+          hasOrderColumn: true,
+        })._unsafeUnwrap();
+        const table = createTableAggregate(sourceTableName, field);
+
+        await expectRuleRepairLifecycle({
+          table,
+          fieldId: field.id().toString(),
+          ruleId: `junction_fk:${field.id().toString()}:self`,
+          expectedStatus: 'warn',
+        });
+      });
+    });
   });
 });
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/index.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/index.ts
index 800f326dc0..19ac720d7b 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/index.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/index.ts
@@ -11,7 +11,12 @@ export {
 } from './context';
 
 // Core interfaces
-export type { ISchemaRule, SchemaRuleValidationResult, TableSchemaStatementBuilder } from './core';
+export type {
+  ISchemaRule,
+  SchemaRuleRepairHint,
+  SchemaRuleValidationResult,
+  TableSchemaStatementBuilder,
+} from './core';
 
 // Field rules
 export {
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/repairer/SchemaRepairResult.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/repairer/SchemaRepairResult.ts
index 2715ff87c7..3e625568cc 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/repairer/SchemaRepairResult.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/repairer/SchemaRepairResult.ts
@@ -1,10 +1,14 @@
+import type { SchemaRuleDetailItem, SchemaRuleRepairHint } from '../core/ISchemaRule';
+
 export type SchemaRepairStatus = 'success' | 'error' | 'warn' | 'pending' | 'running' | 'skipped';
 
 export type SchemaRepairOutcome = 'repaired' | 'unchanged' | 'manual' | 'skipped';
 
 export interface SchemaRepairDetails {
   missing?: ReadonlyArray<string>;
+  missingItems?: ReadonlyArray<SchemaRuleDetailItem>;
   extra?: ReadonlyArray<string>;
+  extraItems?: ReadonlyArray<SchemaRuleDetailItem>;
   statementCount?: number;
 }
 
@@ -18,6 +22,7 @@ export interface SchemaRepairResult {
   outcome?: SchemaRepairOutcome;
   message?: string;
   details?: SchemaRepairDetails;
+  repair?: SchemaRuleRepairHint;
   required: boolean;
   timestamp: number;
   dependencies: ReadonlyArray<string>;
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/repairer/SchemaRepairer.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/repairer/SchemaRepairer.ts
index ea9b8751ca..0ed3f6abac 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/repairer/SchemaRepairer.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/repairer/SchemaRepairer.ts
@@ -1,6 +1,7 @@
 import type { Table } from '@teable/v2-core';
 
 import { executeTableSchemaStatements } from '../../../shared/db';
+import { getRuleRepairHint } from '../core/RuleRepairMetadata';
 import {
   createSchemaRulePlanner,
   getSchemaRulePlanningStageDescription,
@@ -20,6 +21,7 @@ export interface SchemaRepairerParams extends SchemaRulePlannerParams {}
 
 export interface SchemaRepairOptions {
   readonly dryRun?: boolean;
+  readonly targetStatuses?: ReadonlyArray<'warn' | 'error'>;
 }
 
 export class SchemaRepairer {
@@ -110,6 +112,14 @@ export class SchemaRepairer {
         yield runningResult(pending);
 
         try {
+          const currentStatus: 'warn' | 'error' = rule.required ? 'error' : 'warn';
+
+          if (options?.targetStatuses?.length && !options.targetStatuses.includes(currentStatus)) {
+            yield skippedResult(pending, 'Skipped: status not selected for repair');
+            repairedRules.set(rule.id, false);
+            continue;
+          }
+
           const validationResult = await rule.isValid(ctx);
           if (validationResult.isErr()) {
             yield errorResult(pending, validationResult.error.message);
@@ -126,36 +136,61 @@ export class SchemaRepairer {
 
           const details = {
             missing: validation.missing,
+            missingItems: validation.missingItems,
             extra: validation.extra,
+            extraItems: validation.extraItems,
           };
+          const repairResult = getRuleRepairHint(rule, ctx, validation);
+          const repair = repairResult.isOk() ? repairResult.value : undefined;
 
           if (rule.repairMode === 'manual') {
-            yield warnResult(pending, 'Rule requires manual repair', 'manual', details);
+            yield {
+              ...warnResult(pending, 'Rule requires manual repair', 'manual', details),
+              repair,
+            };
+            repairedRules.set(rule.id, false);
+            continue;
+          }
+
+          if (repair && !repair.available && repair.mode === 'auto') {
+            yield {
+              ...skippedResult(pending, 'Skipped: repair unavailable', details),
+              repair,
+            };
             repairedRules.set(rule.id, false);
             continue;
           }
 
           const statementsResult = rule.up(ctx);
           if (statementsResult.isErr()) {
-            yield errorResult(pending, statementsResult.error.message, details);
+            yield {
+              ...errorResult(pending, statementsResult.error.message, details),
+              repair,
+            };
             repairedRules.set(rule.id, false);
             continue;
           }
 
           const statements = statementsResult.value;
           if (statements.length === 0) {
-            yield warnResult(pending, 'No repair statements available', 'manual', details);
+            yield {
+              ...warnResult(pending, 'No repair statements available', 'manual', details),
+              repair,
+            };
             repairedRules.set(rule.id, false);
             continue;
           }
 
           if (options?.dryRun) {
-            yield successResult(
-              pending,
-              `Dry run: ${statements.length} statements ready`,
-              'repaired',
-              { ...details, statementCount: statements.length }
-            );
+            yield {
+              ...successResult(
+                pending,
+                `Dry run: ${statements.length} statements ready`,
+                'repaired',
+                { ...details, statementCount: statements.length }
+              ),
+              repair,
+            };
             repairedRules.set(rule.id, true);
             continue;
           }
@@ -164,33 +199,47 @@ export class SchemaRepairer {
 
           const revalidationResult = await rule.isValid(ctx);
           if (revalidationResult.isErr()) {
-            yield errorResult(pending, revalidationResult.error.message, {
-              ...details,
-              statementCount: statements.length,
-            });
+            yield {
+              ...errorResult(pending, revalidationResult.error.message, {
+                ...details,
+                statementCount: statements.length,
+              }),
+              repair,
+            };
             repairedRules.set(rule.id, false);
             continue;
           }
 
           if (!revalidationResult.value.valid) {
-            yield errorResult(pending, 'Repair executed but schema is still invalid', {
-              missing: revalidationResult.value.missing,
-              extra: revalidationResult.value.extra,
-              statementCount: statements.length,
-            });
+            yield {
+              ...errorResult(pending, 'Repair executed but schema is still invalid', {
+                missing: revalidationResult.value.missing,
+                missingItems: revalidationResult.value.missingItems,
+                extra: revalidationResult.value.extra,
+                extraItems: revalidationResult.value.extraItems,
+                statementCount: statements.length,
+              }),
+              repair,
+            };
             repairedRules.set(rule.id, false);
             continue;
           }
 
-          yield successResult(pending, 'Schema repaired successfully', 'repaired', {
-            statementCount: statements.length,
-          });
+          yield {
+            ...successResult(pending, 'Schema repaired successfully', 'repaired', {
+              statementCount: statements.length,
+            }),
+            repair,
+          };
           repairedRules.set(rule.id, true);
         } catch (error) {
-          yield errorResult(
-            pending,
-            error instanceof Error ? error.message : 'Unknown error during repair'
-          );
+          yield {
+            ...errorResult(
+              pending,
+              error instanceof Error ? error.message : 'Unknown error during repair'
+            ),
+            repair: undefined,
+          };
           repairedRules.set(rule.id, false);
         }
       }
diff --git a/packages/v2/contract-http/src/table/dto.ts b/packages/v2/contract-http/src/table/dto.ts
index 0e16655c63..c19e217069 100644
--- a/packages/v2/contract-http/src/table/dto.ts
+++ b/packages/v2/contract-http/src/table/dto.ts
@@ -254,12 +254,19 @@ const buttonWorkflowSchema = z.object({
   isActive: z.boolean().optional(),
 });
 
+const buttonConfirmSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  confirmText: z.string().optional(),
+});
+
 const buttonOptionsSchema = z.object({
   label: z.string().optional(),
   color: fieldColorSchema.optional(),
   maxCount: z.number().optional(),
   resetCount: z.boolean().optional(),
   workflow: buttonWorkflowSchema.optional().nullable(),
+  confirm: buttonConfirmSchema.optional().nullable(),
 });
 
 const cellValueTypeSchema = z.enum(['string', 'number', 'boolean', 'dateTime']);
@@ -780,12 +787,14 @@ class FieldToDtoVisitor implements IFieldVisitor<IFieldDto> {
     const maxCount = field.maxCount();
     const resetCount = field.resetCount();
     const workflow = field.workflow();
+    const confirm = field.confirm();
     const options: ButtonOptionsDto = {
       label: field.label().toString(),
       color: field.color().toString() as ButtonOptionsDto['color'],
       ...(maxCount ? { maxCount: maxCount.toNumber() } : {}),
       ...(resetCount ? { resetCount: resetCount.toBoolean() } : {}),
       ...(workflow ? { workflow: workflow.toDto() } : {}),
+      ...(confirm ? { confirm: confirm.toDto() } : {}),
     };
 
     return ok({
diff --git a/packages/v2/contract-http/src/table/mapTableDtoToDomain.ts b/packages/v2/contract-http/src/table/mapTableDtoToDomain.ts
index 6fcba9787c..d106e5c718 100644
--- a/packages/v2/contract-http/src/table/mapTableDtoToDomain.ts
+++ b/packages/v2/contract-http/src/table/mapTableDtoToDomain.ts
@@ -1,5 +1,6 @@
 import {
   BaseId,
+  ButtonConfirm,
   ButtonLabel,
   ButtonMaxCount,
   ButtonResetCount,
@@ -399,15 +400,18 @@ const mapBaseFieldDtoToDomain = (
             optional(options?.maxCount, ButtonMaxCount.create).andThen((maxCount) =>
               optional(options?.resetCount, ButtonResetCount.create).andThen((resetCount) =>
                 workflowResult.andThen((workflow) =>
-                  createButtonField({
-                    id,
-                    name,
-                    label,
-                    color,
-                    maxCount,
-                    resetCount,
-                    workflow,
-                  })
+                  optional(options?.confirm, ButtonConfirm.create).andThen((confirm) =>
+                    createButtonField({
+                      id,
+                      name,
+                      label,
+                      color,
+                      maxCount,
+                      resetCount,
+                      workflow,
+                      confirm,
+                    })
+                  )
                 )
               )
             )
diff --git a/packages/v2/core/src/application/services/RecordMutationSpecResolverService.ts b/packages/v2/core/src/application/services/RecordMutationSpecResolverService.ts
index 81494677f1..bc73639abf 100644
--- a/packages/v2/core/src/application/services/RecordMutationSpecResolverService.ts
+++ b/packages/v2/core/src/application/services/RecordMutationSpecResolverService.ts
@@ -10,6 +10,7 @@ import type {
 } from '../../domain/table/records/specs/values/ICellValueSpecVisitor';
 import { SetAttachmentValueSpec } from '../../domain/table/records/specs/values/SetAttachmentValueSpec';
 import { SetLinkValueByTitleSpec } from '../../domain/table/records/specs/values/SetLinkValueByTitleSpec';
+import { SetLinkValueSpec } from '../../domain/table/records/specs/values/SetLinkValueSpec';
 import { SetRowOrderValueSpec } from '../../domain/table/records/specs/values/SetRowOrderValueSpec';
 import { SetUserValueByIdentifierSpec } from '../../domain/table/records/specs/values/SetUserValueByIdentifierSpec';
 import { SetUserValueSpec } from '../../domain/table/records/specs/values/SetUserValueSpec';
@@ -65,7 +66,7 @@ class SpecResolutionCollector implements ICellValueSpecVisitor {
   visitSetDateValue(): Result<void, DomainError> {
     return ok(undefined);
   }
-  visitSetLinkValue(): Result<void, DomainError> {
+  visitSetLinkValue(_spec: SetLinkValueSpec): Result<void, DomainError> {
     return ok(undefined);
   }
   visitSetRowOrderValue(_spec: SetRowOrderValueSpec): Result<void, DomainError> {
diff --git a/packages/v2/core/src/application/services/RecordWritePluginRunner.ts b/packages/v2/core/src/application/services/RecordWritePluginRunner.ts
index ebad77333f..5a3ae82241 100644
--- a/packages/v2/core/src/application/services/RecordWritePluginRunner.ts
+++ b/packages/v2/core/src/application/services/RecordWritePluginRunner.ts
@@ -5,8 +5,8 @@ import type { Result } from 'neverthrow';
 import { domainError, type DomainError } from '../../domain/shared/DomainError';
 import { composeAndSpecsOrUndefined } from '../../domain/shared/specification/composeAndSpecs';
 import type { ISpecification } from '../../domain/shared/specification/ISpecification';
-import type { TableRecord } from '../../domain/table/records/TableRecord';
 import type { ITableRecordConditionSpecVisitor } from '../../domain/table/records/specs/ITableRecordConditionSpecVisitor';
+import type { TableRecord } from '../../domain/table/records/TableRecord';
 import type { IExecutionContext } from '../../ports/ExecutionContext';
 import * as LoggerPort from '../../ports/Logger';
 import * as TableMapperPort from '../../ports/mappers/TableMapper';
@@ -14,6 +14,7 @@ import type {
   IRecordWritePlugin,
   RecordWritePluginContext,
   RecordWritePluginEnforce,
+  RecordWriteScopedFieldIdsResolver,
   RecordWritePluginScope,
 } from '../../ports/RecordWritePlugin';
 import { v2CoreTokens } from '../../ports/tokens';
@@ -142,6 +143,38 @@ const withRecordWritePluginTraceContext = (
   };
 };
 
+const intersectDefinedSets = (
+  sets: ReadonlyArray<ReadonlySet<string> | undefined>
+): ReadonlySet<string> | undefined => {
+  const definedSets = sets.filter((set): set is ReadonlySet<string> => set != null);
+  if (!definedSets.length) {
+    return undefined;
+  }
+
+  const [firstSet, ...restSets] = definedSets;
+  return new Set([...firstSet].filter((value) => restSets.every((set) => set.has(value))));
+};
+
+const composeUpdateFieldResolvers = (
+  resolvers: ReadonlyArray<RecordWriteScopedFieldIdsResolver | undefined>,
+  staticFieldIds: ReadonlySet<string> | undefined
+): RecordWriteScopedFieldIdsResolver | undefined => {
+  const definedResolvers = resolvers.filter(
+    (resolver): resolver is RecordWriteScopedFieldIdsResolver => resolver != null
+  );
+
+  if (!definedResolvers.length && !staticFieldIds) {
+    return undefined;
+  }
+
+  return (record) => {
+    const dynamicFieldIds = intersectDefinedSets(
+      definedResolvers.map((resolver) => resolver(record))
+    );
+    return intersectDefinedSets([staticFieldIds, dynamicFieldIds]);
+  };
+};
+
 const withRecordWritePluginSpan = async <T>(
   context: RecordWritePluginContext,
   pluginName: string,
@@ -183,10 +216,7 @@ export class RecordWritePluginExecution {
     return this.runPhase('guard', this.context);
   }
 
-  getRecordSpec(): Result<
-    ISpecification<TableRecord, ITableRecordConditionSpecVisitor> | undefined,
-    DomainError
-  > {
+  getScope(): Result<RecordWritePluginScope | undefined, DomainError> {
     const specs = this.preparedPlugins
       .map((entry) => entry.scope?.recordSpec)
       .filter(
@@ -194,7 +224,41 @@ export class RecordWritePluginExecution {
           spec != null
       );
 
-    return ok(composeAndSpecsOrUndefined(specs));
+    const recordSpec = composeAndSpecsOrUndefined(specs);
+    const updateFieldIds = intersectDefinedSets(
+      this.preparedPlugins.map((entry) => entry.scope?.updateFieldIds)
+    );
+    const createFieldIds = intersectDefinedSets(
+      this.preparedPlugins.map((entry) => entry.scope?.createFieldIds)
+    );
+    const resolveUpdateFieldIdsForRecord = composeUpdateFieldResolvers(
+      this.preparedPlugins.map((entry) => entry.scope?.resolveUpdateFieldIdsForRecord),
+      updateFieldIds
+    );
+
+    if (!recordSpec && !updateFieldIds && !createFieldIds && !resolveUpdateFieldIdsForRecord) {
+      return ok(undefined);
+    }
+
+    return ok({
+      ...(recordSpec ? { recordSpec } : {}),
+      ...(updateFieldIds ? { updateFieldIds } : {}),
+      ...(createFieldIds ? { createFieldIds } : {}),
+      ...(resolveUpdateFieldIdsForRecord ? { resolveUpdateFieldIdsForRecord } : {}),
+    });
+  }
+
+  getRecordSpec(): Result<
+    ISpecification<TableRecord, ITableRecordConditionSpecVisitor> | undefined,
+    DomainError
+  > {
+    return this.getScope().map((scope) => scope?.recordSpec);
+  }
+
+  getUpdateFieldIdsForRecord(
+    record: TableRecord
+  ): Result<ReadonlySet<string> | undefined, DomainError> {
+    return this.getScope().map((scope) => scope?.resolveUpdateFieldIdsForRecord?.(record));
   }
 
   async beforePersist(executionContext: IExecutionContext): Promise<Result<void, DomainError>> {
diff --git a/packages/v2/core/src/commands/ClearHandler.spec.ts b/packages/v2/core/src/commands/ClearHandler.spec.ts
index 1bb57c8bf7..eeaacb5c47 100644
--- a/packages/v2/core/src/commands/ClearHandler.spec.ts
+++ b/packages/v2/core/src/commands/ClearHandler.spec.ts
@@ -25,8 +25,8 @@ import { TableName } from '../domain/table/TableName';
 import type { TableSortKey } from '../domain/table/TableSortKey';
 import type { IEventBus } from '../ports/EventBus';
 import type { IExecutionContext, IUnitOfWorkTransaction } from '../ports/ExecutionContext';
-import type { IFindOptions } from '../ports/RepositoryQuery';
 import { RecordWriteOperationKind } from '../ports/RecordWritePlugin';
+import type { IFindOptions } from '../ports/RepositoryQuery';
 import type {
   ITableRecordQueryRepository,
   ITableRecordQueryStreamOptions,
@@ -45,7 +45,6 @@ import { ClearHandler } from './ClearHandler';
 import {
   createRecordWritePluginRunner,
   createTrackedRecordWritePlugin,
-  expectRecordWritePluginToBeSkipped,
 } from './recordWritePluginRunnerTestUtils';
 
 const createContext = (): IExecutionContext => {
@@ -376,6 +375,135 @@ describe('ClearHandler', () => {
     expect(event!.updates[0]?.newVersion).toBe(existingVersion + 1);
   });
 
+  it('trims clear targets to plugin-scoped update fields', async () => {
+    const { table, tableId, firstFieldId, secondFieldId } = buildProjectionTable();
+    const viewId = table.views()[0]!.id();
+
+    const tableRepository = new FakeTableRepository();
+    tableRepository.tables.push(table);
+    const tableQueryService = new TableQueryService(tableRepository);
+
+    const recordQueryRepository = new FakeTableRecordQueryRepository();
+    recordQueryRepository.records = [
+      {
+        id: `rec${'m'.repeat(16)}`,
+        version: 1,
+        fields: {
+          [firstFieldId.toString()]: 100,
+          [secondFieldId.toString()]: 200,
+        },
+      },
+    ];
+
+    const recordRepository = new FakeTableRecordRepository();
+    const handler = new ClearHandler(
+      tableQueryService,
+      createRecordWritePluginRunner([
+        {
+          name: 'scope-update-fields',
+          supports: (operation) => operation === RecordWriteOperationKind.updateMany,
+          scope: async () => ok({ updateFieldIds: new Set([firstFieldId.toString()]) }),
+          guard: async () => ok(undefined),
+        },
+      ]),
+      recordRepository,
+      recordQueryRepository,
+      new FakeEventBus(),
+      noopUndoRedoService,
+      new FakeUnitOfWork()
+    );
+
+    const command = ClearCommand.create({
+      tableId: tableId.toString(),
+      viewId: viewId.toString(),
+      ranges: [
+        [0, 0],
+        [1, 0],
+      ],
+    })._unsafeUnwrap();
+
+    const result = await handler.handle(createContext(), command);
+
+    expect(result.isOk()).toBe(true);
+    expect(result._unsafeUnwrap().updatedCount).toBe(1);
+    const updated = recordRepository.updatedRecords[0]!;
+    expect(updated.fields().get(firstFieldId)?.toValue()).toBeNull();
+    expect(updated.fields().get(secondFieldId)).toBeUndefined();
+  });
+
+  it('trims clear targets per record when plugin field scope varies by record', async () => {
+    const { table, tableId, firstFieldId, secondFieldId } = buildProjectionTable();
+    const viewId = table.views()[0]!.id();
+
+    const tableRepository = new FakeTableRepository();
+    tableRepository.tables.push(table);
+    const tableQueryService = new TableQueryService(tableRepository);
+
+    const recordQueryRepository = new FakeTableRecordQueryRepository();
+    recordQueryRepository.records = [
+      {
+        id: `rec${'x'.repeat(16)}`,
+        version: 1,
+        fields: {
+          [firstFieldId.toString()]: 100,
+          [secondFieldId.toString()]: 200,
+        },
+      },
+      {
+        id: `rec${'y'.repeat(16)}`,
+        version: 1,
+        fields: {
+          [firstFieldId.toString()]: 300,
+          [secondFieldId.toString()]: 400,
+        },
+      },
+    ];
+
+    const recordRepository = new FakeTableRecordRepository();
+    const handler = new ClearHandler(
+      tableQueryService,
+      createRecordWritePluginRunner([
+        {
+          name: 'scope-update-fields-per-record',
+          supports: (operation) => operation === RecordWriteOperationKind.updateMany,
+          scope: async () =>
+            ok({
+              updateFieldIds: new Set([firstFieldId.toString(), secondFieldId.toString()]),
+              resolveUpdateFieldIdsForRecord: (record) =>
+                record.fields().get(firstFieldId)?.toValue() === 100
+                  ? new Set([firstFieldId.toString()])
+                  : new Set([secondFieldId.toString()]),
+            }),
+          guard: async () => ok(undefined),
+        },
+      ]),
+      recordRepository,
+      recordQueryRepository,
+      new FakeEventBus(),
+      noopUndoRedoService,
+      new FakeUnitOfWork()
+    );
+
+    const command = ClearCommand.create({
+      tableId: tableId.toString(),
+      viewId: viewId.toString(),
+      ranges: [
+        [0, 0],
+        [1, 1],
+      ],
+    })._unsafeUnwrap();
+
+    const result = await handler.handle(createContext(), command);
+
+    expect(result.isOk()).toBe(true);
+    expect(result._unsafeUnwrap().updatedCount).toBe(2);
+    expect(recordRepository.updatedRecords).toHaveLength(2);
+    expect(recordRepository.updatedRecords[0]?.fields().get(firstFieldId)?.toValue()).toBeNull();
+    expect(recordRepository.updatedRecords[0]?.fields().get(secondFieldId)).toBeUndefined();
+    expect(recordRepository.updatedRecords[1]?.fields().get(firstFieldId)).toBeUndefined();
+    expect(recordRepository.updatedRecords[1]?.fields().get(secondFieldId)?.toValue()).toBeNull();
+  });
+
   it('skips plugins that do not support updateMany', async () => {
     const { table, tableId, primaryFieldId } = buildTable();
     const viewId = table.views()[0]!.id();
@@ -421,7 +549,14 @@ describe('ClearHandler', () => {
     const result = await handler.handle(createContext(), command);
     result._unsafeUnwrap();
 
-    expectRecordWritePluginToBeSkipped(calls, RecordWriteOperationKind.updateMany);
+    expect(calls.supports).toEqual([
+      RecordWriteOperationKind.updateMany,
+      RecordWriteOperationKind.updateMany,
+    ]);
+    expect(calls.prepare).toHaveLength(0);
+    expect(calls.guard).toHaveLength(0);
+    expect(calls.beforePersist).toHaveLength(0);
+    expect(calls.afterCommit).toHaveLength(0);
   });
 
   it('returns 0 when only computed columns are selected', async () => {
diff --git a/packages/v2/core/src/commands/ClearHandler.ts b/packages/v2/core/src/commands/ClearHandler.ts
index ca004b5bde..65553a1817 100644
--- a/packages/v2/core/src/commands/ClearHandler.ts
+++ b/packages/v2/core/src/commands/ClearHandler.ts
@@ -40,6 +40,18 @@ import {
   resolveGroupByToOrderBy,
   resolveOrderBy,
 } from './shared/orderBy';
+import { toTableRecord } from './shared/toTableRecord';
+
+const filterScopedFieldIds = <T extends { toString(): string }>(
+  fieldIds: ReadonlyArray<T>,
+  allowedFieldIds: ReadonlySet<string> | undefined
+): T[] => {
+  if (!allowedFieldIds) {
+    return [...fieldIds];
+  }
+
+  return fieldIds.filter((fieldId) => allowedFieldIds.has(fieldId.toString()));
+};
 
 export interface ClearResult {
   /** Number of records updated (cleared) */
@@ -149,6 +161,55 @@ export class ClearHandler implements ICommandHandler<ClearCommand, ClearResult>
         return ok({ updatedCount: 0 });
       }
 
+      const initialClearedFieldValues = new Map<string, unknown>();
+      for (const fieldId of editableFieldIds) {
+        initialClearedFieldValues.set(fieldId.toString(), null);
+      }
+      const initialPluginExecution = yield* await handler.recordWritePluginRunner.prepare({
+        kind: RecordWriteOperationKind.updateMany,
+        executionContext: context,
+        table,
+        payload: {
+          variant: 'selector',
+          fieldValues: initialClearedFieldValues,
+          fieldKeyType: FieldKeyType.Id,
+          typecast: false,
+          recordIds: [],
+          recordCount: 0,
+        },
+        isTransactionBound: false,
+      });
+      const pluginScope = yield* initialPluginExecution.getScope();
+      const scopedEditableFieldIds = filterScopedFieldIds(
+        editableFieldIds,
+        pluginScope?.updateFieldIds
+      );
+      const pluginRecordSpec = pluginScope?.recordSpec;
+
+      const clearedFieldValues = new Map<string, unknown>();
+      for (const fieldId of scopedEditableFieldIds) {
+        clearedFieldValues.set(fieldId.toString(), null);
+      }
+
+      if (scopedEditableFieldIds.length === 0) {
+        const pluginExecution = yield* await handler.recordWritePluginRunner.prepare({
+          kind: RecordWriteOperationKind.updateMany,
+          executionContext: context,
+          table,
+          payload: {
+            variant: 'selector',
+            fieldValues: clearedFieldValues,
+            fieldKeyType: FieldKeyType.Id,
+            typecast: false,
+            recordIds: [],
+            recordCount: 0,
+          },
+          isTransactionBound: false,
+        });
+        yield* await pluginExecution.guard();
+        return ok({ updatedCount: 0 });
+      }
+
       // 8. Build orderBy from group + sort for correct row mapping
       // If none provided, fall back to view row order column (__row_{viewId})
       const effectiveGroup = command.ignoreViewQuery
@@ -185,12 +246,30 @@ export class ClearHandler implements ICommandHandler<ClearCommand, ClearResult>
         }
 
         const record = recordResult.value;
+        let tableRecord: TableRecord | undefined;
+        if (pluginRecordSpec || pluginScope?.resolveUpdateFieldIdsForRecord) {
+          tableRecord = yield* toTableRecord(table, record);
+        }
+        if (pluginRecordSpec && tableRecord && !pluginRecordSpec.isSatisfiedBy(tableRecord)) {
+          continue;
+        }
         const recordId = yield* RecordId.create(record.id);
         const fieldValues = new Map<string, unknown>();
         const changes: RecordFieldChangeDTO[] = [];
 
         let hasNonNullValue = false;
-        for (const fieldId of editableFieldIds) {
+        const perRecordAllowedFieldIds = tableRecord
+          ? yield* initialPluginExecution.getUpdateFieldIdsForRecord(tableRecord)
+          : undefined;
+        const recordScopedEditableFieldIds = filterScopedFieldIds(
+          scopedEditableFieldIds,
+          perRecordAllowedFieldIds
+        );
+        if (recordScopedEditableFieldIds.length === 0) {
+          continue;
+        }
+
+        for (const fieldId of recordScopedEditableFieldIds) {
           const fieldIdStr = fieldId.toString();
           const oldValue = record.fields[fieldIdStr];
           if (oldValue !== null && oldValue !== undefined) {
@@ -213,12 +292,23 @@ export class ClearHandler implements ICommandHandler<ClearCommand, ClearResult>
       }
 
       if (updateItems.length === 0) {
+        const pluginExecution = yield* await handler.recordWritePluginRunner.prepare({
+          kind: RecordWriteOperationKind.updateMany,
+          executionContext: context,
+          table,
+          payload: {
+            variant: 'selector',
+            fieldValues: clearedFieldValues,
+            fieldKeyType: FieldKeyType.Id,
+            typecast: false,
+            recordIds: [],
+            recordCount: 0,
+          },
+          isTransactionBound: false,
+        });
+        yield* await pluginExecution.guard();
         return ok({ updatedCount: 0 });
       }
-      const clearedFieldValues = new Map<string, unknown>();
-      for (const fieldId of editableFieldIds) {
-        clearedFieldValues.set(fieldId.toString(), null);
-      }
       const pluginExecution = yield* await handler.recordWritePluginRunner.prepare({
         kind: RecordWriteOperationKind.updateMany,
         executionContext: context,
diff --git a/packages/v2/core/src/commands/CreateRecordsHandler.ts b/packages/v2/core/src/commands/CreateRecordsHandler.ts
index e505b8c4cd..be9ca288e6 100644
--- a/packages/v2/core/src/commands/CreateRecordsHandler.ts
+++ b/packages/v2/core/src/commands/CreateRecordsHandler.ts
@@ -204,7 +204,10 @@ export class CreateRecordsHandler
               transactionContext,
               tableForCreate,
               records,
-              command.order ? { order: command.order } : undefined
+              {
+                ...(command.order ? { order: command.order } : {}),
+                fillLinkTitles: command.typecast,
+              }
             );
             return ok({ mutation, tableEvents });
           });
diff --git a/packages/v2/core/src/commands/DuplicateRecordHandler.spec.ts b/packages/v2/core/src/commands/DuplicateRecordHandler.spec.ts
index bc6d32d261..4d5e5f2f66 100644
--- a/packages/v2/core/src/commands/DuplicateRecordHandler.spec.ts
+++ b/packages/v2/core/src/commands/DuplicateRecordHandler.spec.ts
@@ -516,6 +516,72 @@ describe('DuplicateRecordHandler', () => {
     expect(numberValue).toBe(42);
   });
 
+  it('trims duplicate fields to the plugin create scope', async () => {
+    const { table, textFieldId, numberFieldId } = createTestTable(baseId, tableId);
+
+    const tableRepository = new FakeTableRepository();
+    tableRepository.tables.push(table);
+    const tableQueryService = new TableQueryService(tableRepository);
+    const recordRepository = new FakeTableRecordRepository();
+    const recordQueryRepository = new FakeTableRecordQueryRepository();
+    const eventBus = new FakeEventBus();
+    const unitOfWork = new FakeUnitOfWork();
+
+    recordQueryRepository.records.set(sourceRecordId, {
+      id: sourceRecordId,
+      fields: {
+        [textFieldId]: 'Visible value',
+        [numberFieldId]: 42,
+      },
+      version: 1,
+    });
+
+    const plugin = {
+      name: 'duplicate-create-scope',
+      supports(operation: RecordWriteOperationKind) {
+        return operation === RecordWriteOperationKind.duplicate;
+      },
+      async prepare() {
+        return ok({});
+      },
+      scope() {
+        return ok({
+          createFieldIds: new Set([textFieldId]),
+        });
+      },
+      async guard(context) {
+        expect([...context.payload.fieldValues.keys()]).toEqual([textFieldId]);
+        return ok(undefined);
+      },
+    };
+
+    const handler = new DuplicateRecordHandler(
+      tableQueryService,
+      recordRepository,
+      recordQueryRepository,
+      createFakeRecordMutationSpecResolverService(),
+      createRecordWritePluginRunner([plugin]),
+      new RecordWriteSideEffectService(),
+      createTableUpdateFlow(tableRepository, eventBus, unitOfWork),
+      eventBus,
+      noopUndoRedoService,
+      unitOfWork
+    );
+
+    const command = DuplicateRecordCommand.create({
+      tableId,
+      recordId: sourceRecordId,
+    })._unsafeUnwrap();
+
+    const result = await handler.handle(createContext(), command);
+    const { record } = result._unsafeUnwrap();
+
+    expect(record.fields().get(FieldId.create(textFieldId)._unsafeUnwrap())?.toValue()).toBe(
+      'Visible value'
+    );
+    expect(record.fields().get(FieldId.create(numberFieldId)._unsafeUnwrap())).toBeUndefined();
+  });
+
   it('duplicates record when source date field value is a Date instance', async () => {
     const { table, textFieldId, dateFieldId } = createTestTable(baseId, tableId);
 
diff --git a/packages/v2/core/src/commands/DuplicateRecordHandler.ts b/packages/v2/core/src/commands/DuplicateRecordHandler.ts
index 629915e284..fb436b1ad1 100644
--- a/packages/v2/core/src/commands/DuplicateRecordHandler.ts
+++ b/packages/v2/core/src/commands/DuplicateRecordHandler.ts
@@ -4,6 +4,7 @@ import type { Result } from 'neverthrow';
 
 import { FieldKeyResolverService } from '../application/services/FieldKeyResolverService';
 import { RecordMutationSpecResolverService } from '../application/services/RecordMutationSpecResolverService';
+import type { RecordWritePluginExecution } from '../application/services/RecordWritePluginRunner';
 import { RecordWritePluginRunner } from '../application/services/RecordWritePluginRunner';
 import { RecordWriteSideEffectService } from '../application/services/RecordWriteSideEffectService';
 import { TableQueryService } from '../application/services/TableQueryService';
@@ -17,6 +18,7 @@ import type { TableRecord } from '../domain/table/records/TableRecord';
 import * as EventBusPort from '../ports/EventBus';
 import * as ExecutionContextPort from '../ports/ExecutionContext';
 import { RecordWriteOperationKind } from '../ports/RecordWritePlugin';
+import type { RecordWriteFieldValues } from '../ports/RecordWritePlugin';
 import * as TableRecordQueryRepositoryPort from '../ports/TableRecordQueryRepository';
 import type { RecordMutationResult } from '../ports/TableRecordRepository';
 import * as TableRecordRepositoryPort from '../ports/TableRecordRepository';
@@ -73,6 +75,22 @@ export class DuplicateRecordHandler
     private readonly unitOfWork: UnitOfWorkPort.IUnitOfWork
   ) {}
 
+  private filterFieldValuesByCreateScope(
+    pluginExecution: RecordWritePluginExecution,
+    fieldValues: RecordWriteFieldValues
+  ): Result<RecordWriteFieldValues, DomainError> {
+    return pluginExecution.getScope().map((scope) => {
+      const createFieldIds = scope?.createFieldIds;
+      if (!createFieldIds) {
+        return fieldValues;
+      }
+
+      return new Map(
+        [...fieldValues].filter(([fieldId]) => createFieldIds.has(fieldId))
+      ) as RecordWriteFieldValues;
+    });
+  }
+
   @TraceSpan()
   async handle(
     context: ExecutionContextPort.IExecutionContext,
@@ -112,7 +130,7 @@ export class DuplicateRecordHandler
           fieldValues.set(fieldId, value);
         }
       }
-      const pluginExecution = yield* await handler.recordWritePluginRunner.prepare({
+      const duplicatePluginContext = {
         kind: RecordWriteOperationKind.duplicate,
         executionContext: context,
         table,
@@ -123,7 +141,29 @@ export class DuplicateRecordHandler
           recordCount: 1,
         },
         isTransactionBound: false,
-      });
+      } as const;
+      const initialPluginExecution =
+        yield* await handler.recordWritePluginRunner.prepare(duplicatePluginContext);
+      const scopedFieldValues = yield* handler.filterFieldValuesByCreateScope(
+        initialPluginExecution,
+        fieldValues
+      );
+      const pluginExecution =
+        scopedFieldValues.size === fieldValues.size
+          ? initialPluginExecution
+          : yield* await handler.recordWritePluginRunner.prepare({
+              ...duplicatePluginContext,
+              payload: {
+                ...duplicatePluginContext.payload,
+                fieldValues: scopedFieldValues,
+              },
+            });
+      if (scopedFieldValues !== fieldValues) {
+        fieldValues.clear();
+        for (const [fieldId, value] of scopedFieldValues) {
+          fieldValues.set(fieldId, value);
+        }
+      }
       yield* await pluginExecution.guard();
 
       // 4. Execute side effects on field values
diff --git a/packages/v2/core/src/commands/PasteHandler.spec.ts b/packages/v2/core/src/commands/PasteHandler.spec.ts
index 3c461ed558..c9191fce7d 100644
--- a/packages/v2/core/src/commands/PasteHandler.spec.ts
+++ b/packages/v2/core/src/commands/PasteHandler.spec.ts
@@ -18,13 +18,13 @@ import { FieldOptionsAdded } from '../domain/table/events/FieldOptionsAdded';
 import { RecordsBatchUpdated } from '../domain/table/events/RecordsBatchUpdated';
 import { FieldId } from '../domain/table/fields/FieldId';
 import { FieldName } from '../domain/table/fields/FieldName';
+import { FieldType } from '../domain/table/fields/FieldType';
 import { CellValueMultiplicity } from '../domain/table/fields/types/CellValueMultiplicity';
 import { CellValueType } from '../domain/table/fields/types/CellValueType';
 import { FormulaExpression } from '../domain/table/fields/types/FormulaExpression';
 import { LinkFieldConfig } from '../domain/table/fields/types/LinkFieldConfig';
 import { SelectOption } from '../domain/table/fields/types/SelectOption';
-import { UserField } from '../domain/table/fields/types/UserField';
-import { FieldType } from '../domain/table/fields/FieldType';
+import type { UserField } from '../domain/table/fields/types/UserField';
 import type { RecordId } from '../domain/table/records/RecordId';
 import type { RecordUpdateResult } from '../domain/table/records/RecordUpdateResult';
 import type { ITableRecordConditionSpecVisitor } from '../domain/table/records/specs/ITableRecordConditionSpecVisitor';
@@ -54,19 +54,18 @@ import type {
   TableUpdatePersistResult,
 } from '../ports/TableRepository';
 import type { ITableSchemaRepository } from '../ports/TableSchemaRepository';
-import type { IUnitOfWork, UnitOfWorkOperation } from '../ports/UnitOfWork';
 import {
   createUndoRedoCommand,
   flattenUndoRedoCommands,
   type UndoRedoApplyFieldSnapshotCommandData,
   type UndoRedoDeleteFieldCommandData,
 } from '../ports/UndoRedoStore';
+import type { IUnitOfWork, UnitOfWorkOperation } from '../ports/UnitOfWork';
 import { PasteCommand } from './PasteCommand';
 import { PasteHandler } from './PasteHandler';
 import {
   createRecordWritePluginRunner,
   createTrackedRecordWritePlugin,
-  expectRecordWritePluginToBeSkipped,
 } from './recordWritePluginRunnerTestUtils';
 
 const createContext = (): IExecutionContext => {
@@ -1482,7 +1481,13 @@ describe('PasteHandler', () => {
 
       const result = await handler.handle(createContext(), command._unsafeUnwrap());
       expect(result.isOk()).toBe(true);
-      expect(executionOrder).toEqual(['prepare:0', 'beforePersist:0', 'ddl', 'insert']);
+      expect(executionOrder).toEqual([
+        'prepare:0',
+        'prepare:0',
+        'beforePersist:0',
+        'ddl',
+        'insert',
+      ]);
       expect(beforePersistFieldCount).toBe(2);
       expect(insertedFieldCount).toBe(3);
     });
@@ -1754,6 +1759,180 @@ describe('PasteHandler', () => {
     });
   });
 
+  it('trims paste update and create fields from plugin scope independently', async () => {
+    const { table, tableId, textFieldId, numberFieldId } = buildTable();
+    const viewId = table.views()[0]!.id();
+
+    const tableRepository = new FakeTableRepository();
+    tableRepository.tables.push(table);
+    const tableQueryService = new TableQueryService(tableRepository);
+
+    const recordQueryRepository = new FakeTableRecordQueryRepository();
+    recordQueryRepository.records = [
+      {
+        id: `rec${'p'.repeat(16)}`,
+        version: 1,
+        fields: {
+          [textFieldId.toString()]: 'old-title',
+          [numberFieldId.toString()]: 1,
+        },
+      },
+    ];
+
+    const recordRepository = new FakeTableRecordRepository();
+    const eventBus = new FakeEventBus();
+    const unitOfWork = new FakeUnitOfWork();
+
+    const handler = new PasteHandler(
+      tableQueryService,
+      createTableUpdateFlow(tableRepository, eventBus, unitOfWork),
+      new FakeFieldCreationSideEffectService() as never,
+      new FakeForeignTableLoaderService() as never,
+      recordRepository,
+      recordQueryRepository,
+      new FakeRecordMutationSpecResolverService() as unknown as RecordMutationSpecResolverService,
+      noopPasteLinkAutoResolveService,
+      new RecordWriteSideEffectService(),
+      noopRecordWriteUndoRedoPlanService,
+      createRecordWritePluginRunner([
+        {
+          name: 'paste-scope-fields',
+          supports: (operation) => operation === RecordWriteOperationKind.paste,
+          scope: async () =>
+            ok({
+              updateFieldIds: new Set([textFieldId.toString()]),
+              createFieldIds: new Set([numberFieldId.toString()]),
+            }),
+          guard: async () => ok(undefined),
+        },
+      ]),
+      eventBus,
+      noopUndoRedoService,
+      unitOfWork
+    );
+
+    const command = PasteCommand.create({
+      tableId: tableId.toString(),
+      viewId: viewId.toString(),
+      ranges: [
+        [0, 0],
+        [1, 1],
+      ],
+      content: [
+        ['new-title', 99],
+        ['created-title', 123],
+      ],
+    })._unsafeUnwrap();
+
+    const result = await handler.handle(createContext(), command);
+
+    expect(result.isOk()).toBe(true);
+    expect(result._unsafeUnwrap()).toMatchObject({
+      updatedCount: 1,
+      createdCount: 1,
+    });
+    expect(recordRepository.updated).toHaveLength(1);
+    expect(recordRepository.inserted).toHaveLength(1);
+    expect(recordRepository.updated[0]?.record.fields().get(textFieldId)?.toValue()).toBe(
+      'new-title'
+    );
+    expect(recordRepository.updated[0]?.record.fields().get(numberFieldId)).toBeUndefined();
+    expect(recordRepository.inserted[0]?.fields().get(textFieldId)).toBeUndefined();
+    expect(recordRepository.inserted[0]?.fields().get(numberFieldId)?.toValue()).toBe(123);
+  });
+
+  it('trims paste update fields per record when plugin field scope varies by record', async () => {
+    const { table, tableId, textFieldId, numberFieldId } = buildTable();
+    const viewId = table.views()[0]!.id();
+
+    const tableRepository = new FakeTableRepository();
+    tableRepository.tables.push(table);
+    const tableQueryService = new TableQueryService(tableRepository);
+
+    const recordQueryRepository = new FakeTableRecordQueryRepository();
+    recordQueryRepository.records = [
+      {
+        id: `rec${'a'.repeat(16)}`,
+        version: 1,
+        fields: {
+          [textFieldId.toString()]: 'row-1',
+          [numberFieldId.toString()]: 1,
+        },
+      },
+      {
+        id: `rec${'b'.repeat(16)}`,
+        version: 1,
+        fields: {
+          [textFieldId.toString()]: 'row-2',
+          [numberFieldId.toString()]: 2,
+        },
+      },
+    ];
+
+    const recordRepository = new FakeTableRecordRepository();
+    const eventBus = new FakeEventBus();
+    const unitOfWork = new FakeUnitOfWork();
+
+    const handler = new PasteHandler(
+      tableQueryService,
+      createTableUpdateFlow(tableRepository, eventBus, unitOfWork),
+      new FakeFieldCreationSideEffectService() as never,
+      new FakeForeignTableLoaderService() as never,
+      recordRepository,
+      recordQueryRepository,
+      new FakeRecordMutationSpecResolverService() as unknown as RecordMutationSpecResolverService,
+      noopPasteLinkAutoResolveService,
+      new RecordWriteSideEffectService(),
+      noopRecordWriteUndoRedoPlanService,
+      createRecordWritePluginRunner([
+        {
+          name: 'paste-scope-fields-per-record',
+          supports: (operation) => operation === RecordWriteOperationKind.paste,
+          scope: async () =>
+            ok({
+              updateFieldIds: new Set([textFieldId.toString(), numberFieldId.toString()]),
+              resolveUpdateFieldIdsForRecord: (record) =>
+                record.fields().get(textFieldId)?.toValue() === 'row-1'
+                  ? new Set([textFieldId.toString()])
+                  : new Set([numberFieldId.toString()]),
+            }),
+          guard: async () => ok(undefined),
+        },
+      ]),
+      eventBus,
+      noopUndoRedoService,
+      unitOfWork
+    );
+
+    const command = PasteCommand.create({
+      tableId: tableId.toString(),
+      viewId: viewId.toString(),
+      ranges: [
+        [0, 0],
+        [1, 1],
+      ],
+      content: [
+        ['updated-row-1', 11],
+        ['updated-row-2', 22],
+      ],
+    })._unsafeUnwrap();
+
+    const result = await handler.handle(createContext(), command);
+
+    expect(result.isOk()).toBe(true);
+    expect(result._unsafeUnwrap()).toMatchObject({
+      updatedCount: 2,
+      createdCount: 0,
+    });
+    expect(recordRepository.updated).toHaveLength(2);
+    expect(recordRepository.updated[0]?.record.fields().get(textFieldId)?.toValue()).toBe(
+      'updated-row-1'
+    );
+    expect(recordRepository.updated[0]?.record.fields().get(numberFieldId)).toBeUndefined();
+    expect(recordRepository.updated[1]?.record.fields().get(textFieldId)).toBeUndefined();
+    expect(recordRepository.updated[1]?.record.fields().get(numberFieldId)?.toValue()).toBe(22);
+  });
+
   it('skips plugins that do not support paste', async () => {
     const { table, tableId } = buildTable();
     const viewId = table.views()[0]!.id();
@@ -1799,7 +1978,14 @@ describe('PasteHandler', () => {
     const result = await handler.handle(createContext(), command);
     result._unsafeUnwrap();
 
-    expectRecordWritePluginToBeSkipped(calls, RecordWriteOperationKind.paste);
+    expect(calls.supports).toEqual([
+      RecordWriteOperationKind.paste,
+      RecordWriteOperationKind.paste,
+    ]);
+    expect(calls.prepare).toHaveLength(0);
+    expect(calls.guard).toHaveLength(0);
+    expect(calls.beforePersist).toHaveLength(0);
+    expect(calls.afterCommit).toHaveLength(0);
   });
 
   it('rejects when a plugin blocks paste', async () => {
diff --git a/packages/v2/core/src/commands/PasteHandler.ts b/packages/v2/core/src/commands/PasteHandler.ts
index 0396dcfebc..23bdbe8d22 100644
--- a/packages/v2/core/src/commands/PasteHandler.ts
+++ b/packages/v2/core/src/commands/PasteHandler.ts
@@ -128,6 +128,11 @@ interface UpdateOperation {
   type: 'update';
   existingRecord: TableRecordReadModel;
   rowData: ReadonlyArray<unknown>;
+  /**
+   * Per-record editable columns after plugin scoping. `undefined` means this
+   * operation still uses the shared update column set for the paste request.
+   */
+  editableColumns?: ReadonlyArray<EditableColumn>;
 }
 
 /** Represents a create operation for a new record */
@@ -158,6 +163,7 @@ type PendingCreatedRecord = {
 
 type PasteOperationStreamState = {
   iterator: AsyncIterator<Result<PasteOperation, DomainError>>;
+  pendingUpdateOperation?: UpdateOperation;
   pendingCreateOperation?: CreateOperation;
   tableForMutations: Table;
   accumulatedSideEffects: RecordWriteSideEffect[];
@@ -362,19 +368,56 @@ export class PasteHandler implements ICommandHandler<PasteCommand, PasteResult>
         updateFilterSpec
       );
       const collectedOperations = yield* await handler.collectPasteOperations(operationsStream);
-      const pluginExecution = yield* await handler.recordWritePluginRunner.prepare({
+      const initialPluginExecution = yield* await handler.recordWritePluginRunner.prepare({
         kind: RecordWriteOperationKind.paste,
         executionContext: context,
         table: persistedTable,
         payload: yield* handler.buildPastePluginPayload(
           command.typecast,
           editableColumns,
+          editableColumns,
           collectedOperations.updateOperations,
           collectedOperations.createOperations
         ),
         isTransactionBound: false,
       });
+      const pluginScope = yield* initialPluginExecution.getScope();
+      const expandedFieldIds = new Set(
+        plannedColumnExpansion?.newFieldIds.map((fieldId) => fieldId.toString()) ?? []
+      );
+      const scopedUpdateOperations = yield* handler.scopeUpdateOperations(
+        persistedTable,
+        collectedOperations.updateOperations,
+        editableColumns,
+        pluginScope?.recordSpec,
+        initialPluginExecution,
+        expandedFieldIds
+      );
+      const scopedCreateColumns = handler.filterCreateColumns(
+        editableColumns,
+        pluginScope?.createFieldIds,
+        expandedFieldIds
+      );
+      const pluginExecution = yield* await handler.recordWritePluginRunner.prepare({
+        kind: RecordWriteOperationKind.paste,
+        executionContext: context,
+        table: persistedTable,
+        payload: yield* handler.buildPastePluginPayload(
+          command.typecast,
+          editableColumns,
+          scopedCreateColumns,
+          scopedUpdateOperations,
+          collectedOperations.createOperations
+        ),
+        isTransactionBound: false,
+      });
       yield* await pluginExecution.guard();
+      const executableUpdateOperations = scopedUpdateOperations;
+      const executableCreateOperations =
+        scopedCreateColumns.length > 0 ? collectedOperations.createOperations : [];
+      if (executableUpdateOperations.length === 0 && executableCreateOperations.length === 0) {
+        return ok({ updatedCount: 0, createdCount: 0, createdRecordIds: [] });
+      }
 
       // 12. Execute paste within transaction
       const eventData: CollectedEventData = {
@@ -390,11 +433,12 @@ export class PasteHandler implements ICommandHandler<PasteCommand, PasteResult>
         return handler.executePasteStream(
           txContext,
           tableForPaste,
-          collectedOperations.updateOperations,
-          collectedOperations.createOperations,
+          executableUpdateOperations,
+          executableCreateOperations,
           pluginExecution,
           command.typecast,
           editableColumns,
+          scopedCreateColumns,
           eventData,
           plannedColumnExpansion
         );
@@ -756,6 +800,7 @@ export class PasteHandler implements ICommandHandler<PasteCommand, PasteResult>
           type: 'update' as const,
           existingRecord: readModel,
           rowData: content[rowIndex]!,
+          editableColumns: undefined,
         });
       }
       // Always increment rowIndex to consume the content row (even if skipping update)
@@ -792,9 +837,87 @@ export class PasteHandler implements ICommandHandler<PasteCommand, PasteResult>
     return ok({ updateOperations, createOperations });
   }
 
+  private filterUpdateColumns(
+    editableColumns: ReadonlyArray<EditableColumn>,
+    allowedFieldIds: ReadonlySet<string> | undefined,
+    extraAllowedFieldIds: ReadonlySet<string>
+  ): ReadonlyArray<EditableColumn> {
+    if (!allowedFieldIds) {
+      return editableColumns;
+    }
+
+    return editableColumns.filter((column) => {
+      const fieldId = column.fieldId.toString();
+      return allowedFieldIds.has(fieldId) || extraAllowedFieldIds.has(fieldId);
+    });
+  }
+
+  private filterCreateColumns(
+    editableColumns: ReadonlyArray<EditableColumn>,
+    allowedFieldIds: ReadonlySet<string> | undefined,
+    extraAllowedFieldIds: ReadonlySet<string>
+  ): ReadonlyArray<EditableColumn> {
+    if (!allowedFieldIds) {
+      return editableColumns;
+    }
+
+    if (allowedFieldIds.size === 0) {
+      return [];
+    }
+
+    return editableColumns.filter((column) => {
+      const fieldId = column.fieldId.toString();
+      return allowedFieldIds.has(fieldId) || extraAllowedFieldIds.has(fieldId);
+    });
+  }
+
+  private scopeUpdateOperations(
+    table: Table,
+    updateOperations: ReadonlyArray<UpdateOperation>,
+    editableColumns: ReadonlyArray<EditableColumn>,
+    recordSpec: ISpecification<TableRecord, ITableRecordConditionSpecVisitor> | undefined,
+    pluginExecution: RecordWritePluginExecution,
+    extraAllowedFieldIds: ReadonlySet<string>
+  ): Result<ReadonlyArray<UpdateOperation>, DomainError> {
+    const authorizedOperations: UpdateOperation[] = [];
+    for (const operation of updateOperations) {
+      const tableRecord = toTableRecord(table, operation.existingRecord);
+      if (tableRecord.isErr()) {
+        return err(tableRecord.error);
+      }
+      if (recordSpec && !recordSpec.isSatisfiedBy(tableRecord.value)) {
+        continue;
+      }
+
+      const allowedFieldIdsResult = pluginExecution.getUpdateFieldIdsForRecord(tableRecord.value);
+      if (allowedFieldIdsResult.isErr()) {
+        return err(allowedFieldIdsResult.error);
+      }
+
+      const operationEditableColumns = this.filterUpdateColumns(
+        editableColumns,
+        allowedFieldIdsResult.value,
+        extraAllowedFieldIds
+      );
+      if (!operationEditableColumns.length) {
+        continue;
+      }
+
+      authorizedOperations.push({
+        ...operation,
+        editableColumns: operationEditableColumns,
+      });
+    }
+
+    return ok(authorizedOperations);
+  }
+
   private buildPastePluginPayload(
     typecast: boolean,
-    editableColumns: ReadonlyArray<EditableColumn>,
+    // Columns shared by the entire update side of the paste request before per-record scoping.
+    updateColumns: ReadonlyArray<EditableColumn>,
+    // Columns that remain createable after plugin scoping and field expansion allowances.
+    createColumns: ReadonlyArray<EditableColumn>,
     updateOperations: ReadonlyArray<UpdateOperation>,
     createOperations: ReadonlyArray<CreateOperation>
   ): Result<
@@ -819,15 +942,28 @@ export class PasteHandler implements ICommandHandler<PasteCommand, PasteResult>
         return err(recordIdResult.error);
       }
       updateRecordIds.push(recordIdResult.value);
-      updateRecordsFieldValues.push(this.rowDataToFieldValues(operation.rowData, editableColumns));
+      const operationEditableColumns = operation.editableColumns ?? updateColumns;
+      updateRecordsFieldValues.push(
+        this.rowDataToFieldValues(operation.rowData, operationEditableColumns)
+      );
+    }
+
+    const editableFieldIds = new Map<string, FieldId>();
+    for (const operation of updateOperations) {
+      for (const column of operation.editableColumns ?? updateColumns) {
+        editableFieldIds.set(column.fieldId.toString(), column.fieldId);
+      }
+    }
+    for (const column of createColumns) {
+      editableFieldIds.set(column.fieldId.toString(), column.fieldId);
     }
 
     return ok({
-      editableFieldIds: editableColumns.map((column) => column.fieldId),
+      editableFieldIds: [...editableFieldIds.values()],
       updateRecordIds,
       updateRecordsFieldValues,
       createRecordsFieldValues: createOperations.map((operation) =>
-        this.rowDataToFieldValues(operation.rowData, editableColumns)
+        this.rowDataToFieldValues(operation.rowData, createColumns)
       ),
       typecast,
       updateRecordCount: updateOperations.length,
@@ -858,7 +994,8 @@ export class PasteHandler implements ICommandHandler<PasteCommand, PasteResult>
     createOperations: ReadonlyArray<CreateOperation>,
     pluginExecution: RecordWritePluginExecution,
     typecast: boolean,
-    editableColumns: ReadonlyArray<EditableColumn>,
+    updateColumns: ReadonlyArray<EditableColumn>,
+    createColumns: ReadonlyArray<EditableColumn>,
     eventData: CollectedEventData,
     plannedColumnExpansion?: PlannedColumnExpansion
   ): Promise<Result<void, DomainError>> {
@@ -926,7 +1063,7 @@ export class PasteHandler implements ICommandHandler<PasteCommand, PasteResult>
               context,
               streamState,
               typecast,
-              editableColumns,
+              updateColumns,
               batchSize,
               eventData
             )
@@ -953,7 +1090,7 @@ export class PasteHandler implements ICommandHandler<PasteCommand, PasteResult>
               context,
               streamState,
               typecast,
-              editableColumns,
+              createColumns,
               batchSize,
               createdRecordBatches,
               eventData
@@ -1022,13 +1159,14 @@ export class PasteHandler implements ICommandHandler<PasteCommand, PasteResult>
       if (!updateOperations) {
         return;
       }
+      const batchEditableColumns = updateOperations[0]?.editableColumns ?? editableColumns;
 
       const sideEffectResult = await this.prepareMutationChunk(
         context,
         streamState,
         updateOperations,
         typecast,
-        editableColumns,
+        batchEditableColumns,
         eventData
       );
       if (sideEffectResult.isErr()) {
@@ -1041,7 +1179,7 @@ export class PasteHandler implements ICommandHandler<PasteCommand, PasteResult>
         context,
         typecast,
         batchTable,
-        editableColumns,
+        batchEditableColumns,
         updateOperations.map((operation) => operation.rowData),
         streamState.resolvedLinkValues
       );
@@ -1059,7 +1197,7 @@ export class PasteHandler implements ICommandHandler<PasteCommand, PasteResult>
       eventData.afterCommitHandlers.push(...resolvedLinkValueMapResult.value.afterCommitHandlers);
 
       const linkTitleMapResult = typecast
-        ? await this.buildLinkTitleMap(context, batchTable, editableColumns, updateOperations)
+        ? await this.buildLinkTitleMap(context, batchTable, batchEditableColumns, updateOperations)
         : ok(new Map());
       if (linkTitleMapResult.isErr()) {
         yield err(linkTitleMapResult.error);
@@ -1081,7 +1219,7 @@ export class PasteHandler implements ICommandHandler<PasteCommand, PasteResult>
         const oldValues = new Map<string, unknown>();
         const fieldValues = this.buildEditableFieldValues(
           op.rowData,
-          editableColumns,
+          batchEditableColumns,
           (fieldId, rawValue) => {
             oldValues.set(fieldId, op.existingRecord.fields[fieldId]);
             return this.hydrateLinkValue(
@@ -1130,7 +1268,7 @@ export class PasteHandler implements ICommandHandler<PasteCommand, PasteResult>
             return;
           }
 
-          const changes: RecordFieldChangeDTO[] = editableColumns.map((column) => {
+          const changes: RecordFieldChangeDTO[] = batchEditableColumns.map((column) => {
             const fieldId = column.fieldId;
             const fieldIdStr = fieldId.toString();
             const newValue = updateResult.record.fields().get(fieldId)?.toValue() ?? null;
@@ -1340,6 +1478,15 @@ export class PasteHandler implements ICommandHandler<PasteCommand, PasteResult>
     }
 
     const batch: UpdateOperation[] = [];
+    let expectedSignature: string | undefined;
+
+    if (streamState.pendingUpdateOperation) {
+      batch.push(streamState.pendingUpdateOperation);
+      expectedSignature = this.getEditableColumnSignature(
+        streamState.pendingUpdateOperation.editableColumns
+      );
+      streamState.pendingUpdateOperation = undefined;
+    }
 
     while (batch.length < batchSize) {
       const next = await streamState.iterator.next();
@@ -1357,6 +1504,13 @@ export class PasteHandler implements ICommandHandler<PasteCommand, PasteResult>
         break;
       }
 
+      const signature = this.getEditableColumnSignature(operation.editableColumns);
+      if (expectedSignature && signature !== expectedSignature) {
+        streamState.pendingUpdateOperation = operation;
+        break;
+      }
+
+      expectedSignature = signature;
       batch.push(operation);
     }
 
@@ -1367,6 +1521,15 @@ export class PasteHandler implements ICommandHandler<PasteCommand, PasteResult>
     streamState: PasteOperationStreamState,
     batchSize: number
   ): Promise<Result<ReadonlyArray<CreateOperation> | null, DomainError>> {
+    if (streamState.pendingUpdateOperation) {
+      return err(
+        domainError.unexpected({
+          code: 'paste.create_stream.pending_update',
+          message: 'Create stream must not start while update operations are still pending',
+        })
+      );
+    }
+
     const batch: CreateOperation[] = [];
 
     if (streamState.pendingCreateOperation) {
@@ -1400,6 +1563,18 @@ export class PasteHandler implements ICommandHandler<PasteCommand, PasteResult>
     return ok(batch.length > 0 ? batch : null);
   }
 
+  /**
+   * Group only contiguous update operations with the same scoped columns. In the worst case,
+   * alternating per-record permissions can reduce batching to single-row updates.
+   */
+  private getEditableColumnSignature(
+    editableColumns: ReadonlyArray<EditableColumn> | undefined
+  ): string {
+    return (editableColumns ?? [])
+      .map((column) => `${column.fieldId.toString()}:${column.columnIndex}`)
+      .join('|');
+  }
+
   private async prepareMutationChunk(
     context: ExecutionContextPort.IExecutionContext,
     streamState: PasteOperationStreamState,
diff --git a/packages/v2/core/src/commands/TableFieldSpecs.ts b/packages/v2/core/src/commands/TableFieldSpecs.ts
index 65089642fd..41e8f0cc72 100644
--- a/packages/v2/core/src/commands/TableFieldSpecs.ts
+++ b/packages/v2/core/src/commands/TableFieldSpecs.ts
@@ -34,6 +34,7 @@ import {
 } from '../domain/table/fields/FieldFactory';
 import { FieldId } from '../domain/table/fields/FieldId';
 import { FieldName } from '../domain/table/fields/FieldName';
+import { ButtonConfirm } from '../domain/table/fields/types/ButtonConfirm';
 import { ButtonLabel } from '../domain/table/fields/types/ButtonLabel';
 import { ButtonMaxCount } from '../domain/table/fields/types/ButtonMaxCount';
 import { ButtonResetCount } from '../domain/table/fields/types/ButtonResetCount';
@@ -2105,6 +2106,7 @@ class CreateButtonFieldSpec implements ICreateTableFieldSpec {
     private readonly maxCount: ButtonMaxCount | undefined,
     private readonly resetCount: ButtonResetCount | undefined,
     private readonly workflow: ButtonWorkflow | undefined,
+    private readonly confirm: ButtonConfirm | undefined,
     private readonly notNull: FieldNotNull,
     private readonly unique: FieldUnique
   ) {}
@@ -2119,6 +2121,7 @@ class CreateButtonFieldSpec implements ICreateTableFieldSpec {
       maxCount?: ButtonMaxCount;
       resetCount?: ButtonResetCount;
       workflow?: ButtonWorkflow;
+      confirm?: ButtonConfirm;
       notNull: FieldNotNull;
       unique: FieldUnique;
     }
@@ -2131,6 +2134,7 @@ class CreateButtonFieldSpec implements ICreateTableFieldSpec {
       options.maxCount,
       options.resetCount,
       options.workflow,
+      options.confirm,
       options.notNull,
       options.unique
     ).withPrimary(options.isPrimary);
@@ -2149,6 +2153,7 @@ class CreateButtonFieldSpec implements ICreateTableFieldSpec {
     if (this.maxCount) fieldBuilder.withMaxCount(this.maxCount);
     if (this.resetCount) fieldBuilder.withResetCount(this.resetCount);
     if (this.workflow) fieldBuilder.withWorkflow(this.workflow);
+    if (this.confirm) fieldBuilder.withConfirm(this.confirm);
     if (this.isPrimary) fieldBuilder.primary();
     fieldBuilder.done();
   }
@@ -2165,6 +2170,7 @@ class CreateButtonFieldSpec implements ICreateTableFieldSpec {
         maxCount: this.maxCount,
         resetCount: this.resetCount,
         workflow: this.workflow,
+        confirm: this.confirm,
         notNull: this.notNull,
         unique: this.unique,
       })
@@ -2645,17 +2651,20 @@ export const parseTableFieldSpec = (
                 optional(field.options?.maxCount, ButtonMaxCount.create).andThen((maxCount) =>
                   optional(field.options?.resetCount, ButtonResetCount.create).andThen(
                     (resetCount) =>
-                      optional(field.options?.workflow, ButtonWorkflow.create).map((workflow) =>
-                        CreateButtonFieldSpec.create(id, name, {
-                          isPrimary: options.isPrimary,
-                          label,
-                          color,
-                          maxCount,
-                          resetCount,
-                          workflow,
-                          notNull: validation.notNull,
-                          unique: validation.unique,
-                        })
+                      optional(field.options?.workflow, ButtonWorkflow.create).andThen((workflow) =>
+                        optional(field.options?.confirm, ButtonConfirm.create).map((confirm) =>
+                          CreateButtonFieldSpec.create(id, name, {
+                            isPrimary: options.isPrimary,
+                            label,
+                            color,
+                            maxCount,
+                            resetCount,
+                            workflow,
+                            confirm,
+                            notNull: validation.notNull,
+                            unique: validation.unique,
+                          })
+                        )
                       )
                   )
                 )
diff --git a/packages/v2/core/src/commands/TableFieldUpdateSpecs.same-type.spec.ts b/packages/v2/core/src/commands/TableFieldUpdateSpecs.same-type.spec.ts
index 7db3de45ef..d9229698ea 100644
--- a/packages/v2/core/src/commands/TableFieldUpdateSpecs.same-type.spec.ts
+++ b/packages/v2/core/src/commands/TableFieldUpdateSpecs.same-type.spec.ts
@@ -5,6 +5,7 @@ import { DbFieldName } from '../domain/table/fields/DbFieldName';
 import type { Field } from '../domain/table/fields/Field';
 import { FieldId } from '../domain/table/fields/FieldId';
 import { FieldName } from '../domain/table/fields/FieldName';
+import { ButtonConfirm } from '../domain/table/fields/types/ButtonConfirm';
 import { ButtonLabel } from '../domain/table/fields/types/ButtonLabel';
 import { ButtonMaxCount } from '../domain/table/fields/types/ButtonMaxCount';
 import { ButtonWorkflow } from '../domain/table/fields/types/ButtonWorkflow';
@@ -74,6 +75,11 @@ const BUTTON_WORKFLOW = ButtonWorkflow.create({
   name: 'Deploy',
   isActive: true,
 })._unsafeUnwrap();
+const BUTTON_CONFIRM = ButtonConfirm.create({
+  title: 'Confirm deploy',
+  description: 'Ship this change?',
+  confirmText: 'Deploy',
+})._unsafeUnwrap();
 const BUTTON_COLOR_TEAL = FieldColor.from('teal');
 const FORMULA_NUMBER_FORMATTING = NumberFormatting.create({
   type: 'decimal',
@@ -625,6 +631,7 @@ const sameTypeCases: SameTypeCase[] = [
           .withColor(BUTTON_COLOR_TEAL)
           .withMaxCount(BUTTON_MAX_THREE)
           .withWorkflow(BUTTON_WORKFLOW)
+          .withConfirm(BUTTON_CONFIRM)
           .done();
       });
       setStableDbFieldName(currentField, 'stable_button_column');
@@ -637,6 +644,11 @@ const sameTypeCases: SameTypeCase[] = [
             label: 'Ship',
             color: 'blue',
             workflow: null,
+            confirm: {
+              title: 'Confirm ship',
+              description: 'Ship now?',
+              confirmText: 'Ship',
+            },
           },
           notNull: true,
           unique: true,
@@ -664,6 +676,12 @@ const sameTypeCases: SameTypeCase[] = [
           expect(workflowSpec).toBeDefined();
           expect(workflowSpec?.previousWorkflow()).toEqual(BUTTON_WORKFLOW);
           expect(workflowSpec?.nextWorkflow()).toBeUndefined();
+          expect(workflowSpec?.previousConfirm()).toEqual(BUTTON_CONFIRM);
+          expect(workflowSpec?.nextConfirm()?.toDto()).toEqual({
+            title: 'Confirm ship',
+            description: 'Ship now?',
+            confirmText: 'Ship',
+          });
         },
       };
     },
diff --git a/packages/v2/core/src/commands/TableFieldUpdateSpecs.ts b/packages/v2/core/src/commands/TableFieldUpdateSpecs.ts
index 2b7731a2bd..2e442befcd 100644
--- a/packages/v2/core/src/commands/TableFieldUpdateSpecs.ts
+++ b/packages/v2/core/src/commands/TableFieldUpdateSpecs.ts
@@ -14,6 +14,7 @@ import { FieldName } from '../domain/table/fields/FieldName';
 import { AttachmentField } from '../domain/table/fields/types/AttachmentField';
 import { AutoNumberField } from '../domain/table/fields/types/AutoNumberField';
 import { ButtonField } from '../domain/table/fields/types/ButtonField';
+import { ButtonConfirm } from '../domain/table/fields/types/ButtonConfirm';
 import { ButtonLabel } from '../domain/table/fields/types/ButtonLabel';
 import { ButtonMaxCount } from '../domain/table/fields/types/ButtonMaxCount';
 import { ButtonWorkflow } from '../domain/table/fields/types/ButtonWorkflow';
@@ -3037,6 +3038,7 @@ class UpdateButtonFieldSpec implements IUpdateTableFieldSpec {
     private readonly maxCountValue: ButtonMaxCount | undefined,
     private readonly shouldClearMaxCount: boolean,
     private readonly workflowClearable: ClearableResult<ButtonWorkflow | undefined>,
+    private readonly confirmClearable: ClearableResult<ButtonConfirm | undefined>,
     private readonly notNullValue: FieldNotNull | undefined,
     private readonly uniqueValue: FieldUnique | undefined
   ) {}
@@ -3048,6 +3050,7 @@ class UpdateButtonFieldSpec implements IUpdateTableFieldSpec {
       color?: unknown;
       maxCount?: unknown;
       workflow?: unknown;
+      confirm?: unknown;
     };
     notNull?: unknown;
     unique?: unknown;
@@ -3062,26 +3065,35 @@ class UpdateButtonFieldSpec implements IUpdateTableFieldSpec {
       typeof input.options === 'object' &&
       Object.prototype.hasOwnProperty.call(input.options, 'workflow');
 
+    const confirmWasProvided =
+      input.options != null &&
+      typeof input.options === 'object' &&
+      Object.prototype.hasOwnProperty.call(input.options, 'confirm');
+
     return optional(input.name, FieldName.create).andThen((name) =>
       optional(input.options?.label, ButtonLabel.create).andThen((label) =>
         optional(input.options?.color, FieldColor.create).andThen((color) =>
           optional(input.options?.maxCount, ButtonMaxCount.create).andThen((maxCount) =>
             clearable(input.options?.workflow, workflowWasProvided, ButtonWorkflow.create).andThen(
               (workflowResult) =>
-                optional(input.notNull, FieldNotNull.create).andThen((notNull) =>
-                  optional(input.unique, FieldUnique.create).map(
-                    (unique) =>
-                      new UpdateButtonFieldSpec(
-                        name,
-                        label,
-                        color,
-                        maxCount,
-                        !maxCountWasProvided,
-                        workflowResult,
-                        notNull,
-                        unique
+                clearable(input.options?.confirm, confirmWasProvided, ButtonConfirm.create).andThen(
+                  (confirmResult) =>
+                    optional(input.notNull, FieldNotNull.create).andThen((notNull) =>
+                      optional(input.unique, FieldUnique.create).map(
+                        (unique) =>
+                          new UpdateButtonFieldSpec(
+                            name,
+                            label,
+                            color,
+                            maxCount,
+                            !maxCountWasProvided,
+                            workflowResult,
+                            confirmResult,
+                            notNull,
+                            unique
+                          )
                       )
-                  )
+                    )
                 )
             )
           )
@@ -3133,23 +3145,31 @@ class UpdateButtonFieldSpec implements IUpdateTableFieldSpec {
       }
     }
 
-    if (this.workflowClearable.shouldClear) {
-      // Workflow explicitly set to null - clear it
-      const currentWorkflow = currentField.workflow();
-      if (currentWorkflow !== undefined) {
-        specs.push(UpdateButtonWorkflowSpec.create(currentField.id(), currentWorkflow, undefined));
-      }
-    } else if (this.workflowClearable.value !== undefined) {
-      const currentWorkflow = currentField.workflow();
-      if (!currentWorkflow || !this.workflowClearable.value.equals(currentWorkflow)) {
-        specs.push(
-          UpdateButtonWorkflowSpec.create(
-            currentField.id(),
-            currentWorkflow,
-            this.workflowClearable.value
-          )
-        );
-      }
+    const currentWorkflow = currentField.workflow();
+    const currentConfirm = currentField.confirm();
+    const workflowChanged = this.workflowClearable.shouldClear
+      ? currentWorkflow !== undefined
+      : this.workflowClearable.value !== undefined &&
+        (!currentWorkflow || !this.workflowClearable.value.equals(currentWorkflow));
+    const confirmChanged = this.confirmClearable.shouldClear
+      ? currentConfirm !== undefined
+      : this.confirmClearable.value !== undefined &&
+        (!currentConfirm || !this.confirmClearable.value.equals(currentConfirm));
+
+    if (workflowChanged || confirmChanged) {
+      specs.push(
+        UpdateButtonWorkflowSpec.create(
+          currentField.id(),
+          currentWorkflow,
+          this.workflowClearable.shouldClear
+            ? undefined
+            : this.workflowClearable.value ?? currentWorkflow,
+          currentConfirm,
+          this.confirmClearable.shouldClear
+            ? undefined
+            : this.confirmClearable.value ?? currentConfirm
+        )
+      );
     }
 
     const constraintsSpec = buildConstraintsSpec(currentField, this.notNullValue, this.uniqueValue);
diff --git a/packages/v2/core/src/domain/table/TableBuilder.ts b/packages/v2/core/src/domain/table/TableBuilder.ts
index a2fe50b8ca..b913dd3250 100644
--- a/packages/v2/core/src/domain/table/TableBuilder.ts
+++ b/packages/v2/core/src/domain/table/TableBuilder.ts
@@ -12,6 +12,7 @@ import { validateForeignTablesForFields } from './fields/ForeignTableRelatedFiel
 import { AttachmentField } from './fields/types/AttachmentField';
 import { AutoNumberField } from './fields/types/AutoNumberField';
 import { ButtonField } from './fields/types/ButtonField';
+import type { ButtonConfirm } from './fields/types/ButtonConfirm';
 import { ButtonLabel } from './fields/types/ButtonLabel';
 import type { ButtonMaxCount } from './fields/types/ButtonMaxCount';
 import type { ButtonResetCount } from './fields/types/ButtonResetCount';
@@ -1772,6 +1773,7 @@ export class ButtonFieldBuilder {
   private maxCount: ButtonMaxCount | undefined;
   private resetCount: ButtonResetCount | undefined;
   private workflow: ButtonWorkflow | undefined;
+  private confirm: ButtonConfirm | undefined;
   private notNull: FieldNotNull = FieldNotNull.optional();
   private unique: FieldUnique = FieldUnique.disabled();
   private isPrimary = false;
@@ -1816,6 +1818,11 @@ export class ButtonFieldBuilder {
     return this;
   }
 
+  withConfirm(confirm: ButtonConfirm): ButtonFieldBuilder {
+    this.confirm = confirm;
+    return this;
+  }
+
   withNotNull(notNull: FieldNotNull): ButtonFieldBuilder {
     this.notNull = notNull;
     return this;
@@ -1847,6 +1854,7 @@ export class ButtonFieldBuilder {
         maxCount: this.maxCount,
         resetCount: this.resetCount,
         workflow: this.workflow,
+        confirm: this.confirm,
       })
         .andThen((field) => applyFieldValidation(field, this.notNull, this.unique))
         .andThen((field) => {
diff --git a/packages/v2/core/src/domain/table/fields/FieldFactory.ts b/packages/v2/core/src/domain/table/fields/FieldFactory.ts
index fac03447d4..ea142a44a6 100644
--- a/packages/v2/core/src/domain/table/fields/FieldFactory.ts
+++ b/packages/v2/core/src/domain/table/fields/FieldFactory.ts
@@ -10,6 +10,7 @@ import type { FieldName } from './FieldName';
 import { AttachmentField } from './types/AttachmentField';
 import { AutoNumberField } from './types/AutoNumberField';
 import { ButtonField } from './types/ButtonField';
+import type { ButtonConfirm } from './types/ButtonConfirm';
 import type { ButtonLabel } from './types/ButtonLabel';
 import type { ButtonMaxCount } from './types/ButtonMaxCount';
 import type { ButtonResetCount } from './types/ButtonResetCount';
@@ -304,6 +305,7 @@ export const createButtonField = (params: {
   maxCount?: ButtonMaxCount;
   resetCount?: ButtonResetCount;
   workflow?: ButtonWorkflow;
+  confirm?: ButtonConfirm;
   notNull?: FieldNotNull;
   unique?: FieldUnique;
 }): Result<Field, DomainError> =>
diff --git a/packages/v2/core/src/domain/table/fields/types/ButtonConfirm.ts b/packages/v2/core/src/domain/table/fields/types/ButtonConfirm.ts
new file mode 100644
index 0000000000..389d970fb2
--- /dev/null
+++ b/packages/v2/core/src/domain/table/fields/types/ButtonConfirm.ts
@@ -0,0 +1,38 @@
+import { err, ok } from 'neverthrow';
+import type { Result } from 'neverthrow';
+import { z } from 'zod';
+
+import { domainError, type DomainError } from '../../../shared/DomainError';
+import { ValueObject } from '../../../shared/ValueObject';
+
+const buttonConfirmSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  confirmText: z.string().optional(),
+});
+
+export type ButtonConfirmValue = z.infer<typeof buttonConfirmSchema>;
+
+export class ButtonConfirm extends ValueObject {
+  private constructor(private readonly value: ButtonConfirmValue) {
+    super();
+  }
+
+  static create(raw: unknown): Result<ButtonConfirm, DomainError> {
+    const parsed = buttonConfirmSchema.safeParse(raw);
+    if (!parsed.success) return err(domainError.validation({ message: 'Invalid ButtonConfirm' }));
+    return ok(new ButtonConfirm(parsed.data));
+  }
+
+  equals(other: ButtonConfirm): boolean {
+    return (
+      this.value.title === other.value.title &&
+      this.value.description === other.value.description &&
+      this.value.confirmText === other.value.confirmText
+    );
+  }
+
+  toDto(): ButtonConfirmValue {
+    return { ...this.value };
+  }
+}
diff --git a/packages/v2/core/src/domain/table/fields/types/ButtonField.ts b/packages/v2/core/src/domain/table/fields/types/ButtonField.ts
index 91cad4b7b7..edd2b03b87 100644
--- a/packages/v2/core/src/domain/table/fields/types/ButtonField.ts
+++ b/packages/v2/core/src/domain/table/fields/types/ButtonField.ts
@@ -8,6 +8,7 @@ import type { FieldId } from '../FieldId';
 import type { FieldName } from '../FieldName';
 import { FieldType } from '../FieldType';
 import type { IFieldVisitor } from '../visitors/IFieldVisitor';
+import type { ButtonConfirm } from './ButtonConfirm';
 import { ButtonLabel } from './ButtonLabel';
 import type { ButtonMaxCount } from './ButtonMaxCount';
 import type { ButtonResetCount } from './ButtonResetCount';
@@ -22,7 +23,8 @@ export class ButtonField extends Field {
     private readonly colorValue: FieldColor,
     private readonly maxCountValue: ButtonMaxCount | undefined,
     private readonly resetCountValue: ButtonResetCount | undefined,
-    private readonly workflowValue: ButtonWorkflow | undefined
+    private readonly workflowValue: ButtonWorkflow | undefined,
+    private readonly confirmValue: ButtonConfirm | undefined
   ) {
     super(id, name, FieldType.button());
   }
@@ -35,6 +37,7 @@ export class ButtonField extends Field {
     maxCount?: ButtonMaxCount;
     resetCount?: ButtonResetCount;
     workflow?: ButtonWorkflow;
+    confirm?: ButtonConfirm;
   }): Result<ButtonField, DomainError> {
     return ok(
       new ButtonField(
@@ -44,7 +47,8 @@ export class ButtonField extends Field {
         params.color ?? FieldColor.from('teal'),
         params.maxCount,
         params.resetCount,
-        params.workflow
+        params.workflow,
+        params.confirm
       )
     );
   }
@@ -69,6 +73,10 @@ export class ButtonField extends Field {
     return this.workflowValue;
   }
 
+  confirm(): ButtonConfirm | undefined {
+    return this.confirmValue;
+  }
+
   duplicate(params: FieldDuplicateParams): Result<Field, DomainError> {
     return ButtonField.create({
       id: params.newId,
@@ -78,6 +86,7 @@ export class ButtonField extends Field {
       maxCount: this.maxCount(),
       resetCount: this.resetCount(),
       workflow: undefined,
+      confirm: this.confirm(),
     });
   }
 
diff --git a/packages/v2/core/src/domain/table/fields/visitors/FieldOptionsDtoVisitor.ts b/packages/v2/core/src/domain/table/fields/visitors/FieldOptionsDtoVisitor.ts
index 21c7af3714..e44cfc21e1 100644
--- a/packages/v2/core/src/domain/table/fields/visitors/FieldOptionsDtoVisitor.ts
+++ b/packages/v2/core/src/domain/table/fields/visitors/FieldOptionsDtoVisitor.ts
@@ -173,6 +173,7 @@ export class FieldOptionsDtoVisitor implements IFieldVisitor<unknown> {
     const maxCount = field.maxCount();
     const resetCount = field.resetCount();
     const workflow = field.workflow();
+    const confirm = field.confirm();
     const options: Record<string, unknown> = {
       label: field.label().toString(),
       color: field.color().toString(),
@@ -180,6 +181,7 @@ export class FieldOptionsDtoVisitor implements IFieldVisitor<unknown> {
     if (maxCount) options.maxCount = maxCount.toNumber();
     if (resetCount) options.resetCount = resetCount.toBoolean();
     if (workflow) options.workflow = workflow.toDto();
+    if (confirm) options.confirm = confirm.toDto();
     return ok(options);
   }
 
diff --git a/packages/v2/core/src/domain/table/fields/visitors/FieldToSpecVisitor.ts b/packages/v2/core/src/domain/table/fields/visitors/FieldToSpecVisitor.ts
index 1bca159781..29863c258b 100644
--- a/packages/v2/core/src/domain/table/fields/visitors/FieldToSpecVisitor.ts
+++ b/packages/v2/core/src/domain/table/fields/visitors/FieldToSpecVisitor.ts
@@ -383,8 +383,13 @@ export class FieldToSpecVisitor extends AbstractFieldVisitor<ICellValueSpec> {
 
     if (parsed.type === 'ids') {
       // Standard format: [{ id: 'recXxx', title?: string }]
+      // Pass foreignTableId so the resolver can look up missing titles
       return ok(
-        new SetLinkValueSpec(field.id(), CellValue.fromValidated(parsed.value as LinkItem[]))
+        new SetLinkValueSpec(
+          field.id(),
+          CellValue.fromValidated(parsed.value as LinkItem[]),
+          field.foreignTableId()
+        )
       );
     }
 
diff --git a/packages/v2/core/src/domain/table/records/specs/values/SetLinkValueSpec.ts b/packages/v2/core/src/domain/table/records/specs/values/SetLinkValueSpec.ts
index 3cd63d3a6b..e304da9d72 100644
--- a/packages/v2/core/src/domain/table/records/specs/values/SetLinkValueSpec.ts
+++ b/packages/v2/core/src/domain/table/records/specs/values/SetLinkValueSpec.ts
@@ -3,6 +3,7 @@ import type { Result } from 'neverthrow';
 import type { DomainError } from '../../../../shared/DomainError';
 import { MutateOnlySpec } from '../../../../shared/specification/MutateOnlySpec';
 import type { FieldId } from '../../../fields/FieldId';
+import type { TableId } from '../../../TableId';
 import type { TableRecord } from '../../TableRecord';
 import type { CellValue } from '../../values/CellValue';
 import type { ICellValueSpecVisitor } from './ICellValueSpecVisitor';
@@ -22,11 +23,18 @@ export interface LinkItem {
 export class SetLinkValueSpec extends MutateOnlySpec<TableRecord, ICellValueSpecVisitor> {
   constructor(
     readonly fieldId: FieldId,
-    readonly value: CellValue<LinkItem[]>
+    readonly value: CellValue<LinkItem[]>,
+    readonly foreignTableId?: TableId
   ) {
     super();
   }
 
+  needsTitleResolution(): boolean {
+    const items = this.value.toValue();
+    if (!items || !Array.isArray(items) || items.length === 0) return false;
+    return this.foreignTableId != null && items.some((item) => item.id && !item.title);
+  }
+
   mutate(record: TableRecord): Result<TableRecord, DomainError> {
     return record.setFieldValue(this.fieldId, this.value);
   }
diff --git a/packages/v2/core/src/domain/table/specs/field-updates/UpdateButtonColorSpec.ts b/packages/v2/core/src/domain/table/specs/field-updates/UpdateButtonColorSpec.ts
index 615a1e7ff5..e6ea22db73 100644
--- a/packages/v2/core/src/domain/table/specs/field-updates/UpdateButtonColorSpec.ts
+++ b/packages/v2/core/src/domain/table/specs/field-updates/UpdateButtonColorSpec.ts
@@ -60,6 +60,7 @@ export class UpdateButtonColorSpec<
       maxCount: field.maxCount(),
       resetCount: field.resetCount(),
       workflow: field.workflow(),
+      confirm: field.confirm(),
     });
     if (updatedFieldResult.isErr()) return err(updatedFieldResult.error);
 
diff --git a/packages/v2/core/src/domain/table/specs/field-updates/UpdateButtonLabelSpec.ts b/packages/v2/core/src/domain/table/specs/field-updates/UpdateButtonLabelSpec.ts
index 3012262b7b..2600dea696 100644
--- a/packages/v2/core/src/domain/table/specs/field-updates/UpdateButtonLabelSpec.ts
+++ b/packages/v2/core/src/domain/table/specs/field-updates/UpdateButtonLabelSpec.ts
@@ -60,6 +60,7 @@ export class UpdateButtonLabelSpec<
       maxCount: field.maxCount(),
       resetCount: field.resetCount(),
       workflow: field.workflow(),
+      confirm: field.confirm(),
     });
     if (updatedFieldResult.isErr()) return err(updatedFieldResult.error);
 
diff --git a/packages/v2/core/src/domain/table/specs/field-updates/UpdateButtonMaxCountSpec.ts b/packages/v2/core/src/domain/table/specs/field-updates/UpdateButtonMaxCountSpec.ts
index 60eb4787d8..d0b5b03ea9 100644
--- a/packages/v2/core/src/domain/table/specs/field-updates/UpdateButtonMaxCountSpec.ts
+++ b/packages/v2/core/src/domain/table/specs/field-updates/UpdateButtonMaxCountSpec.ts
@@ -60,6 +60,7 @@ export class UpdateButtonMaxCountSpec<
       maxCount: this.nextMaxCountValue,
       resetCount: field.resetCount(),
       workflow: field.workflow(),
+      confirm: field.confirm(),
     });
     if (updatedFieldResult.isErr()) return err(updatedFieldResult.error);
 
diff --git a/packages/v2/core/src/domain/table/specs/field-updates/UpdateButtonWorkflowSpec.ts b/packages/v2/core/src/domain/table/specs/field-updates/UpdateButtonWorkflowSpec.ts
index 258c177bdf..eadf11532b 100644
--- a/packages/v2/core/src/domain/table/specs/field-updates/UpdateButtonWorkflowSpec.ts
+++ b/packages/v2/core/src/domain/table/specs/field-updates/UpdateButtonWorkflowSpec.ts
@@ -5,6 +5,7 @@ import { domainError, type DomainError } from '../../../shared/DomainError';
 import { MutateOnlySpec } from '../../../shared/specification/MutateOnlySpec';
 import type { FieldId } from '../../fields/FieldId';
 import { ButtonField } from '../../fields/types/ButtonField';
+import type { ButtonConfirm } from '../../fields/types/ButtonConfirm';
 import type { ButtonWorkflow } from '../../fields/types/ButtonWorkflow';
 import type { Table } from '../../Table';
 import type { ITableSpecVisitor } from '../ITableSpecVisitor';
@@ -18,7 +19,9 @@ export class UpdateButtonWorkflowSpec<
   private constructor(
     private readonly fieldIdValue: FieldId,
     private readonly previousWorkflowValue: ButtonWorkflow | undefined,
-    private readonly nextWorkflowValue: ButtonWorkflow | undefined
+    private readonly nextWorkflowValue: ButtonWorkflow | undefined,
+    private readonly previousConfirmValue: ButtonConfirm | undefined,
+    private readonly nextConfirmValue: ButtonConfirm | undefined
   ) {
     super();
   }
@@ -26,9 +29,17 @@ export class UpdateButtonWorkflowSpec<
   static create(
     fieldId: FieldId,
     previousWorkflow: ButtonWorkflow | undefined,
-    nextWorkflow: ButtonWorkflow | undefined
+    nextWorkflow: ButtonWorkflow | undefined,
+    previousConfirm?: ButtonConfirm,
+    nextConfirm?: ButtonConfirm
   ): UpdateButtonWorkflowSpec {
-    return new UpdateButtonWorkflowSpec(fieldId, previousWorkflow, nextWorkflow);
+    return new UpdateButtonWorkflowSpec(
+      fieldId,
+      previousWorkflow,
+      nextWorkflow,
+      previousConfirm,
+      nextConfirm
+    );
   }
 
   fieldId(): FieldId {
@@ -43,6 +54,14 @@ export class UpdateButtonWorkflowSpec<
     return this.nextWorkflowValue;
   }
 
+  previousConfirm(): ButtonConfirm | undefined {
+    return this.previousConfirmValue;
+  }
+
+  nextConfirm(): ButtonConfirm | undefined {
+    return this.nextConfirmValue;
+  }
+
   mutate(t: Table): Result<Table, DomainError> {
     const fieldResult = t.getField((f) => f.id().equals(this.fieldIdValue));
     if (fieldResult.isErr()) return err(fieldResult.error);
@@ -60,6 +79,7 @@ export class UpdateButtonWorkflowSpec<
       maxCount: field.maxCount(),
       resetCount: field.resetCount(),
       workflow: this.nextWorkflowValue,
+      confirm: this.nextConfirmValue,
     });
     if (updatedFieldResult.isErr()) return err(updatedFieldResult.error);
 
diff --git a/packages/v2/core/src/index.ts b/packages/v2/core/src/index.ts
index 64082e95d4..97d520f36e 100644
--- a/packages/v2/core/src/index.ts
+++ b/packages/v2/core/src/index.ts
@@ -304,6 +304,7 @@ export * from './domain/table/fields/visitors/FieldValueTypeVisitor';
 export * from './domain/table/fields/visitors/LinkForeignTableReferenceVisitor';
 export type { AttachmentField } from './domain/table/fields/types/AttachmentField';
 export type { ButtonField } from './domain/table/fields/types/ButtonField';
+export * from './domain/table/fields/types/ButtonConfirm';
 export * from './domain/table/fields/types/ButtonLabel';
 export * from './domain/table/fields/types/ButtonMaxCount';
 export * from './domain/table/fields/types/ButtonResetCount';
diff --git a/packages/v2/core/src/ports/RecordWritePlugin.ts b/packages/v2/core/src/ports/RecordWritePlugin.ts
index 50a4dec3e5..0e976b5446 100644
--- a/packages/v2/core/src/ports/RecordWritePlugin.ts
+++ b/packages/v2/core/src/ports/RecordWritePlugin.ts
@@ -7,8 +7,8 @@ import type { FieldId } from '../domain/table/fields/FieldId';
 import type { FieldKeyType } from '../domain/table/fields/FieldKeyType';
 import type { RecordId } from '../domain/table/records/RecordId';
 import type { RecordInsertOrder } from '../domain/table/records/RecordInsertOrder';
-import type { TableRecord } from '../domain/table/records/TableRecord';
 import type { ITableRecordConditionSpecVisitor } from '../domain/table/records/specs/ITableRecordConditionSpecVisitor';
+import type { TableRecord } from '../domain/table/records/TableRecord';
 import type { Table } from '../domain/table/Table';
 import type { IExecutionContext } from './ExecutionContext';
 import type { SourceColumnMap } from './import/IImportSource';
@@ -201,8 +201,15 @@ export type RecordWritePluginContextMap = {
 
 export type RecordWritePluginContext = RecordWritePluginContextMap[RecordWriteOperationKind];
 
+export type RecordWriteScopedFieldIdsResolver = (
+  record: TableRecord
+) => ReadonlySet<string> | undefined;
+
 export interface RecordWritePluginScope {
   readonly recordSpec?: ISpecification<TableRecord, ITableRecordConditionSpecVisitor>;
+  readonly updateFieldIds?: ReadonlySet<string>;
+  readonly createFieldIds?: ReadonlySet<string>;
+  readonly resolveUpdateFieldIdsForRecord?: RecordWriteScopedFieldIdsResolver;
 }
 
 export interface IRecordWritePlugin<TPreparedState = unknown> {
diff --git a/packages/v2/core/src/ports/TableRecordRepository.ts b/packages/v2/core/src/ports/TableRecordRepository.ts
index f03d0833a3..ba7769dfcf 100644
--- a/packages/v2/core/src/ports/TableRecordRepository.ts
+++ b/packages/v2/core/src/ports/TableRecordRepository.ts
@@ -200,6 +200,13 @@ export interface InsertOptions {
    * the same transaction after the records are restored.
    */
   cleanupTrashRecordIds?: ReadonlyArray<string>;
+
+  /**
+   * When true, generate SQL to fill missing link titles by JOINing
+   * the foreign table's primary field. Used in typecast mode when
+   * API clients provide link IDs without titles.
+   */
+  fillLinkTitles?: boolean;
 }
 
 export interface ITableRecordRepository {
diff --git a/packages/v2/core/src/ports/mappers/TableMapper.ts b/packages/v2/core/src/ports/mappers/TableMapper.ts
index a21db6baaf..74816fe6ce 100644
--- a/packages/v2/core/src/ports/mappers/TableMapper.ts
+++ b/packages/v2/core/src/ports/mappers/TableMapper.ts
@@ -97,12 +97,19 @@ export type IButtonWorkflowDTO = {
   isActive?: boolean;
 };
 
+export type IButtonConfirmDTO = {
+  title?: string;
+  description?: string;
+  confirmText?: string;
+};
+
 export type IButtonFieldOptionsDTO = {
   label?: string;
   color?: string;
   maxCount?: number;
   resetCount?: boolean;
   workflow?: IButtonWorkflowDTO | null;
+  confirm?: IButtonConfirmDTO | null;
 };
 
 export type IFormulaFieldFormattingDTO =
diff --git a/packages/v2/core/src/ports/mappers/defaults/DefaultTableMapper.spec.ts b/packages/v2/core/src/ports/mappers/defaults/DefaultTableMapper.spec.ts
index 8b7f5216f2..9f8891eb89 100644
--- a/packages/v2/core/src/ports/mappers/defaults/DefaultTableMapper.spec.ts
+++ b/packages/v2/core/src/ports/mappers/defaults/DefaultTableMapper.spec.ts
@@ -5,6 +5,7 @@ import { FieldId } from '../../../domain/table/fields/FieldId';
 import { FieldName } from '../../../domain/table/fields/FieldName';
 import { AttachmentField } from '../../../domain/table/fields/types/AttachmentField';
 import { ButtonField } from '../../../domain/table/fields/types/ButtonField';
+import { ButtonConfirm } from '../../../domain/table/fields/types/ButtonConfirm';
 import { ButtonLabel } from '../../../domain/table/fields/types/ButtonLabel';
 import { ButtonMaxCount } from '../../../domain/table/fields/types/ButtonMaxCount';
 import { ButtonResetCount } from '../../../domain/table/fields/types/ButtonResetCount';
@@ -152,6 +153,11 @@ const buildTable = () => {
     name: 'Deploy',
     isActive: true,
   })._unsafeUnwrap();
+  const buttonConfirm = ButtonConfirm.create({
+    title: 'Confirm deploy',
+    description: 'Ship this change?',
+    confirmText: 'Deploy',
+  })._unsafeUnwrap();
 
   const fields = [
     SingleLineTextField.create({
@@ -220,6 +226,7 @@ const buildTable = () => {
       maxCount: buttonMax,
       resetCount: buttonReset,
       workflow: buttonWorkflow,
+      confirm: buttonConfirm,
     })._unsafeUnwrap(),
   ];
 
@@ -353,6 +360,13 @@ describe('DefaultTableMapper', () => {
     expect(mapped.views().length).toBe(table.views().length);
     expect(mapped.views()[0]?.options()).toEqual(table.views()[0]?.options());
     expect(mapped.views()[5]?.options()).toEqual(table.views()[5]?.options());
+    const mappedButton = mapped
+      .getFields()
+      .find((field) => field.name().toString() === 'Action') as ButtonField | undefined;
+    const originalButton = table
+      .getFields()
+      .find((field) => field.name().toString() === 'Action') as ButtonField | undefined;
+    expect(mappedButton?.confirm()?.toDto()).toEqual(originalButton?.confirm()?.toDto());
     mapped.dbTableName()._unsafeUnwrap();
 
     const fieldDbNameResult = mapped.getFields()[0]?.dbFieldName();
@@ -504,6 +518,56 @@ describe('DefaultTableMapper', () => {
     expect((conditionalLookupField as ConditionalLookupField).isPending()).toBe(true);
   });
 
+  it('preserves lookup dbFieldName instead of inheriting the inner system column', () => {
+    const mapper = new DefaultTableMapper();
+    const dto = mapper.toDTO(buildTable())._unsafeUnwrap();
+
+    const lookupFieldId = `fld${'q'.repeat(16)}`;
+    const lookupDbFieldName = 'lookup_auto_number_q';
+
+    const withLookup = {
+      ...dto,
+      fields: [
+        ...dto.fields,
+        {
+          id: lookupFieldId,
+          name: 'Lookup Auto Number',
+          type: 'autoNumber' as const,
+          options: {
+            expression: 'AUTO_NUMBER()',
+          },
+          isLookup: true,
+          isComputed: true,
+          dbFieldName: lookupDbFieldName,
+          dbFieldType: 'INTEGER',
+          cellValueType: 'number' as const,
+          isMultipleCellValue: false,
+          lookupOptions: {
+            foreignTableId: `tbl${'b'.repeat(16)}`,
+            linkFieldId: `fld${'c'.repeat(16)}`,
+            lookupFieldId: `fld${'d'.repeat(16)}`,
+            relationship: 'manyOne' as const,
+          },
+        },
+      ],
+    };
+
+    const mapped = mapper.toDomain(withLookup)._unsafeUnwrap();
+    const mappedLookupField = mapped
+      .getFields()
+      .find((field) => field.id().equals(FieldId.create(lookupFieldId)._unsafeUnwrap()));
+    expect(mappedLookupField).toBeInstanceOf(LookupField);
+    expect((mappedLookupField as LookupField).innerFieldType()._unsafeUnwrap().toString()).toBe(
+      'autoNumber'
+    );
+
+    const roundTripped = mapper.toDTO(mapped)._unsafeUnwrap();
+    const lookupField = roundTripped.fields.find((field) => field.id === lookupFieldId);
+
+    expect(lookupField?.dbFieldName).toBe(lookupDbFieldName);
+    expect(lookupField?.dbFieldName).not.toBe('__auto_number');
+  });
+
   it('rehydrates conditional lookup inner formula when result type is provided', () => {
     const table = buildTable();
     const mapper = new DefaultTableMapper();
diff --git a/packages/v2/core/src/ports/mappers/defaults/DefaultTableMapper.ts b/packages/v2/core/src/ports/mappers/defaults/DefaultTableMapper.ts
index fea719b848..6e63317533 100644
--- a/packages/v2/core/src/ports/mappers/defaults/DefaultTableMapper.ts
+++ b/packages/v2/core/src/ports/mappers/defaults/DefaultTableMapper.ts
@@ -13,6 +13,7 @@ import { FieldName } from '../../../domain/table/fields/FieldName';
 import { AttachmentField } from '../../../domain/table/fields/types/AttachmentField';
 import { AutoNumberField } from '../../../domain/table/fields/types/AutoNumberField';
 import { ButtonField } from '../../../domain/table/fields/types/ButtonField';
+import { ButtonConfirm } from '../../../domain/table/fields/types/ButtonConfirm';
 import { ButtonLabel } from '../../../domain/table/fields/types/ButtonLabel';
 import { ButtonMaxCount } from '../../../domain/table/fields/types/ButtonMaxCount';
 import { ButtonResetCount } from '../../../domain/table/fields/types/ButtonResetCount';
@@ -573,12 +574,14 @@ class FieldToPersistenceVisitor implements IFieldVisitor<ITableFieldPersistenceD
     const maxCount = field.maxCount();
     const resetCount = field.resetCount();
     const workflow = field.workflow();
+    const confirm = field.confirm();
     const options: IButtonFieldOptionsDTO = {
       label: field.label().toString(),
       color: field.color().toString(),
       ...(maxCount ? { maxCount: maxCount.toNumber() } : {}),
       ...(resetCount ? { resetCount: resetCount.toBoolean() } : {}),
       ...(workflow ? { workflow: workflow.toDto() } : {}),
+      ...(confirm ? { confirm: confirm.toDto() } : {}),
     };
 
     return ok({
@@ -695,6 +698,7 @@ class FieldToPersistenceVisitor implements IFieldVisitor<ITableFieldPersistenceD
 
         return {
           ...innerDto,
+          ...baseDto,
           id: field.id().toString(),
           name: field.name().toString(),
           isLookup: true,
@@ -1260,15 +1264,18 @@ export class DefaultTableMapper implements ITableMapper {
                   optional(options.maxCount, ButtonMaxCount.create).andThen((maxCount) =>
                     optional(options.resetCount, ButtonResetCount.create).andThen((resetCount) =>
                       optional(options.workflow, ButtonWorkflow.create).andThen((workflow) =>
-                        ButtonField.create({
-                          id,
-                          name,
-                          label,
-                          color,
-                          maxCount,
-                          resetCount,
-                          workflow,
-                        })
+                        optional(options.confirm, ButtonConfirm.create).andThen((confirm) =>
+                          ButtonField.create({
+                            id,
+                            name,
+                            label,
+                            color,
+                            maxCount,
+                            resetCount,
+                            workflow,
+                            confirm,
+                          })
+                        )
                       )
                     )
                   )
diff --git a/packages/v2/core/src/schemas/field/tableField.schema.ts b/packages/v2/core/src/schemas/field/tableField.schema.ts
index cdb5504126..9f7a9a7318 100644
--- a/packages/v2/core/src/schemas/field/tableField.schema.ts
+++ b/packages/v2/core/src/schemas/field/tableField.schema.ts
@@ -112,12 +112,19 @@ export const buttonWorkflowSchema = z.object({
   isActive: z.boolean().optional(),
 });
 
+export const buttonConfirmSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  confirmText: z.string().optional(),
+});
+
 export const buttonOptionsSchema = z.object({
   label: z.string().optional(),
   color: fieldColorSchema.optional(),
   maxCount: z.number().optional(),
   resetCount: z.boolean().optional(),
   workflow: buttonWorkflowSchema.optional().nullable(),
+  confirm: buttonConfirmSchema.optional().nullable(),
 });
 
 export const formulaOptionsSchema = z.object({
diff --git a/packages/v2/e2e/src/conditionalFields.e2e.spec.ts b/packages/v2/e2e/src/conditionalFields.e2e.spec.ts
index 99a08c7e6c..b73e043f4c 100644
--- a/packages/v2/e2e/src/conditionalFields.e2e.spec.ts
+++ b/packages/v2/e2e/src/conditionalFields.e2e.spec.ts
@@ -424,6 +424,128 @@ describe('v2 http conditionalFields (e2e)', () => {
       expect(created).toBeTruthy();
     });
 
+    it('exposes foreign singleSelect choices for conditionalLookup fields', async () => {
+      const categoryFieldId = createFieldId();
+      const importanceFieldId = createFieldId();
+      const hostCategoryFieldId = createFieldId();
+      const conditionalLookupFieldId = createFieldId();
+
+      const foreignWithCategory = await ctx.createField({
+        baseId: ctx.baseId,
+        tableId: foreignTableId,
+        field: { type: 'singleLineText', id: categoryFieldId, name: 'Category' },
+      });
+      const foreignCategoryField = foreignWithCategory.fields.find((f) => f.id === categoryFieldId);
+      if (!foreignCategoryField) throw new Error('Missing foreign category field');
+
+      const foreignWithImportance = await ctx.createField({
+        baseId: ctx.baseId,
+        tableId: foreignTableId,
+        field: {
+          type: 'singleSelect',
+          id: importanceFieldId,
+          name: 'Importance',
+          options: {
+            choices: [
+              { id: 'choCondCore', name: '核心', color: 'blue' },
+              { id: 'choCondImportant', name: '重要', color: 'green' },
+              { id: 'choCondReference', name: '参考', color: 'orange' },
+            ],
+          },
+        },
+      });
+      const foreignImportanceField = foreignWithImportance.fields.find(
+        (f) => f.id === importanceFieldId
+      ) as
+        | {
+            options?: {
+              choices?: Array<{ id: string; name: string; color: string }>;
+            };
+          }
+        | undefined;
+      if (!foreignImportanceField?.options?.choices) {
+        throw new Error('Missing foreign importance field choices');
+      }
+
+      const hostWithCategoryFilter = await ctx.createField({
+        baseId: ctx.baseId,
+        tableId: hostTableId,
+        field: { type: 'singleLineText', id: hostCategoryFieldId, name: 'Category Filter' },
+      });
+      const hostCategoryFilterField = hostWithCategoryFilter.fields.find(
+        (f) => f.id === hostCategoryFieldId
+      );
+      if (!hostCategoryFilterField) throw new Error('Missing host category filter field');
+
+      const expectedChoices = foreignImportanceField.options.choices;
+
+      const { status, rawBody } = await createField(hostTableId, {
+        type: 'conditionalLookup',
+        id: conditionalLookupFieldId,
+        name: 'Conditional Importance',
+        options: {
+          foreignTableId,
+          lookupFieldId: importanceFieldId,
+          condition: {
+            filter: {
+              conjunction: 'and',
+              filterSet: [
+                {
+                  fieldId: categoryFieldId,
+                  operator: 'is',
+                  value: hostCategoryFieldId,
+                  isSymbol: true,
+                },
+              ],
+            },
+          },
+        },
+      });
+
+      if (status !== 200) {
+        console.error('CreateField failed:', JSON.stringify(rawBody, null, 2));
+      }
+      expect(status).toBe(200);
+
+      const parsed = createFieldOkResponseSchema.safeParse(rawBody);
+      expect(parsed.success).toBe(true);
+      if (!parsed.success || !parsed.data.ok) return;
+
+      const created = parsed.data.data.table.fields.find(
+        (f) => f.id === conditionalLookupFieldId
+      ) as
+        | {
+            type?: string;
+            isLookup?: boolean;
+            options?: {
+              choices?: Array<{ id: string; name: string; color: string }>;
+            };
+          }
+        | undefined;
+      expect(created).toBeTruthy();
+      if (!created) return;
+
+      expect(created.type).toBe('singleSelect');
+      expect(created.isLookup).toBe(true);
+      expect(created.options?.choices).toEqual(expectedChoices);
+
+      const persistedField = (await getTableById(hostTableId)).fields.find(
+        (field) => field.id === conditionalLookupFieldId
+      ) as
+        | {
+            options?: {
+              choices?: Array<{ id: string; name: string; color: string }>;
+            };
+          }
+        | undefined;
+      expect(persistedField?.options?.choices).toEqual(expectedChoices);
+
+      await ctx.deleteField({ tableId: hostTableId, fieldId: conditionalLookupFieldId });
+      await ctx.deleteField({ tableId: hostTableId, fieldId: hostCategoryFieldId });
+      await ctx.deleteField({ tableId: foreignTableId, fieldId: importanceFieldId });
+      await ctx.deleteField({ tableId: foreignTableId, fieldId: categoryFieldId });
+    });
+
     it('rejects conditionalLookup as primary field', async () => {
       const { status } = await createField(hostTableId, {
         type: 'conditionalLookup',
diff --git a/packages/v2/e2e/src/create-field/button/button.spec.ts b/packages/v2/e2e/src/create-field/button/button.spec.ts
index bb0877c00f..98f90fce7a 100644
--- a/packages/v2/e2e/src/create-field/button/button.spec.ts
+++ b/packages/v2/e2e/src/create-field/button/button.spec.ts
@@ -56,4 +56,101 @@ describe('create-field: button v1 parity', () => {
       if (tableId) await ctx.deleteTable(tableId).catch(() => undefined);
     }
   });
+
+  test('button field confirm config is persisted when updating field options', async () => {
+    let tableId: string | undefined;
+
+    try {
+      const table = await ctx.createTable({
+        baseId: ctx.baseId,
+        name: nextName('v2-update-reg-button-confirm'),
+        fields: [{ type: 'singleLineText', name: 'Name', isPrimary: true }],
+      });
+      tableId = table.id;
+
+      const withButton = await ctx.createField({
+        baseId: ctx.baseId,
+        tableId,
+        field: {
+          type: 'button',
+          name: 'Button',
+          options: {
+            label: 'Send',
+            color: 'teal',
+            workflow: {
+              id: 'wfl00000000000000001',
+              name: 'Workflow',
+              isActive: true,
+            },
+          },
+        },
+      });
+
+      const buttonField = withButton.fields.find((f) => f.name === 'Button') as
+        | { id: string }
+        | undefined;
+      if (!buttonField) throw new Error('Missing button field');
+
+      const updated = await ctx.updateField({
+        tableId,
+        fieldId: buttonField.id,
+        field: {
+          type: 'button',
+          options: {
+            label: 'Send',
+            color: 'teal',
+            workflow: {
+              id: 'wfl00000000000000001',
+              name: 'Workflow',
+              isActive: true,
+            },
+            confirm: {
+              title: 'Y',
+              description: '123',
+              confirmText: 'Y',
+            },
+          },
+        },
+      });
+
+      const updatedButton = updated.fields.find((f) => f.id === buttonField.id) as
+        | {
+            options?: {
+              confirm?: {
+                title?: string;
+                description?: string;
+                confirmText?: string;
+              };
+            };
+          }
+        | undefined;
+
+      expect(updatedButton?.options?.confirm).toEqual({
+        title: 'Y',
+        description: '123',
+        confirmText: 'Y',
+      });
+
+      const refreshed = await ctx.getTableById(table.id);
+      const refreshedButton = refreshed.fields.find((f) => f.id === buttonField.id) as
+        | {
+            options?: {
+              confirm?: {
+                title?: string;
+                description?: string;
+                confirmText?: string;
+              };
+            };
+          }
+        | undefined;
+
+      expect(refreshedButton?.options?.confirm).toEqual({
+        title: 'Y',
+        description: '123',
+        confirmText: 'Y',
+      });
+    } finally {
+      if (tableId) await ctx.deleteTable(tableId).catch(() => undefined);
+    }
+  });
 });
diff --git a/packages/v2/e2e/src/link-migration-compat.e2e.spec.ts b/packages/v2/e2e/src/link-migration-compat.e2e.spec.ts
new file mode 100644
index 0000000000..5bb775abdc
--- /dev/null
+++ b/packages/v2/e2e/src/link-migration-compat.e2e.spec.ts
@@ -0,0 +1,593 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import {
+  createRecordOkResponseSchema,
+  createRecordsOkResponseSchema,
+  createTableOkResponseSchema,
+  listTableRecordsOkResponseSchema,
+  updateRecordOkResponseSchema,
+  updateRecordsOkResponseSchema,
+} from '@teable/v2-contract-http';
+import type { ICreateTableCommandInput } from '@teable/v2-core';
+import { FieldKeyType } from '@teable/v2-core';
+import { beforeAll, describe, expect, it } from 'vitest';
+import { getSharedTestContext, type SharedTestContext } from './shared/globalTestContext';
+
+/**
+ * E2E test: reproduce the migration script link bug step by step.
+ *
+ * Migration script pattern:
+ *   Phase 1 – create records WITHOUT link values (skip link fields)
+ *   Phase 2 – use ID mapping to PATCH/update link fields
+ *
+ * Each step logs its raw input and output so we can see exactly where IDs diverge.
+ */
+describe('v2 link migration compatibility – step-by-step debug', () => {
+  let ctx: SharedTestContext;
+
+  // -------- helpers (thin wrappers that return raw JSON for inspection) --------
+
+  async function apiPost(path: string, body: Record<string, unknown>) {
+    const response = await fetch(`${ctx.baseUrl}${path}`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    const raw = await response.json();
+    return { status: response.status, body: raw };
+  }
+
+  async function apiGet(path: string) {
+    const response = await fetch(`${ctx.baseUrl}${path}`);
+    const raw = await response.json();
+    return { status: response.status, body: raw };
+  }
+
+  beforeAll(async () => {
+    ctx = await getSharedTestContext();
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  //  Scenario 1 – Two-phase migration: create → update links (fieldKeyType=id)
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  describe('Scenario 1: two-phase create→update link by fieldId', () => {
+    // Table & field IDs filled by beforeAll
+    let speakersTableId: string;
+    let esTableId: string;
+    let speakerNameFieldId: string;
+    let esTitleFieldId: string;
+    let esLinkFieldId: string;
+
+    // Record IDs – the "ID mapping" that the script would produce
+    let spkAliceId: string;
+    let spkBobId: string;
+    let es001Id: string;
+    let es002Id: string;
+
+    // ---- Step 1: Create tables ----
+    beforeAll(async () => {
+      console.log('\n======= Scenario 1 – Step 1: Create tables =======');
+
+      const spkRes = await apiPost('/tables/create', {
+        baseId: ctx.baseId,
+        name: `S1_Speakers_${Date.now()}`,
+        fields: [{ type: 'singleLineText', name: 'Full Name', isPrimary: true }],
+        views: [{ type: 'grid' }],
+      } satisfies ICreateTableCommandInput);
+      const spkTable = createTableOkResponseSchema.parse(spkRes.body).data.table;
+      speakersTableId = spkTable.id;
+      speakerNameFieldId = spkTable.fields.find((f) => f.name === 'Full Name')!.id;
+      console.log('  Speakers table created:', speakersTableId);
+      console.log('  Speakers fields:', JSON.stringify(spkTable.fields, null, 2));
+
+      const esRes = await apiPost('/tables/create', {
+        baseId: ctx.baseId,
+        name: `S1_EventSpeakers_${Date.now()}`,
+        fields: [
+          { type: 'singleLineText', name: 'ESID', isPrimary: true },
+          {
+            type: 'link',
+            name: 'Speaker',
+            options: {
+              relationship: 'manyMany',
+              foreignTableId: speakersTableId,
+              lookupFieldId: speakerNameFieldId,
+              isOneWay: false, // two-way link
+            },
+          },
+        ],
+        views: [{ type: 'grid' }],
+      } satisfies ICreateTableCommandInput);
+      const esTable = createTableOkResponseSchema.parse(esRes.body).data.table;
+      esTableId = esTable.id;
+      esTitleFieldId = esTable.fields.find((f) => f.name === 'ESID')!.id;
+      esLinkFieldId = esTable.fields.find((f) => f.name === 'Speaker')!.id;
+      console.log('  EventSpeakers table created:', esTableId);
+      console.log('  EventSpeakers fields:', JSON.stringify(esTable.fields, null, 2));
+      console.log('  Link field ID:', esLinkFieldId);
+    });
+
+    // ---- Step 2: Phase 1 – Create records WITHOUT link values ----
+    it('Step 2 – Phase 1: create Speaker records (foreign table)', async () => {
+      console.log('\n======= Step 2: Create Speaker records =======');
+
+      const r1 = await apiPost('/tables/createRecord', {
+        tableId: speakersTableId,
+        fields: { [speakerNameFieldId]: 'Alice Johnson' },
+        fieldKeyType: FieldKeyType.Id,
+      });
+      spkAliceId = createRecordOkResponseSchema.parse(r1.body).data.record.id;
+      console.log('  Alice record ID:', spkAliceId);
+      console.log(
+        '  Alice response fields:',
+        JSON.stringify(createRecordOkResponseSchema.parse(r1.body).data.record.fields)
+      );
+
+      const r2 = await apiPost('/tables/createRecord', {
+        tableId: speakersTableId,
+        fields: { [speakerNameFieldId]: 'Bob Smith' },
+        fieldKeyType: FieldKeyType.Id,
+      });
+      spkBobId = createRecordOkResponseSchema.parse(r2.body).data.record.id;
+      console.log('  Bob record ID:', spkBobId);
+
+      expect(spkAliceId).toMatch(/^rec/);
+      expect(spkBobId).toMatch(/^rec/);
+    });
+
+    it('Step 3 – Phase 1: create EventSpeaker records WITHOUT link values', async () => {
+      console.log('\n======= Step 3: Create EventSpeaker records (no links) =======');
+
+      const r1 = await apiPost('/tables/createRecord', {
+        tableId: esTableId,
+        fields: { [esTitleFieldId]: 'ES001' },
+        fieldKeyType: FieldKeyType.Id,
+      });
+      const rec1 = createRecordOkResponseSchema.parse(r1.body).data.record;
+      es001Id = rec1.id;
+      console.log('  ES001 record ID:', es001Id);
+      console.log('  ES001 fields:', JSON.stringify(rec1.fields));
+
+      const r2 = await apiPost('/tables/createRecord', {
+        tableId: esTableId,
+        fields: { [esTitleFieldId]: 'ES002' },
+        fieldKeyType: FieldKeyType.Id,
+      });
+      const rec2 = createRecordOkResponseSchema.parse(r2.body).data.record;
+      es002Id = rec2.id;
+      console.log('  ES002 record ID:', es002Id);
+      console.log('  ES002 fields:', JSON.stringify(rec2.fields));
+
+      // Link field should be empty/null at this point
+      expect(rec1.fields[esLinkFieldId]).toBeOneOf([null, undefined, []]);
+    });
+
+    it('Step 4 – Phase 2: update ES001 to link to Alice (by field ID)', async () => {
+      console.log('\n======= Step 4: Update ES001 → link Alice =======');
+      console.log('  Input: recordId =', es001Id);
+      console.log('  Input: link field ID =', esLinkFieldId);
+      console.log('  Input: link value =', JSON.stringify([{ id: spkAliceId }]));
+
+      const res = await apiPost('/tables/updateRecord', {
+        tableId: esTableId,
+        recordId: es001Id,
+        fields: { [esLinkFieldId]: [{ id: spkAliceId }] },
+        fieldKeyType: FieldKeyType.Id,
+        typecast: true,
+      });
+
+      console.log('  Response status:', res.status);
+      console.log('  Response body:', JSON.stringify(res.body, null, 2));
+
+      expect(res.status).toBe(200);
+      const parsed = updateRecordOkResponseSchema.parse(res.body);
+      const updatedFields = parsed.data.record.fields;
+      console.log('  Updated record fields:', JSON.stringify(updatedFields));
+
+      // Check the link value in the response
+      const linkVal = updatedFields[esLinkFieldId] as Array<{ id: string; title?: string }> | null;
+      console.log('  Link value after update:', JSON.stringify(linkVal));
+
+      expect(linkVal).not.toBeNull();
+      expect(Array.isArray(linkVal)).toBe(true);
+      expect(linkVal!.length).toBe(1);
+      expect(linkVal![0].id).toBe(spkAliceId);
+      console.log('  Link ID matches: ✅', linkVal![0].id, '===', spkAliceId);
+      // Note: title in updateRecord response may be undefined since it's returned
+      // from in-memory record before the DB title-fill statement runs.
+      // The title will be correct when reading via listRecords.
+      console.log('  Link title in response:', linkVal![0].title ?? '(not yet filled - OK)');
+    });
+
+    it('Step 5 – Phase 2: update ES002 to link to Bob (by field ID)', async () => {
+      console.log('\n======= Step 5: Update ES002 → link Bob =======');
+      console.log('  Input: link value =', JSON.stringify([{ id: spkBobId }]));
+
+      const res = await apiPost('/tables/updateRecord', {
+        tableId: esTableId,
+        recordId: es002Id,
+        fields: { [esLinkFieldId]: [{ id: spkBobId }] },
+        fieldKeyType: FieldKeyType.Id,
+        typecast: true,
+      });
+
+      console.log('  Response status:', res.status);
+      const parsed = updateRecordOkResponseSchema.parse(res.body);
+      const linkVal = parsed.data.record.fields[esLinkFieldId] as Array<{
+        id: string;
+        title?: string;
+      }> | null;
+      console.log('  Link value after update:', JSON.stringify(linkVal));
+      console.log('  Link title in response:', linkVal?.[0]?.title ?? '(not yet filled - OK)');
+
+      expect(linkVal).not.toBeNull();
+      expect(linkVal!.length).toBe(1);
+      expect(linkVal![0].id).toBe(spkBobId);
+    });
+
+    it('Step 6 – Verify: listRecords on EventSpeakers – do link titles resolve?', async () => {
+      console.log('\n======= Step 6: listRecords – check titles =======');
+
+      const res = await apiGet(
+        `/tables/listRecords?tableId=${esTableId}&fieldKeyType=${FieldKeyType.Id}`
+      );
+      expect(res.status).toBe(200);
+      const records = listTableRecordsOkResponseSchema.parse(res.body).data.records;
+
+      for (const rec of records) {
+        const title = rec.fields[esTitleFieldId];
+        const linkVal = rec.fields[esLinkFieldId] as Array<{
+          id: string;
+          title?: string;
+        }> | null;
+        console.log(`  Record ${rec.id} (${title}):`);
+        console.log(`    link field value: ${JSON.stringify(linkVal)}`);
+        if (linkVal) {
+          for (const link of linkVal) {
+            console.log(`    → linked ID: ${link.id}, title: ${link.title ?? '❌ undefined'}`);
+          }
+        }
+      }
+
+      // Check ES001 → Alice
+      const es001 = records.find((r) => r.fields[esTitleFieldId] === 'ES001');
+      const es001Links = es001?.fields[esLinkFieldId] as Array<{
+        id: string;
+        title?: string;
+      }>;
+      expect(es001Links).toHaveLength(1);
+      expect(es001Links[0].id).toBe(spkAliceId);
+      // This is the key assertion – does title resolve?
+      expect(es001Links[0].title).toBe('Alice Johnson');
+    });
+
+    // TODO: Symmetric link population after updateRecord requires the computed update pipeline
+    // to detect junction changes and rebuild the symmetric field's JSON value on the foreign table.
+    // This is a separate issue from title resolution.
+    it.todo('Step 7 – symmetric link on Speakers table populated after updateRecord');
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  //  Scenario 2 – Create records with inline link values (fieldKeyType=name)
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  describe('Scenario 2: createRecords inline link (fieldKeyType=name, typecast=true)', () => {
+    let foreignTableId: string;
+    let mainTableId: string;
+    let foreignTitleFieldId: string;
+    let foreignRecId1: string;
+    let foreignRecId2: string;
+
+    beforeAll(async () => {
+      console.log('\n======= Scenario 2 – Setup =======');
+
+      const fRes = await apiPost('/tables/create', {
+        baseId: ctx.baseId,
+        name: `S2_Foreign_${Date.now()}`,
+        fields: [{ type: 'singleLineText', name: 'Title', isPrimary: true }],
+        views: [{ type: 'grid' }],
+      } satisfies ICreateTableCommandInput);
+      const fTable = createTableOkResponseSchema.parse(fRes.body).data.table;
+      foreignTableId = fTable.id;
+      foreignTitleFieldId = fTable.fields.find((f) => f.name === 'Title')!.id;
+
+      const fr1 = await apiPost('/tables/createRecord', {
+        tableId: foreignTableId,
+        fields: { [foreignTitleFieldId]: 'Target A' },
+        fieldKeyType: FieldKeyType.Id,
+      });
+      foreignRecId1 = createRecordOkResponseSchema.parse(fr1.body).data.record.id;
+
+      const fr2 = await apiPost('/tables/createRecord', {
+        tableId: foreignTableId,
+        fields: { [foreignTitleFieldId]: 'Target B' },
+        fieldKeyType: FieldKeyType.Id,
+      });
+      foreignRecId2 = createRecordOkResponseSchema.parse(fr2.body).data.record.id;
+      console.log('  Foreign records:', foreignRecId1, foreignRecId2);
+
+      const mRes = await apiPost('/tables/create', {
+        baseId: ctx.baseId,
+        name: `S2_Main_${Date.now()}`,
+        fields: [
+          { type: 'singleLineText', name: 'Name', isPrimary: true },
+          {
+            type: 'link',
+            name: 'Links',
+            options: {
+              relationship: 'manyMany',
+              foreignTableId,
+              lookupFieldId: foreignTitleFieldId,
+              isOneWay: false,
+            },
+          },
+        ],
+        views: [{ type: 'grid' }],
+      } satisfies ICreateTableCommandInput);
+      const mTable = createTableOkResponseSchema.parse(mRes.body).data.table;
+      mainTableId = mTable.id;
+      console.log('  Main table:', mainTableId);
+      console.log('  Main fields:', JSON.stringify(mTable.fields, null, 2));
+    });
+
+    it('createRecords with {id,title} objects via fieldKeyType=name, typecast=true', async () => {
+      console.log('\n======= Scenario 2 – createRecords with {id,title} =======');
+
+      const inputRecords = [
+        {
+          fields: {
+            Name: 'Inline Link 1',
+            Links: [{ id: foreignRecId1, title: 'Target A' }],
+          },
+        },
+        {
+          fields: {
+            Name: 'Inline Link 2',
+            Links: [{ id: foreignRecId1 }, { id: foreignRecId2 }],
+          },
+        },
+        {
+          fields: {
+            Name: 'No Links',
+          },
+        },
+      ];
+      console.log('  Input:', JSON.stringify(inputRecords, null, 2));
+
+      const res = await apiPost('/tables/createRecords', {
+        tableId: mainTableId,
+        records: inputRecords,
+        fieldKeyType: FieldKeyType.Name,
+        typecast: true,
+      });
+
+      console.log('  Response status:', res.status);
+      const created = createRecordsOkResponseSchema.parse(res.body).data.records;
+      for (const rec of created) {
+        console.log(`  Created ${rec.id}:`, JSON.stringify(rec.fields));
+      }
+      expect(created).toHaveLength(3);
+
+      // Now list and check titles
+      console.log('\n  --- listRecords after create ---');
+      const listRes = await apiGet(
+        `/tables/listRecords?tableId=${mainTableId}&fieldKeyType=${FieldKeyType.Name}`
+      );
+      const records = listTableRecordsOkResponseSchema.parse(listRes.body).data.records;
+      for (const rec of records) {
+        console.log(`  ${rec.id}: ${JSON.stringify(rec.fields)}`);
+      }
+
+      const r1 = records.find((r) => r.fields['Name'] === 'Inline Link 1');
+      const links1 = r1?.fields['Links'] as Array<{ id: string; title?: string }>;
+      console.log('  Inline Link 1 → Links:', JSON.stringify(links1));
+      expect(links1).toHaveLength(1);
+      expect(links1[0].id).toBe(foreignRecId1);
+      expect(links1[0].title).toBe('Target A');
+    });
+
+    it('createRecords with plain record ID strings ["recXxx"]', async () => {
+      console.log('\n======= Scenario 2 – createRecords with string IDs =======');
+
+      const inputRecords = [
+        {
+          fields: {
+            Name: 'String IDs',
+            Links: [foreignRecId1, foreignRecId2], // plain strings, not objects
+          },
+        },
+      ];
+      console.log('  Input:', JSON.stringify(inputRecords));
+      console.log('  (note: Links value is string array, not {id} objects)');
+
+      const res = await apiPost('/tables/createRecords', {
+        tableId: mainTableId,
+        records: inputRecords,
+        fieldKeyType: FieldKeyType.Name,
+        typecast: true,
+      });
+
+      console.log('  Response status:', res.status);
+      if (res.status === 201) {
+        const created = createRecordsOkResponseSchema.parse(res.body).data.records;
+        for (const rec of created) {
+          console.log(`  Created ${rec.id}:`, JSON.stringify(rec.fields));
+        }
+      } else {
+        console.log('  ERROR body:', JSON.stringify(res.body));
+      }
+
+      // List and check
+      const listRes = await apiGet(
+        `/tables/listRecords?tableId=${mainTableId}&fieldKeyType=${FieldKeyType.Name}`
+      );
+      const records = listTableRecordsOkResponseSchema.parse(listRes.body).data.records;
+      const found = records.find((r) => r.fields['Name'] === 'String IDs');
+      const links = found?.fields['Links'] as Array<{ id: string; title?: string }>;
+      console.log('  After list – String IDs links:', JSON.stringify(links));
+
+      expect(links).toHaveLength(2);
+      expect(links.map((l) => l.id).sort()).toEqual([foreignRecId1, foreignRecId2].sort());
+      // Key: does title resolve?
+      console.log(
+        '  Titles:',
+        links.map((l) => l.title)
+      );
+      expect(links[0].title).toBeDefined();
+      expect(links[0].title).not.toBeNull();
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  //  Scenario 3 – Batch updateRecords with fieldKeyType=name + typecast=true
+  //  This is the closest to the actual migration script Phase 2.
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  describe('Scenario 3: batch updateRecords (fieldKeyType=name, typecast=true)', () => {
+    let foreignTableId: string;
+    let mainTableId: string;
+    let foreignTitleFieldId: string;
+    let foreignRecId1: string;
+    let foreignRecId2: string;
+    let mainRec1Id: string;
+    let mainRec2Id: string;
+
+    beforeAll(async () => {
+      console.log('\n======= Scenario 3 – Setup =======');
+
+      const fRes = await apiPost('/tables/create', {
+        baseId: ctx.baseId,
+        name: `S3_Foreign_${Date.now()}`,
+        fields: [{ type: 'singleLineText', name: 'Title', isPrimary: true }],
+        views: [{ type: 'grid' }],
+      } satisfies ICreateTableCommandInput);
+      const fTable = createTableOkResponseSchema.parse(fRes.body).data.table;
+      foreignTableId = fTable.id;
+      foreignTitleFieldId = fTable.fields.find((f) => f.name === 'Title')!.id;
+
+      const fr1 = await apiPost('/tables/createRecord', {
+        tableId: foreignTableId,
+        fields: { [foreignTitleFieldId]: 'Batch Target 1' },
+        fieldKeyType: FieldKeyType.Id,
+      });
+      foreignRecId1 = createRecordOkResponseSchema.parse(fr1.body).data.record.id;
+
+      const fr2 = await apiPost('/tables/createRecord', {
+        tableId: foreignTableId,
+        fields: { [foreignTitleFieldId]: 'Batch Target 2' },
+        fieldKeyType: FieldKeyType.Id,
+      });
+      foreignRecId2 = createRecordOkResponseSchema.parse(fr2.body).data.record.id;
+      console.log('  Foreign records:', foreignRecId1, foreignRecId2);
+
+      const mRes = await apiPost('/tables/create', {
+        baseId: ctx.baseId,
+        name: `S3_Main_${Date.now()}`,
+        fields: [
+          { type: 'singleLineText', name: 'Name', isPrimary: true },
+          {
+            type: 'link',
+            name: 'Links',
+            options: {
+              relationship: 'manyMany',
+              foreignTableId,
+              lookupFieldId: foreignTitleFieldId,
+              isOneWay: false,
+            },
+          },
+        ],
+        views: [{ type: 'grid' }],
+      } satisfies ICreateTableCommandInput);
+      const mTable = createTableOkResponseSchema.parse(mRes.body).data.table;
+      mainTableId = mTable.id;
+
+      // Phase 1: create records without links
+      const cr = await apiPost('/tables/createRecords', {
+        tableId: mainTableId,
+        records: [{ fields: { Name: 'Main 1' } }, { fields: { Name: 'Main 2' } }],
+        fieldKeyType: FieldKeyType.Name,
+        typecast: true,
+      });
+      const createdRecords = createRecordsOkResponseSchema.parse(cr.body).data.records;
+      mainRec1Id = createdRecords[0].id;
+      mainRec2Id = createdRecords[1].id;
+      console.log('  Main records (no links):', mainRec1Id, mainRec2Id);
+    });
+
+    it('Phase 2: batch updateRecords with link by field name + typecast', async () => {
+      console.log('\n======= Scenario 3 – batch updateRecords =======');
+
+      const inputBody = {
+        tableId: mainTableId,
+        records: [
+          {
+            id: mainRec1Id,
+            fields: {
+              Links: [{ id: foreignRecId1 }],
+            },
+          },
+          {
+            id: mainRec2Id,
+            fields: {
+              Links: [{ id: foreignRecId1 }, { id: foreignRecId2 }],
+            },
+          },
+        ],
+        fieldKeyType: FieldKeyType.Name,
+        typecast: true,
+      };
+      console.log('  Input body:', JSON.stringify(inputBody, null, 2));
+
+      const res = await apiPost('/tables/updateRecords', inputBody);
+      console.log('  Response status:', res.status);
+      console.log('  Response body:', JSON.stringify(res.body, null, 2));
+
+      if (res.status === 200) {
+        console.log('  ✅ batch updateRecords succeeded');
+        // Response is { ok: true, data: { updatedCount: N } }
+        expect(res.body.ok).toBe(true);
+        expect(res.body.data.updatedCount).toBe(2);
+      } else {
+        console.log('  ❌ updateRecords FAILED with status', res.status);
+        // Still report what the error is
+        expect(res.status).toBe(200);
+      }
+    });
+
+    it('Verify: listRecords after batch update – titles resolve?', async () => {
+      console.log('\n======= Scenario 3 – Verify after batch update =======');
+
+      const listRes = await apiGet(
+        `/tables/listRecords?tableId=${mainTableId}&fieldKeyType=${FieldKeyType.Name}`
+      );
+      const records = listTableRecordsOkResponseSchema.parse(listRes.body).data.records;
+
+      for (const rec of records) {
+        console.log(`  ${rec.id}: ${JSON.stringify(rec.fields)}`);
+      }
+
+      const r1 = records.find((r) => r.fields['Name'] === 'Main 1');
+      const r2 = records.find((r) => r.fields['Name'] === 'Main 2');
+
+      const links1 = r1?.fields['Links'] as Array<{ id: string; title?: string }> | null;
+      const links2 = r2?.fields['Links'] as Array<{ id: string; title?: string }> | null;
+
+      console.log('  Main 1 links:', JSON.stringify(links1));
+      console.log('  Main 2 links:', JSON.stringify(links2));
+
+      // If batch update succeeded, verify titles
+      if (links1 && links1.length > 0) {
+        expect(links1[0].id).toBe(foreignRecId1);
+        console.log('  Main 1 title:', links1[0].title ?? '❌ undefined');
+        expect(links1[0].title).toBe('Batch Target 1');
+      }
+
+      if (links2 && links2.length > 0) {
+        expect(links2).toHaveLength(2);
+        for (const link of links2) {
+          console.log(`  Main 2 → ${link.id}, title: ${link.title ?? '❌ undefined'}`);
+        }
+      }
+    });
+  });
+});
diff --git a/packages/v2/e2e/src/lookup-auto-number.e2e.spec.ts b/packages/v2/e2e/src/lookup-auto-number.e2e.spec.ts
new file mode 100644
index 0000000000..2fc76295aa
--- /dev/null
+++ b/packages/v2/e2e/src/lookup-auto-number.e2e.spec.ts
@@ -0,0 +1,175 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { beforeAll, describe, expect, test } from 'vitest';
+
+import { getSharedTestContext, type SharedTestContext } from './shared/globalTestContext';
+
+let fieldIdCounter = 0;
+let tableNameCounter = 0;
+
+const createFieldId = () => {
+  const suffix = fieldIdCounter.toString(36).padStart(16, '0');
+  fieldIdCounter += 1;
+  return `fld${suffix}`;
+};
+
+const uniqueTableName = (prefix: string) => {
+  tableNameCounter += 1;
+  return `${prefix}-${tableNameCounter}-${Date.now()}`;
+};
+
+const deleteTableSafe = async (ctx: SharedTestContext, tableId: string | undefined) => {
+  if (!tableId) return;
+  try {
+    await ctx.deleteTable(tableId);
+  } catch {
+    return undefined;
+  }
+};
+
+const valueAt = (value: unknown) => {
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return value;
+};
+
+describe('lookup autoNumber regression', () => {
+  let ctx: SharedTestContext;
+
+  beforeAll(async () => {
+    ctx = await getSharedTestContext();
+  });
+
+  test('uses the linked record auto number instead of the host row auto number', async () => {
+    let sourceTableId: string | undefined;
+    let hostTableId: string | undefined;
+
+    try {
+      const sourceNameFieldId = createFieldId();
+      const sourceAutoNumberFieldId = createFieldId();
+      const sourceNumberFieldId = createFieldId();
+      const hostNameFieldId = createFieldId();
+      const hostLinkFieldId = createFieldId();
+      const hostLookupAutoNumberFieldId = createFieldId();
+      const hostLookupNumberFieldId = createFieldId();
+      const hostRollupAutoNumberFieldId = createFieldId();
+
+      const sourceTable = await ctx.createTable({
+        baseId: ctx.baseId,
+        name: uniqueTableName('LookupAutoNumberSource'),
+        fields: [
+          { type: 'singleLineText', id: sourceNameFieldId, name: 'Name', isPrimary: true },
+          { type: 'autoNumber', id: sourceAutoNumberFieldId, name: 'AutoNum' },
+          { type: 'number', id: sourceNumberFieldId, name: 'Number' },
+        ],
+        views: [{ type: 'grid' }],
+      });
+      sourceTableId = sourceTable.id;
+
+      const hostTable = await ctx.createTable({
+        baseId: ctx.baseId,
+        name: uniqueTableName('LookupAutoNumberHost'),
+        fields: [
+          { type: 'singleLineText', id: hostNameFieldId, name: 'Name', isPrimary: true },
+          {
+            type: 'link',
+            id: hostLinkFieldId,
+            name: 'Link to Source',
+            options: {
+              relationship: 'manyMany',
+              foreignTableId: sourceTable.id,
+              lookupFieldId: sourceNameFieldId,
+            },
+          },
+          {
+            type: 'lookup',
+            id: hostLookupAutoNumberFieldId,
+            name: 'Lookup AutoNum',
+            options: {
+              linkFieldId: hostLinkFieldId,
+              foreignTableId: sourceTable.id,
+              lookupFieldId: sourceAutoNumberFieldId,
+            },
+          },
+          {
+            type: 'lookup',
+            id: hostLookupNumberFieldId,
+            name: 'Lookup Number',
+            options: {
+              linkFieldId: hostLinkFieldId,
+              foreignTableId: sourceTable.id,
+              lookupFieldId: sourceNumberFieldId,
+            },
+          },
+          {
+            type: 'rollup',
+            id: hostRollupAutoNumberFieldId,
+            name: 'Rollup AutoNum',
+            options: { expression: 'sum({values})' },
+            config: {
+              linkFieldId: hostLinkFieldId,
+              foreignTableId: sourceTable.id,
+              lookupFieldId: sourceAutoNumberFieldId,
+            },
+          },
+        ],
+        views: [{ type: 'grid' }],
+      });
+      hostTableId = hostTable.id;
+
+      const hostTableMeta = await ctx.getTableById(hostTable.id);
+      const lookupAutoNumberField = hostTableMeta.fields.find(
+        (field) => field.id === hostLookupAutoNumberFieldId
+      );
+      expect(lookupAutoNumberField?.type).toBe('autoNumber');
+      expect(lookupAutoNumberField?.isLookup).toBe(true);
+      expect(lookupAutoNumberField?.options).toEqual({ expression: 'AUTO_NUMBER()' });
+
+      const source1 = await ctx.createRecord(sourceTable.id, {
+        [sourceNameFieldId]: 'Record A1',
+        [sourceNumberFieldId]: 1,
+      });
+      const source2 = await ctx.createRecord(sourceTable.id, {
+        [sourceNameFieldId]: 'Record A2',
+        [sourceNumberFieldId]: 2,
+      });
+      const source3 = await ctx.createRecord(sourceTable.id, {
+        [sourceNameFieldId]: 'Record A3',
+        [sourceNumberFieldId]: 3,
+      });
+
+      const host1 = await ctx.createRecord(hostTable.id, {
+        [hostNameFieldId]: 'Row B1',
+        [hostLinkFieldId]: [{ id: source3.id }],
+      });
+      const host2 = await ctx.createRecord(hostTable.id, {
+        [hostNameFieldId]: 'Row B2',
+        [hostLinkFieldId]: [{ id: source1.id }],
+      });
+      const host3 = await ctx.createRecord(hostTable.id, {
+        [hostNameFieldId]: 'Row B3',
+        [hostLinkFieldId]: [{ id: source2.id }],
+      });
+
+      await ctx.drainOutbox();
+
+      const hostRecords = await ctx.listRecordsWithoutDrain(hostTable.id);
+      const byId = new Map(hostRecords.map((record) => [record.id, record]));
+
+      expect(byId.get(host1.id)?.fields[hostLookupNumberFieldId]).toEqual([3]);
+      expect(byId.get(host2.id)?.fields[hostLookupNumberFieldId]).toEqual([1]);
+      expect(byId.get(host3.id)?.fields[hostLookupNumberFieldId]).toEqual([2]);
+
+      expect(byId.get(host1.id)?.fields[hostRollupAutoNumberFieldId]).toBe(3);
+      expect(byId.get(host2.id)?.fields[hostRollupAutoNumberFieldId]).toBe(1);
+      expect(byId.get(host3.id)?.fields[hostRollupAutoNumberFieldId]).toBe(2);
+
+      expect(valueAt(byId.get(host1.id)?.fields[hostLookupAutoNumberFieldId])).toBe(3);
+      expect(valueAt(byId.get(host2.id)?.fields[hostLookupAutoNumberFieldId])).toBe(1);
+      expect(valueAt(byId.get(host3.id)?.fields[hostLookupAutoNumberFieldId])).toBe(2);
+    } finally {
+      await deleteTableSafe(ctx, hostTableId);
+      await deleteTableSafe(ctx, sourceTableId);
+    }
+  });
+});
diff --git a/packages/v2/e2e/src/update-field/conditionalLookup/update-properties.spec.ts b/packages/v2/e2e/src/update-field/conditionalLookup/update-properties.spec.ts
index 5f791b06e6..6fe72df976 100644
--- a/packages/v2/e2e/src/update-field/conditionalLookup/update-properties.spec.ts
+++ b/packages/v2/e2e/src/update-field/conditionalLookup/update-properties.spec.ts
@@ -236,6 +236,123 @@ describe('update-field: conditionalLookup property updates', () => {
     await ctx.deleteField({ tableId: hostTableId, fieldId });
   });
 
+  test('should clear sort and limit when condition update omits them', async () => {
+    const fieldId = createFieldId();
+    const foreignStatus = await ctx.createField({
+      baseId: ctx.baseId,
+      tableId: foreignTableId,
+      field: { type: 'singleLineText', name: `Status ${fieldId}` },
+    });
+    const statusField = foreignStatus.fields.find((f) => f.name === `Status ${fieldId}`);
+    if (!statusField) throw new Error('No foreign status field');
+
+    const hostFilter = await ctx.createField({
+      baseId: ctx.baseId,
+      tableId: hostTableId,
+      field: { type: 'singleLineText', name: `Filter ${fieldId}` },
+    });
+    const hostFilterField = hostFilter.fields.find((f) => f.name === `Filter ${fieldId}`);
+    if (!hostFilterField) throw new Error('No host filter field');
+
+    const foreignRow1 = await ctx.createRecord(foreignTableId, {
+      [foreignPrimaryFieldId]: `row-1-${fieldId}`,
+      [statusField.id]: 'Active',
+      [foreignNumberFieldId]: 10,
+    });
+    const foreignRow2 = await ctx.createRecord(foreignTableId, {
+      [foreignPrimaryFieldId]: `row-2-${fieldId}`,
+      [statusField.id]: 'Active',
+      [foreignNumberFieldId]: 20,
+    });
+    const hostRow = await ctx.createRecord(hostTableId, {
+      [hostPrimaryFieldId]: `host-${fieldId}`,
+      [hostFilterField.id]: 'Active',
+    });
+
+    await ctx.createField({
+      baseId: ctx.baseId,
+      tableId: hostTableId,
+      field: {
+        type: 'conditionalLookup',
+        id: fieldId,
+        name: `CL Clear Sort ${fieldId}`,
+        options: {
+          foreignTableId,
+          lookupFieldId: foreignPrimaryFieldId,
+          condition: {
+            filter: {
+              conjunction: 'and',
+              filterSet: [
+                {
+                  fieldId: statusField.id,
+                  operator: 'is',
+                  value: { type: 'field', fieldId: hostFilterField.id },
+                },
+              ],
+            },
+            sort: { fieldId: foreignNumberFieldId, order: 'desc' as const },
+            limit: 1,
+          },
+        },
+      },
+    });
+
+    const beforeRecords = await ctx.listRecords(hostTableId);
+    const beforeValue = beforeRecords.find((record) => record.id === hostRow.id)?.fields[
+      fieldId
+    ] as string[] | undefined;
+    expect(beforeValue).toEqual([foreignRow2.fields[foreignPrimaryFieldId]]);
+
+    const updatedTable = await ctx.updateField({
+      tableId: hostTableId,
+      fieldId,
+      field: {
+        options: {
+          foreignTableId,
+          lookupFieldId: foreignPrimaryFieldId,
+          condition: {
+            filter: {
+              conjunction: 'and',
+              filterSet: [
+                {
+                  fieldId: statusField.id,
+                  operator: 'is',
+                  value: { type: 'field', fieldId: hostFilterField.id },
+                },
+              ],
+            },
+          },
+        },
+      },
+    });
+
+    const updatedField = updatedTable.fields.find((f) => f.id === fieldId) as
+      | {
+          conditionalLookupOptions?: {
+            condition?: {
+              sort?: { fieldId?: string; order?: string };
+              limit?: number;
+            };
+          };
+        }
+      | undefined;
+    expect(updatedField?.conditionalLookupOptions?.condition?.sort).toBeUndefined();
+    expect(updatedField?.conditionalLookupOptions?.condition?.limit).toBeUndefined();
+
+    const afterRecords = await ctx.listRecords(hostTableId);
+    const afterValue = afterRecords.find((record) => record.id === hostRow.id)?.fields[fieldId] as
+      | string[]
+      | undefined;
+    expect([...(afterValue ?? [])].sort()).toEqual([
+      foreignRow1.fields[foreignPrimaryFieldId],
+      foreignRow2.fields[foreignPrimaryFieldId],
+    ]);
+
+    await ctx.deleteField({ tableId: hostTableId, fieldId });
+    await ctx.deleteField({ tableId: hostTableId, fieldId: hostFilterField.id });
+    await ctx.deleteField({ tableId: foreignTableId, fieldId: statusField.id });
+  });
+
   test('should change lookupFieldId', async () => {
     const fieldId = createFieldId();
     await ctx.createField({
diff --git a/packages/v2/e2e/src/update-field/conditionalRollup/update-properties.spec.ts b/packages/v2/e2e/src/update-field/conditionalRollup/update-properties.spec.ts
index 222be5b222..36d5082963 100644
--- a/packages/v2/e2e/src/update-field/conditionalRollup/update-properties.spec.ts
+++ b/packages/v2/e2e/src/update-field/conditionalRollup/update-properties.spec.ts
@@ -242,6 +242,127 @@ describe('update-field: conditionalRollup property updates', () => {
     await ctx.deleteField({ tableId: hostTableId, fieldId });
   });
 
+  test('should clear sort and limit when condition update omits them', async () => {
+    const fieldId = createFieldId();
+    const foreignStatus = await ctx.createField({
+      baseId: ctx.baseId,
+      tableId: foreignTableId,
+      field: { type: 'singleLineText', name: `Status ${fieldId}` },
+    });
+    const statusField = foreignStatus.fields.find((f) => f.name === `Status ${fieldId}`);
+    if (!statusField) throw new Error('No foreign status field');
+
+    const hostFilter = await ctx.createField({
+      baseId: ctx.baseId,
+      tableId: hostTableId,
+      field: { type: 'singleLineText', name: `Filter ${fieldId}` },
+    });
+    const hostFilterField = hostFilter.fields.find((f) => f.name === `Filter ${fieldId}`);
+    if (!hostFilterField) throw new Error('No host filter field');
+
+    const foreignRow1 = await ctx.createRecord(foreignTableId, {
+      [foreignPrimaryFieldId]: `row-1-${fieldId}`,
+      [statusField.id]: 'Active',
+      [foreignNumberFieldId]: 10,
+    });
+    const foreignRow2 = await ctx.createRecord(foreignTableId, {
+      [foreignPrimaryFieldId]: `row-2-${fieldId}`,
+      [statusField.id]: 'Active',
+      [foreignNumberFieldId]: 20,
+    });
+    const hostRow = await ctx.createRecord(hostTableId, {
+      [hostPrimaryFieldId]: `host-${fieldId}`,
+      [hostFilterField.id]: 'Active',
+    });
+
+    await ctx.createField({
+      baseId: ctx.baseId,
+      tableId: hostTableId,
+      field: {
+        type: 'conditionalRollup',
+        id: fieldId,
+        name: `CR Clear Sort ${fieldId}`,
+        options: {
+          expression: 'array_compact({values})',
+          timeZone: 'utc',
+        },
+        config: {
+          foreignTableId,
+          lookupFieldId: foreignPrimaryFieldId,
+          condition: {
+            filter: {
+              conjunction: 'and',
+              filterSet: [
+                {
+                  fieldId: statusField.id,
+                  operator: 'is',
+                  value: { type: 'field', fieldId: hostFilterField.id },
+                },
+              ],
+            },
+            sort: { fieldId: foreignNumberFieldId, order: 'desc' as const },
+            limit: 1,
+          },
+        },
+      },
+    });
+
+    const beforeRecords = await ctx.listRecords(hostTableId);
+    const beforeValue = beforeRecords.find((record) => record.id === hostRow.id)?.fields[
+      fieldId
+    ] as string[] | undefined;
+    expect(beforeValue).toEqual([foreignRow2.fields[foreignPrimaryFieldId]]);
+
+    const updatedTable = await ctx.updateField({
+      tableId: hostTableId,
+      fieldId,
+      field: {
+        config: {
+          foreignTableId,
+          lookupFieldId: foreignPrimaryFieldId,
+          condition: {
+            filter: {
+              conjunction: 'and',
+              filterSet: [
+                {
+                  fieldId: statusField.id,
+                  operator: 'is',
+                  value: { type: 'field', fieldId: hostFilterField.id },
+                },
+              ],
+            },
+          },
+        },
+      },
+    });
+
+    const updatedField = updatedTable.fields.find((f) => f.id === fieldId) as
+      | {
+          config?: {
+            condition?: {
+              sort?: { fieldId?: string; order?: string };
+              limit?: number;
+            };
+          };
+        }
+      | undefined;
+    expect(updatedField?.config?.condition?.sort).toBeUndefined();
+    expect(updatedField?.config?.condition?.limit).toBeUndefined();
+
+    const afterRecords = await ctx.listRecords(hostTableId);
+    const afterValue = afterRecords.find((record) => record.id === hostRow.id)?.fields[fieldId] as
+      | string[]
+      | undefined;
+    expect([...(afterValue ?? [])].sort()).toEqual([
+      foreignRow1.fields[foreignPrimaryFieldId],
+      foreignRow2.fields[foreignPrimaryFieldId],
+    ]);
+
+    await ctx.deleteField({ tableId: hostTableId, fieldId });
+    await ctx.deleteField({ tableId: hostTableId, fieldId: hostFilterField.id });
+    await ctx.deleteField({ tableId: foreignTableId, fieldId: statusField.id });
+  });
+
   test('should change lookupFieldId', async () => {
     const fieldId = createFieldId();
     await ctx.createField({
diff --git a/packages/v2/e2e/src/update-field/longText/update-properties.spec.ts b/packages/v2/e2e/src/update-field/longText/update-properties.spec.ts
index 963bb919ac..e0fddace41 100644
--- a/packages/v2/e2e/src/update-field/longText/update-properties.spec.ts
+++ b/packages/v2/e2e/src/update-field/longText/update-properties.spec.ts
@@ -26,7 +26,6 @@ const getChoiceNames = (field?: SelectFieldLike) =>
 describe('update-field: longText property updates', () => {
   let ctx: SharedTestContext;
   let tableId: string;
-  let primaryFieldId: string;
   let fieldIdCounter = 0;
 
   const createFieldId = () => {
@@ -46,7 +45,6 @@ describe('update-field: longText property updates', () => {
     tableId = table.id;
     const primaryField = table.fields.find((f) => f.isPrimary);
     if (!primaryField) throw new Error('No primary field');
-    primaryFieldId = primaryField.id;
   });
 
   afterAll(async () => {
diff --git a/packages/v2/e2e/src/update-field/lookup/update-properties.spec.ts b/packages/v2/e2e/src/update-field/lookup/update-properties.spec.ts
index abf63834ce..09a6a10b26 100644
--- a/packages/v2/e2e/src/update-field/lookup/update-properties.spec.ts
+++ b/packages/v2/e2e/src/update-field/lookup/update-properties.spec.ts
@@ -815,6 +815,88 @@ describe('update-field: lookup property updates', () => {
     await ctx.deleteField({ tableId: sourceTableId, fieldId: lookupField.id });
     await ctx.deleteField({ tableId: sourceTableId, fieldId: linkField.id });
   });
+
+  test('should keep lookup long text showAs cleared when API attempts to set markdown', async () => {
+    const foreignTableAfterLongText = await ctx.createField({
+      baseId: ctx.baseId,
+      tableId: foreignTableId,
+      field: {
+        type: 'longText',
+        name: 'Foreign Long Text',
+        options: {
+          showAs: { type: 'markdown' },
+        },
+      },
+    });
+    const foreignLongTextField = foreignTableAfterLongText.fields.find(
+      (f) => f.name === 'Foreign Long Text'
+    );
+    if (!foreignLongTextField) throw new Error('Foreign long text field not found');
+
+    const sourceWithLink = await ctx.createField({
+      baseId: ctx.baseId,
+      tableId: sourceTableId,
+      field: {
+        type: 'link',
+        name: 'Link Long Text',
+        options: {
+          foreignTableId,
+          relationship: 'manyMany',
+          lookupFieldId: foreignPrimaryFieldId,
+          isOneWay: true,
+        },
+      },
+    });
+    const linkField = sourceWithLink.fields.find((f) => f.name === 'Link Long Text');
+    if (!linkField) throw new Error('Link field not found');
+
+    const sourceWithLookup = await ctx.createField({
+      baseId: ctx.baseId,
+      tableId: sourceTableId,
+      field: {
+        type: 'lookup',
+        name: 'Lookup Long Text',
+        options: {
+          linkFieldId: linkField.id,
+          foreignTableId,
+          lookupFieldId: foreignLongTextField.id,
+        },
+      },
+    });
+    const lookupField = sourceWithLookup.fields.find((f) => f.name === 'Lookup Long Text');
+    if (!lookupField) throw new Error('Lookup field not found');
+    expect(lookupField.options?.showAs).toBeFalsy();
+
+    await ctx.updateField({
+      tableId: sourceTableId,
+      fieldId: lookupField.id,
+      field: {
+        options: { showAs: null },
+      },
+    });
+
+    const clearedField = await ctx
+      .getTableById(sourceTableId)
+      .then((table) => table.fields.find((f) => f.id === lookupField.id));
+    expect(clearedField?.options?.showAs).toBeFalsy();
+
+    await ctx.updateField({
+      tableId: sourceTableId,
+      fieldId: lookupField.id,
+      field: {
+        options: { showAs: { type: 'markdown' } },
+      },
+    });
+
+    const persistedField = await ctx
+      .getTableById(sourceTableId)
+      .then((table) => table.fields.find((f) => f.id === lookupField.id));
+    expect(persistedField?.options?.showAs).toBeFalsy();
+
+    await ctx.deleteField({ tableId: sourceTableId, fieldId: lookupField.id });
+    await ctx.deleteField({ tableId: sourceTableId, fieldId: linkField.id });
+    await ctx.deleteField({ tableId: foreignTableId, fieldId: foreignLongTextField.id });
+  });
 });
 
 describe('update-field: lookup conversions', () => {