diff --git a/apps/nestjs-backend/package.json b/apps/nestjs-backend/package.json
index 815a1d1654..b015e4a188 100644
--- a/apps/nestjs-backend/package.json
+++ b/apps/nestjs-backend/package.json
@@ -123,17 +123,18 @@
     "webpack": "5.91.0"
   },
   "dependencies": {
-    "@ai-sdk/amazon-bedrock": "4.0.69",
-    "@ai-sdk/anthropic": "3.0.50",
-    "@ai-sdk/azure": "3.0.38",
-    "@ai-sdk/cohere": "3.0.22",
-    "@ai-sdk/deepseek": "2.0.21",
-    "@ai-sdk/google": "3.0.34",
-    "@ai-sdk/mistral": "3.0.21",
-    "@ai-sdk/openai": "3.0.37",
-    "@ai-sdk/openai-compatible": "2.0.31",
-    "@ai-sdk/togetherai": "2.0.35",
-    "@ai-sdk/xai": "3.0.60",
+    "@ai-sdk/amazon-bedrock": "4.0.97",
+    "@ai-sdk/anthropic": "3.0.72",
+    "@ai-sdk/azure": "3.0.55",
+    "@ai-sdk/cohere": "3.0.31",
+    "@ai-sdk/deepseek": "2.0.30",
+    "@ai-sdk/google": "3.0.65",
+    "@ai-sdk/mistral": "3.0.31",
+    "@ai-sdk/openai": "3.0.54",
+    "@ai-sdk/openai-compatible": "2.0.42",
+    "@ai-sdk/provider": "3.0.9",
+    "@ai-sdk/togetherai": "2.0.46",
+    "@ai-sdk/xai": "3.0.84",
     "@an-epiphany/websocket-json-stream": "1.2.0",
     "@aws-sdk/client-s3": "3.609.0",
     "@aws-sdk/lib-storage": "3.609.0",
@@ -154,7 +155,7 @@
     "@nestjs/swagger": "7.3.0",
     "@nestjs/terminus": "10.2.3",
     "@nestjs/websockets": "10.3.5",
-    "@openrouter/ai-sdk-provider": "2.2.3",
+    "@openrouter/ai-sdk-provider": "2.8.1",
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/context-async-hooks": "2.5.0",
     "@opentelemetry/exporter-logs-otlp-http": "0.201.1",
@@ -193,7 +194,7 @@
     "@teable/v2-di": "workspace:*",
     "@teable/v2-import": "workspace:*",
     "@valibot/to-json-schema": "1.3.0",
-    "ai": "6.0.105",
+    "ai": "6.0.169",
     "ajv": "8.12.0",
     "archiver": "7.0.1",
     "axios": "1.7.7",
@@ -241,7 +242,7 @@
     "oauth2orize": "1.12.0",
     "oauth2orize-pkce": "0.1.2",
     "object-sizeof": "2.6.4",
-    "ollama-ai-provider-v2": "3.0.2",
+    "ollama-ai-provider-v2": "3.5.0",
     "p-limit": "3.1.0",
     "papaparse": "5.4.1",
     "passport": "0.7.0",
diff --git a/apps/nestjs-backend/src/cache/types.ts b/apps/nestjs-backend/src/cache/types.ts
index c200ccd5cd..942cc59623 100644
--- a/apps/nestjs-backend/src/cache/types.ts
+++ b/apps/nestjs-backend/src/cache/types.ts
@@ -36,6 +36,7 @@ export interface ICacheStore {
   [key: `oauth:token-rate:${string}:${string}`]: number;
   [key: `automation:email:rate:${string}:${number}`]: number;
   [key: `automation:email-att:${string}`]: string[];
+  [key: `automation:fail-notify-count:${string}`]: number;
   // Distributed lock keys
   [key: `lock:${string}`]: string;
   [key: `import:result:manifest:${string}`]: {
diff --git a/apps/nestjs-backend/src/db-provider/filter-query/__tests__/invalid-filter-skip.spec.ts b/apps/nestjs-backend/src/db-provider/filter-query/__tests__/invalid-filter-skip.spec.ts
new file mode 100644
index 0000000000..b058bbdc73
--- /dev/null
+++ b/apps/nestjs-backend/src/db-provider/filter-query/__tests__/invalid-filter-skip.spec.ts
@@ -0,0 +1,306 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import {
+  CellValueType,
+  DateFieldCore,
+  DateFormattingPreset,
+  DriverClient,
+  FieldType,
+  NumberFieldCore,
+  SingleLineTextFieldCore,
+  TimeFormatting,
+} from '@teable/core';
+import type { FieldCore, IFilter } from '@teable/core';
+import knex from 'knex';
+import type { IRecordQueryFilterContext } from '../../../features/record/query-builder/record-query-builder.interface';
+import type { IDbProvider } from '../../db.provider.interface';
+import type { AbstractCellValueFilter } from '../cell-value-filter.abstract';
+import { AbstractFilterQuery } from '../filter-query.abstract';
+import { FilterQueryPostgres } from '../postgres/filter-query.postgres';
+
+const knexBuilder = knex({ client: 'pg' });
+const dbProviderStub = { driver: DriverClient.Pg } as unknown as IDbProvider;
+const mainTableAlias = 'main_table as main';
+
+function assignBaseField<T extends FieldCore>(
+  field: T,
+  params: {
+    id: string;
+    name?: string;
+    dbFieldName: string;
+    type: FieldType;
+    cellValueType: CellValueType;
+    options: T['options'];
+  }
+): T {
+  field.id = params.id;
+  field.name = params.name ?? params.id;
+  field.dbFieldName = params.dbFieldName;
+  field.type = params.type;
+  field.options = params.options;
+  field.cellValueType = params.cellValueType;
+  field.isMultipleCellValue = false;
+  field.isLookup = false;
+  field.updateDbFieldType();
+  return field;
+}
+
+function createNumberField(id: string, dbFieldName: string): NumberFieldCore {
+  return assignBaseField(new NumberFieldCore(), {
+    id,
+    dbFieldName,
+    type: FieldType.Number,
+    cellValueType: CellValueType.Number,
+    options: NumberFieldCore.defaultOptions(),
+  });
+}
+
+function createTextField(id: string, dbFieldName: string, name?: string): SingleLineTextFieldCore {
+  return assignBaseField(new SingleLineTextFieldCore(), {
+    id,
+    name,
+    dbFieldName,
+    type: FieldType.SingleLineText,
+    cellValueType: CellValueType.String,
+    options: SingleLineTextFieldCore.defaultOptions(),
+  });
+}
+
+function createDateField(id: string, dbFieldName: string): DateFieldCore {
+  const options = DateFieldCore.defaultOptions();
+  options.formatting = {
+    date: DateFormattingPreset.ISO,
+    time: TimeFormatting.None,
+    timeZone: 'UTC',
+  };
+  return assignBaseField(new DateFieldCore(), {
+    id,
+    dbFieldName,
+    type: FieldType.Date,
+    cellValueType: CellValueType.DateTime,
+    options,
+  });
+}
+
+class ThrowingFilterQuery extends AbstractFilterQuery {
+  private createThrowingFilter(): AbstractCellValueFilter {
+    return {
+      compiler: () => {
+        throw new Error('unexpected adapter failure');
+      },
+    } as unknown as AbstractCellValueFilter;
+  }
+
+  booleanFilter(_field: FieldCore, _context?: IRecordQueryFilterContext): AbstractCellValueFilter {
+    return this.createThrowingFilter();
+  }
+
+  numberFilter(_field: FieldCore, _context?: IRecordQueryFilterContext): AbstractCellValueFilter {
+    return this.createThrowingFilter();
+  }
+
+  dateTimeFilter(_field: FieldCore, _context?: IRecordQueryFilterContext): AbstractCellValueFilter {
+    return this.createThrowingFilter();
+  }
+
+  stringFilter(_field: FieldCore, _context?: IRecordQueryFilterContext): AbstractCellValueFilter {
+    return this.createThrowingFilter();
+  }
+
+  jsonFilter(_field: FieldCore, _context?: IRecordQueryFilterContext): AbstractCellValueFilter {
+    return this.createThrowingFilter();
+  }
+}
+
+describe('filter-query invalid filter skip', () => {
+  it('skips filter item with invalid operator instead of throwing', () => {
+    const numberField = createNumberField('fld_num', 'num_col');
+    const filter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: numberField.id,
+          operator: 'contains',
+          value: 'whatever',
+        },
+      ],
+    } as unknown as IFilter;
+
+    const qb = knexBuilder(mainTableAlias);
+    const filterQuery = new FilterQueryPostgres(
+      qb,
+      { [numberField.id]: numberField },
+      filter,
+      undefined,
+      dbProviderStub
+    );
+
+    expect(() => filterQuery.appendQueryBuilder()).not.toThrow();
+    expect(qb.toQuery()).not.toContain('num_col');
+  });
+
+  it('preserves valid filter items alongside skipped invalid ones', () => {
+    const numberField = createNumberField('fld_num', 'num_col');
+    const textField = createTextField('fld_text', 'text_col');
+    const filter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: numberField.id,
+          operator: 'contains',
+          value: 'whatever',
+        },
+        {
+          fieldId: textField.id,
+          operator: 'contains',
+          value: 'hello',
+        },
+      ],
+    } as unknown as IFilter;
+
+    const qb = knexBuilder(mainTableAlias);
+    const filterQuery = new FilterQueryPostgres(
+      qb,
+      { [numberField.id]: numberField, [textField.id]: textField },
+      filter,
+      undefined,
+      dbProviderStub
+    );
+
+    expect(() => filterQuery.appendQueryBuilder()).not.toThrow();
+    const sql = qb.toQuery();
+    expect(sql).toContain('text_col');
+    expect(sql).not.toContain('num_col');
+  });
+
+  it('keeps filter items keyed by field name when fields map supports name keys', () => {
+    const textField = createTextField('fld_text_name', 'text_name_col', 'Display Name');
+    const filter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: textField.name,
+          operator: 'contains',
+          value: 'hello',
+        },
+      ],
+    } as unknown as IFilter;
+
+    const qb = knexBuilder(mainTableAlias);
+    const filterQuery = new FilterQueryPostgres(
+      qb,
+      { [textField.id]: textField, [textField.name]: textField },
+      filter,
+      undefined,
+      dbProviderStub
+    );
+
+    expect(() => filterQuery.appendQueryBuilder()).not.toThrow();
+    expect(qb.toQuery()).toContain('text_name_col');
+  });
+
+  it('skips filter item with invalid sub-operator mode instead of throwing', () => {
+    const dateField = createDateField('fld_date', 'date_col');
+    const filter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: dateField.id,
+          operator: 'isWithIn',
+          value: { mode: 'invalidMode', exactDate: null, timeZone: 'UTC' },
+        },
+      ],
+    } as unknown as IFilter;
+
+    const qb = knexBuilder(mainTableAlias);
+    const filterQuery = new FilterQueryPostgres(
+      qb,
+      { [dateField.id]: dateField },
+      filter,
+      undefined,
+      dbProviderStub
+    );
+
+    expect(() => filterQuery.appendQueryBuilder()).not.toThrow();
+    expect(qb.toQuery()).not.toContain('date_col');
+  });
+
+  it('skips filter item whose value shape fails inside the adapter compiler', () => {
+    const dateField = createDateField('fld_date_shape', 'date_shape_col');
+    // value is a string, but isWithIn requires an object { mode, ... }
+    const filter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: dateField.id,
+          operator: 'isWithIn',
+          value: 'today',
+        },
+      ],
+    } as unknown as IFilter;
+
+    const qb = knexBuilder(mainTableAlias).select('id');
+    const filterQuery = new FilterQueryPostgres(
+      qb,
+      { [dateField.id]: dateField },
+      filter,
+      undefined,
+      dbProviderStub
+    );
+
+    expect(() => filterQuery.appendQueryBuilder()).not.toThrow();
+    expect(() => qb.toQuery()).not.toThrow();
+  });
+
+  it('rethrows non-user compiler errors instead of swallowing them', () => {
+    const numberField = createNumberField('fld_num_system', 'num_system_col');
+    const filter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: numberField.id,
+          operator: 'is',
+          value: 1,
+        },
+      ],
+    } as unknown as IFilter;
+
+    const qb = knexBuilder(mainTableAlias).select('id');
+    const filterQuery = new ThrowingFilterQuery(
+      qb,
+      { [numberField.id]: numberField },
+      filter,
+      undefined,
+      dbProviderStub
+    );
+
+    expect(() => filterQuery.appendQueryBuilder()).not.toThrow();
+    expect(() => qb.toQuery()).toThrow();
+  });
+
+  it('rethrows field-reference context errors instead of skipping them', () => {
+    const textField = createTextField('fld_text_ref_context', 'text_ref_context_col');
+    const refField = createTextField('fld_ref_context', 'ref_context_col');
+    const filter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: textField.id,
+          operator: 'is',
+          value: { type: 'field', fieldId: refField.id },
+        },
+      ],
+    } as unknown as IFilter;
+
+    const qb = knexBuilder(mainTableAlias).select('id');
+    const filterQuery = new FilterQueryPostgres(
+      qb,
+      { [textField.id]: textField, [refField.id]: refField },
+      filter,
+      undefined,
+      dbProviderStub
+    );
+
+    expect(() => filterQuery.appendQueryBuilder()).not.toThrow();
+    expect(() => qb.toQuery()).toThrow('not available for reference comparisons');
+  });
+});
diff --git a/apps/nestjs-backend/src/db-provider/filter-query/filter-query.abstract.ts b/apps/nestjs-backend/src/db-provider/filter-query/filter-query.abstract.ts
index 6910423874..d05f322b32 100644
--- a/apps/nestjs-backend/src/db-provider/filter-query/filter-query.abstract.ts
+++ b/apps/nestjs-backend/src/db-provider/filter-query/filter-query.abstract.ts
@@ -1,8 +1,8 @@
-import { Logger } from '@nestjs/common';
+import { BadRequestException, Logger } from '@nestjs/common';
 import type {
   FieldCore,
   IConjunction,
-  IDateTimeFieldOperator,
+  IFilterValidationError,
   IFilter,
   IFilterItem,
   IFilterOperator,
@@ -14,17 +14,16 @@ import {
   CellValueType,
   DbFieldType,
   FieldType,
+  analyzeFilterValidationIssues,
   getFilterOperatorMapping,
-  getValidFilterSubOperators,
-  HttpErrorCode,
   isEmpty,
   isMeTag,
   isNotEmpty,
   isFieldReferenceValue,
 } from '@teable/core';
 import type { Knex } from 'knex';
-import { includes, invert, isObject } from 'lodash';
-import { CustomHttpException } from '../../custom.exception';
+import { includes, invert } from 'lodash';
+import { ZodError } from 'zod';
 import type { IRecordQueryFilterContext } from '../../features/record/query-builder/record-query-builder.interface';
 import type { IDbProvider, IFilterQueryExtra } from '../db.provider.interface';
 import type { AbstractCellValueFilter } from './cell-value-filter.abstract';
@@ -33,6 +32,7 @@ import type { IFilterQueryInterface } from './filter-query.interface';
 
 export abstract class AbstractFilterQuery implements IFilterQueryInterface {
   private logger = new Logger(AbstractFilterQuery.name);
+  private filterValidationIssueMap = new Map<string, IFilterValidationError[]>();
 
   constructor(
     protected readonly originQueryBuilder: Knex.QueryBuilder,
@@ -45,6 +45,7 @@ export abstract class AbstractFilterQuery implements IFilterQueryInterface {
 
   appendQueryBuilder(): Knex.QueryBuilder {
     this.preProcessRemoveNullAndReplaceMe(this.filter);
+    this.filterValidationIssueMap = this.collectFilterValidationIssues(this.filter);
 
     return this.parseFilters(this.originQueryBuilder, this.filter);
   }
@@ -52,20 +53,22 @@ export abstract class AbstractFilterQuery implements IFilterQueryInterface {
   private parseFilters(
     queryBuilder: Knex.QueryBuilder,
     filter?: IFilter,
-    parentConjunction?: IConjunction
+    parentConjunction?: IConjunction,
+    path: number[] = []
   ): Knex.QueryBuilder {
     if (!filter || !filter.filterSet) {
       return queryBuilder;
     }
     const { filterSet, conjunction } = filter;
     queryBuilder.where((filterBuilder) => {
-      filterSet.forEach((filterItem) => {
+      filterSet.forEach((filterItem, index) => {
+        const itemPath = [...path, index];
         if ('fieldId' in filterItem) {
-          this.parseFilter(filterBuilder, filterItem as IFilterItem, conjunction);
+          this.parseFilter(filterBuilder, filterItem as IFilterItem, conjunction, itemPath);
         } else {
           filterBuilder = filterBuilder[parentConjunction || conjunction];
           filterBuilder.where((builder) => {
-            this.parseFilters(builder, filterItem as IFilterSet, conjunction);
+            this.parseFilters(builder, filterItem as IFilterSet, conjunction, itemPath);
           });
         }
       });
@@ -77,7 +80,8 @@ export abstract class AbstractFilterQuery implements IFilterQueryInterface {
   private parseFilter(
     queryBuilder: Knex.QueryBuilder,
     filterMeta: IFilterItem,
-    conjunction: IConjunction
+    conjunction: IConjunction,
+    path: number[]
   ) {
     const { fieldId, operator, value, isSymbol } = filterMeta;
 
@@ -86,71 +90,153 @@ export abstract class AbstractFilterQuery implements IFilterQueryInterface {
       return queryBuilder;
     }
 
-    let convertOperator = operator;
-    const filterOperatorMapping = getFilterOperatorMapping(field);
-    const validFilterOperators = Object.keys(filterOperatorMapping);
-    if (isSymbol) {
-      convertOperator = invert(filterOperatorMapping)[operator] as IFilterOperator;
+    if (this.shouldSkipInvalidFilterItem(field, filterMeta, path)) {
+      return queryBuilder;
     }
 
+    const convertOperator = this.getConvertedOperator(field, operator, isSymbol);
+    const validFilterOperators = Object.keys(getFilterOperatorMapping(field));
+
     if (!includes(validFilterOperators, convertOperator)) {
-      let referenceFieldId: string | undefined;
-      if (isFieldReferenceValue(value)) {
-        referenceFieldId = value.fieldId;
-      } else if (Array.isArray(value)) {
-        referenceFieldId = (
-          value.find((entry) => isFieldReferenceValue(entry)) as IFieldReferenceValue | undefined
-        )?.fieldId;
-      }
+      this.throwIfFilterReferencesInvalidOperator(field, value);
+      this.logger.warn(
+        `Skip filter item: field=${field.id}(${field.name}) operator='${convertOperator}' not in [${validFilterOperators.join(',')}]`
+      );
+      return queryBuilder;
+    }
 
-      if (referenceFieldId) {
-        const referenceName = this.fields?.[referenceFieldId]?.name ?? referenceFieldId;
-        const sourceName = field.name ?? field.id;
-        throw new FieldReferenceCompatibilityException(sourceName, referenceName);
-      }
+    queryBuilder = queryBuilder[conjunction];
 
-      throw new CustomHttpException(
-        `The '${convertOperator}' operation provided for the '${field.name}' filter is invalid. Only the following types are allowed: [${validFilterOperators}]`,
-        HttpErrorCode.VALIDATION_ERROR,
-        {
-          localization: {
-            i18nKey: 'httpErrors.view.filterInvalidOperator',
-          },
-        }
+    try {
+      this.getFilterAdapter(field).compiler(
+        queryBuilder,
+        convertOperator as IFilterOperator,
+        value,
+        this.dbProvider!
       );
+    } catch (error) {
+      this.handleCompilerError(error, field, convertOperator, value);
+    }
+    return queryBuilder;
+  }
+
+  private shouldSkipInvalidFilterItem(field: FieldCore, filterMeta: IFilterItem, path: number[]) {
+    const validationIssues = this.getFilterItemValidationIssues(path);
+    if (validationIssues.length === 0) {
+      return false;
     }
 
-    const validFilterSubOperators = getValidFilterSubOperators(
-      field.type,
-      convertOperator as IDateTimeFieldOperator
+    const hasInvalidOperator = validationIssues.some(
+      (issue) => issue.code === 'OPERATOR_NOT_ALLOWED'
     );
+    if (hasInvalidOperator) {
+      this.throwIfFilterReferencesInvalidOperator(field, filterMeta.value);
+    }
 
-    if (
-      validFilterSubOperators &&
-      isObject(value) &&
-      'mode' in value &&
-      !includes(validFilterSubOperators, value.mode)
-    ) {
-      throw new CustomHttpException(
-        `The '${convertOperator}' operation provided for the '${field.name}' filter is invalid. Only the following subtypes are allowed: [${validFilterSubOperators}]`,
-        HttpErrorCode.VALIDATION_ERROR,
-        {
-          localization: {
-            i18nKey: 'httpErrors.view.filterInvalidOperatorMode',
-          },
-        }
-      );
+    this.logger.warn(
+      `Skip filter item: field=${field.id}(${field.name}) path=${path.join('.')} issues=[${validationIssues
+        .map((issue) => issue.code)
+        .join(',')}]`
+    );
+    return true;
+  }
+
+  private getConvertedOperator(field: FieldCore, operator: string, isSymbol?: boolean) {
+    if (!isSymbol) {
+      return operator as IFilterOperator;
     }
 
-    queryBuilder = queryBuilder[conjunction];
+    return invert(getFilterOperatorMapping(field))[operator] as IFilterOperator;
+  }
 
-    this.getFilterAdapter(field).compiler(
-      queryBuilder,
-      convertOperator as IFilterOperator,
-      value,
-      this.dbProvider!
+  private throwIfFilterReferencesInvalidOperator(field: FieldCore, value: unknown) {
+    const referenceFieldId = this.extractFieldReferenceFieldId(value);
+    if (!referenceFieldId) {
+      return;
+    }
+
+    const referenceName = this.fields?.[referenceFieldId]?.name ?? referenceFieldId;
+    const sourceName = field.name ?? field.id;
+    throw new FieldReferenceCompatibilityException(sourceName, referenceName);
+  }
+
+  private handleCompilerError(
+    error: unknown,
+    field: FieldCore,
+    convertOperator: IFilterOperator,
+    value: unknown
+  ) {
+    if (error instanceof FieldReferenceCompatibilityException) {
+      throw error;
+    }
+    if (this.extractFieldReferenceFieldId(value)) {
+      throw error;
+    }
+    if (!this.isSkippableCompilerError(error)) {
+      throw error;
+    }
+    const reason = error instanceof Error ? error.message : String(error);
+    this.logger.warn(
+      `Skip filter item: field=${field.id}(${field.name}) operator='${convertOperator}' ` +
+        `value=${JSON.stringify(value)} compile error: ${reason}`
     );
-    return queryBuilder;
+  }
+
+  private collectFilterValidationIssues(filter?: IFilter) {
+    const issueMap = new Map<string, IFilterValidationError[]>();
+    if (!filter || !this.fields) {
+      return issueMap;
+    }
+
+    const fieldMetaMap = Object.entries(this.fields).reduce(
+      (acc, [fieldKey, field]) => {
+        const fieldMeta = {
+          type: field.type,
+          cellValueType: field.cellValueType,
+          isMultipleCellValue: Boolean(field.isMultipleCellValue),
+        };
+        acc[fieldKey] = fieldMeta;
+        acc[field.id] = fieldMeta;
+        return acc;
+      },
+      {} as Record<
+        string,
+        {
+          type: FieldType;
+          cellValueType: CellValueType;
+          isMultipleCellValue: boolean;
+        }
+      >
+    );
+
+    const issues = analyzeFilterValidationIssues(filter, fieldMetaMap);
+    issues.forEach((issue) => {
+      const key = issue.path.join('.');
+      const issueList = issueMap.get(key) ?? [];
+      issueList.push(issue);
+      issueMap.set(key, issueList);
+    });
+    return issueMap;
+  }
+
+  private getFilterItemValidationIssues(path: number[]) {
+    return this.filterValidationIssueMap.get(path.join('.')) ?? [];
+  }
+
+  private extractFieldReferenceFieldId(value: unknown): string | undefined {
+    if (isFieldReferenceValue(value)) {
+      return value.fieldId;
+    }
+    if (Array.isArray(value)) {
+      return (
+        value.find((entry) => isFieldReferenceValue(entry)) as IFieldReferenceValue | undefined
+      )?.fieldId;
+    }
+    return undefined;
+  }
+
+  private isSkippableCompilerError(error: unknown) {
+    return error instanceof BadRequestException || error instanceof ZodError;
   }
 
   private getFilterAdapter(field: FieldCore): AbstractCellValueFilter {
diff --git a/apps/nestjs-backend/src/db-provider/formula-default-unit.spec.ts b/apps/nestjs-backend/src/db-provider/formula-default-unit.spec.ts
index 1909991cf4..dd2c9259a2 100644
--- a/apps/nestjs-backend/src/db-provider/formula-default-unit.spec.ts
+++ b/apps/nestjs-backend/src/db-provider/formula-default-unit.spec.ts
@@ -69,3 +69,35 @@ describe('convertFormulaToGeneratedColumn blank numeric comparisons', () => {
     expect(result.sql).toContain("= ''");
   });
 });
+
+describe('convertFormulaToSelectQuery blank numeric comparisons', () => {
+  it('keeps spaced BLANK() as a blank operand when comparing number fields', () => {
+    const numberField = createFieldInstanceByVo({
+      id: 'fldWeight',
+      dbFieldName: 'weight',
+      name: 'Weight',
+      type: FieldType.Number,
+      cellValueType: CellValueType.Number,
+      dbFieldType: DbFieldType.Real,
+    });
+    const table = new TableDomain({
+      id: 'tblFormulaUnit',
+      name: 'Formula Unit',
+      dbTableName: 'public.tbl_formula_unit',
+      lastModifiedTime: '2026-04-08T00:00:00.000Z',
+      fields: [numberField],
+    });
+    const provider = new PostgresProvider(knex({ client: 'pg' }));
+    const sql = toSql(
+      provider.convertFormulaToSelectQuery('{fldWeight} != BLANK()', {
+        ...context,
+        table,
+      })
+    );
+
+    expect(sql).toContain('COALESCE(NULLIF');
+    expect(sql).toContain('"weight"');
+    expect(sql).not.toContain('::numeric');
+    expect(sql).toContain("<> ''");
+  });
+});
diff --git a/apps/nestjs-backend/src/db-provider/search-query/date-search-range.util.ts b/apps/nestjs-backend/src/db-provider/search-query/date-search-range.util.ts
new file mode 100644
index 0000000000..3e85cf721f
--- /dev/null
+++ b/apps/nestjs-backend/src/db-provider/search-query/date-search-range.util.ts
@@ -0,0 +1,80 @@
+import { DateFormattingPreset, type IDateFieldOptions, TimeFormatting } from '@teable/core';
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+import timezone from 'dayjs/plugin/timezone';
+import utc from 'dayjs/plugin/utc';
+
+dayjs.extend(utc);
+dayjs.extend(timezone);
+dayjs.extend(customParseFormat);
+
+type IDateSearchUnit = 'year' | 'month' | 'day' | 'minute';
+
+export interface IDateSearchRange {
+  start: string;
+  end: string;
+}
+
+const dateSearchPatterns: Array<{ pattern: RegExp; format: string; unit: IDateSearchUnit }> = [
+  { pattern: /^\d{4}$/, format: 'YYYY', unit: 'year' },
+  { pattern: /^\d{4}-\d{2}$/, format: 'YYYY-MM', unit: 'month' },
+  { pattern: /^\d{4}-\d{2}-\d{2}$/, format: 'YYYY-MM-DD', unit: 'day' },
+  { pattern: /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}$/, format: 'YYYY-MM-DD HH:mm', unit: 'minute' },
+];
+
+const isUnitAllowed = (
+  unit: IDateSearchUnit,
+  formatting: IDateFieldOptions['formatting']
+): boolean => {
+  const dateFormat = formatting.date ?? DateFormattingPreset.ISO;
+  const hasTime = formatting.time != null && formatting.time !== TimeFormatting.None;
+
+  switch (unit) {
+    case 'year':
+      return true;
+    case 'month':
+      return dateFormat !== DateFormattingPreset.Y;
+    case 'day':
+      return dateFormat !== DateFormattingPreset.Y && dateFormat !== DateFormattingPreset.YM;
+    case 'minute':
+      return hasTime;
+    default:
+      return false;
+  }
+};
+
+export const getDateSearchRange = (
+  rawSearchValue: string,
+  dateFieldOptions: IDateFieldOptions
+): IDateSearchRange | null => {
+  const searchValue = rawSearchValue.trim();
+  if (!searchValue) {
+    return null;
+  }
+
+  const formatting = dateFieldOptions.formatting;
+  const timeZone = formatting.timeZone;
+
+  for (const candidate of dateSearchPatterns) {
+    if (!candidate.pattern.test(searchValue) || !isUnitAllowed(candidate.unit, formatting)) {
+      continue;
+    }
+
+    const normalizedSearchValue =
+      candidate.unit === 'minute' ? searchValue.replace('T', ' ') : searchValue;
+    const parsed = dayjs.tz(normalizedSearchValue, candidate.format, timeZone);
+    if (!parsed.isValid() || parsed.format(candidate.format) !== normalizedSearchValue) {
+      continue;
+    }
+
+    const start = parsed.startOf(candidate.unit);
+    const end = start.add(1, candidate.unit);
+
+    return {
+      start: start.toISOString(),
+      end: end.toISOString(),
+    };
+  }
+
+  return null;
+};
diff --git a/apps/nestjs-backend/src/db-provider/search-query/search-index-builder.postgres.spec.ts b/apps/nestjs-backend/src/db-provider/search-query/search-index-builder.postgres.spec.ts
index e8544e1a62..e4756350b4 100644
--- a/apps/nestjs-backend/src/db-provider/search-query/search-index-builder.postgres.spec.ts
+++ b/apps/nestjs-backend/src/db-provider/search-query/search-index-builder.postgres.spec.ts
@@ -1,9 +1,9 @@
 import { CellValueType, FieldType } from '@teable/core';
 import type { IFieldInstance } from '../../features/field/model/factory';
-import { FieldFormatter } from './search-index-builder.postgres';
+import { FieldFormatter, IndexBuilderPostgres } from './search-index-builder.postgres';
 
 describe('FieldFormatter', () => {
-  it('formats date fields for search without creating a trigram index expression', () => {
+  it('does not expose trigram search expressions for date fields, but still builds a btree index spec', () => {
     const field = {
       cellValueType: CellValueType.DateTime,
       dbFieldName: 'Due_Date',
@@ -17,9 +17,32 @@ describe('FieldFormatter', () => {
       type: FieldType.Date,
     } as IFieldInstance;
 
-    expect(FieldFormatter.getSearchableExpression(field)).toBe(
-      "TO_CHAR(TIMEZONE('Asia/Singapore', \"Due_Date\"), 'YYYY-MM-DD HH24:MI')"
+    expect(FieldFormatter.getSearchableExpression(field)).toBeNull();
+    expect(FieldFormatter.getIndexSpec(field)).toEqual({
+      kind: 'btree',
+      expression: '"Due_Date"',
+    });
+  });
+
+  it('creates a btree index sql for single datetime fields', () => {
+    const builder = new IndexBuilderPostgres();
+    const field = {
+      id: 'fldDateField000001',
+      cellValueType: CellValueType.DateTime,
+      dbFieldName: 'Due_Date',
+      isMultipleCellValue: false,
+      isStructuredCellValue: false,
+      options: {
+        formatting: {
+          timeZone: 'Asia/Singapore',
+        },
+      },
+      type: FieldType.Date,
+    } as IFieldInstance;
+
+    expect(builder.createSingleIndexSql('base_table.records', field)).toContain(
+      'ON "base_table"."records" USING btree ("Due_Date")'
     );
-    expect(FieldFormatter.getIndexExpression(field)).toBeNull();
+    expect(builder.createSingleIndexSql('base_table.records', field)).not.toContain('gin_trgm_ops');
   });
 });
diff --git a/apps/nestjs-backend/src/db-provider/search-query/search-index-builder.postgres.ts b/apps/nestjs-backend/src/db-provider/search-query/search-index-builder.postgres.ts
index a8a522ae10..c6f852136c 100644
--- a/apps/nestjs-backend/src/db-provider/search-query/search-index-builder.postgres.ts
+++ b/apps/nestjs-backend/src/db-provider/search-query/search-index-builder.postgres.ts
@@ -1,7 +1,6 @@
 /* eslint-disable regexp/no-unused-capturing-group */
 /* eslint-disable sonarjs/no-duplicate-string */
 import { assertNever, CellValueType, FieldType } from '@teable/core';
-import type { IDateFieldOptions } from '@teable/core';
 import type { IFieldInstance } from '../../features/field/model/factory';
 
 import { IndexBuilderAbstract } from '../index-query/index-abstract-builder';
@@ -14,7 +13,17 @@ interface IPgIndex {
   indexdef: string;
 }
 
-const unSupportCellValueType = [CellValueType.DateTime, CellValueType.Boolean];
+const unSupportCellValueType = [CellValueType.Boolean];
+
+type ISearchIndexSpec =
+  | {
+      kind: 'btree';
+      expression: string;
+    }
+  | {
+      kind: 'trgm';
+      expression: string;
+    };
 
 export class FieldFormatter {
   static getSearchableExpression(field: IFieldInstance, isArray = false): string | null {
@@ -29,8 +38,8 @@ export class FieldFormatter {
           return `ROUND(value::numeric, ${precision})::text`;
         }
         case CellValueType.DateTime: {
-          const timeZone = (options as IDateFieldOptions).formatting.timeZone.replace(/'/g, "''");
-          return `TO_CHAR(TIMEZONE('${timeZone}', value), 'YYYY-MM-DD HH24:MI')`;
+          // date type not support full text search
+          return null;
         }
         case CellValueType.Boolean: {
           // date type not support full text search
@@ -67,11 +76,27 @@ export class FieldFormatter {
   }
 
   // expression for generating index
-  static getIndexExpression(field: IFieldInstance): string | null {
+  static getIndexSpec(field: IFieldInstance): ISearchIndexSpec | null {
     if (field.cellValueType === CellValueType.DateTime) {
+      if (field.isMultipleCellValue) {
+        return null;
+      }
+
+      return {
+        kind: 'btree',
+        expression: `"${field.dbFieldName}"`,
+      };
+    }
+
+    const expression = this.getSearchableExpression(field, field.isMultipleCellValue);
+    if (!expression) {
       return null;
     }
-    return this.getSearchableExpression(field, field.isMultipleCellValue);
+
+    return {
+      kind: 'trgm',
+      expression,
+    };
   }
 }
 
@@ -112,12 +137,16 @@ export class IndexBuilderPostgres extends IndexBuilderAbstract {
   createSingleIndexSql(dbTableName: string, field: IFieldInstance): string | null {
     const [schema, table] = dbTableName.split('.');
     const indexName = this.getIndexName(table, field);
-    const expression = FieldFormatter.getIndexExpression(field);
-    if (expression === null) {
+    const indexSpec = FieldFormatter.getIndexSpec(field);
+    if (indexSpec === null) {
       return null;
     }
 
-    return `CREATE INDEX IF NOT EXISTS "${indexName}" ON "${schema}"."${table}" USING gin ((${expression}) gin_trgm_ops)`;
+    if (indexSpec.kind === 'btree') {
+      return `CREATE INDEX IF NOT EXISTS "${indexName}" ON "${schema}"."${table}" USING btree (${indexSpec.expression})`;
+    }
+
+    return `CREATE INDEX IF NOT EXISTS "${indexName}" ON "${schema}"."${table}" USING gin ((${indexSpec.expression}) gin_trgm_ops)`;
   }
 
   getDropIndexSql(dbTableName: string): string {
@@ -145,8 +174,7 @@ export class IndexBuilderPostgres extends IndexBuilderAbstract {
     const fieldSql = searchFields
       .filter(({ cellValueType }) => !unSupportCellValueType.includes(cellValueType))
       .map((field) => {
-        const expression = FieldFormatter.getIndexExpression(field);
-        return expression ? this.createSingleIndexSql(dbTableName, field) : null;
+        return this.createSingleIndexSql(dbTableName, field);
       })
       .filter((sql): sql is string => sql !== null);
 
@@ -202,9 +230,8 @@ export class IndexBuilderPostgres extends IndexBuilderAbstract {
     const [, table] = dbTableName.split('.');
     const expectExistIndex = fields
       .filter(({ cellValueType }) => !unSupportCellValueType.includes(cellValueType))
-      .map((field) => {
-        return this.getIndexName(table, field);
-      });
+      .filter((field) => this.createSingleIndexSql(dbTableName, field) !== null)
+      .map((field) => this.getIndexName(table, field));
 
     // 1: find the lack or redundant index
     const lackingIndex = expectExistIndex.filter(
@@ -223,11 +250,16 @@ export class IndexBuilderPostgres extends IndexBuilderAbstract {
     // 2: find the abnormal index definition
     const expectIndexDef = fields
       .filter(({ cellValueType }) => !unSupportCellValueType.includes(cellValueType))
-      .map((f) => {
-        return {
-          indexName: this.getIndexName(table, f),
-          indexDef: this.createSingleIndexSql(dbTableName, f) as string,
-        };
+      .flatMap((f) => {
+        const indexDef = this.createSingleIndexSql(dbTableName, f);
+        return indexDef
+          ? [
+              {
+                indexName: this.getIndexName(table, f),
+                indexDef,
+              },
+            ]
+          : [];
       });
 
     return expectIndexDef
diff --git a/apps/nestjs-backend/src/db-provider/search-query/search-query.postgres.spec.ts b/apps/nestjs-backend/src/db-provider/search-query/search-query.postgres.spec.ts
new file mode 100644
index 0000000000..069a3cf712
--- /dev/null
+++ b/apps/nestjs-backend/src/db-provider/search-query/search-query.postgres.spec.ts
@@ -0,0 +1,55 @@
+import { CellValueType, DateFormattingPreset, FieldType, TimeFormatting } from '@teable/core';
+import { TableIndex } from '@teable/openapi';
+import knex from 'knex';
+import { describe, expect, it } from 'vitest';
+import type { IFieldInstance } from '../../features/field/model/factory';
+import { SearchQueryPostgres } from './search-query.postgres';
+
+const buildDateField = (): IFieldInstance =>
+  ({
+    id: 'fldDateSearch00001',
+    dbFieldName: 'Due_Date',
+    cellValueType: CellValueType.DateTime,
+    isMultipleCellValue: false,
+    isStructuredCellValue: false,
+    type: FieldType.Date,
+    options: {
+      formatting: {
+        date: DateFormattingPreset.ISO,
+        time: TimeFormatting.None,
+        timeZone: 'Asia/Shanghai',
+      },
+    },
+  }) as IFieldInstance;
+
+describe('SearchQueryPostgres', () => {
+  const db = knex({ client: 'pg' });
+
+  it('uses a datetime range for date-like search values when search index is enabled', () => {
+    const field = buildDateField();
+    const builder = new SearchQueryPostgres(
+      db.queryBuilder(),
+      field,
+      ['2022-03-02', '', true],
+      [TableIndex.search]
+    );
+
+    const compiled = builder.getQuery()?.toSQL();
+    expect(compiled?.sql).toContain('"Due_Date" >= ?::timestamptz AND "Due_Date" < ?::timestamptz');
+    expect(compiled?.sql).not.toContain('TO_CHAR');
+    expect(compiled?.bindings).toEqual(['2022-03-01T16:00:00.000Z', '2022-03-02T16:00:00.000Z']);
+  });
+
+  it('skips date-field scans for non-date-like search values', () => {
+    const field = buildDateField();
+    const builder = new SearchQueryPostgres(
+      db.queryBuilder(),
+      field,
+      ['not-a-date', '', true],
+      [TableIndex.search]
+    );
+
+    const compiled = builder.getQuery()?.toSQL();
+    expect(compiled?.sql).toBe('FALSE');
+  });
+});
diff --git a/apps/nestjs-backend/src/db-provider/search-query/search-query.postgres.ts b/apps/nestjs-backend/src/db-provider/search-query/search-query.postgres.ts
index aba34644a7..53283be572 100644
--- a/apps/nestjs-backend/src/db-provider/search-query/search-query.postgres.ts
+++ b/apps/nestjs-backend/src/db-provider/search-query/search-query.postgres.ts
@@ -9,6 +9,7 @@ import type { IRecordQueryFilterContext } from '../../features/record/query-buil
 import { escapePostgresRegex } from '../../utils/postgres-regex-escape';
 import { escapeLikeWildcards } from '../../utils/sql-like-escape';
 import { SearchQueryAbstract } from './abstract';
+import { getDateSearchRange } from './date-search-range.util';
 import { FieldFormatter } from './search-index-builder.postgres';
 import type { ISearchCellValueType } from './types';
 
@@ -53,6 +54,9 @@ export class SearchQueryPostgres extends SearchQueryAbstract {
     const { isMultipleCellValue } = field;
     const isSearchAllFields = !search[1];
     if (isSearchAllFields) {
+      if (field.cellValueType === CellValueType.DateTime) {
+        return isMultipleCellValue ? this.multipleDate() : this.date();
+      }
       const searchValue = search[0];
       const escapedSearchValue = escapeLikeWildcards(searchValue);
       const expression = FieldFormatter.getSearchableExpression(field, isMultipleCellValue);
@@ -136,17 +140,15 @@ export class SearchQueryPostgres extends SearchQueryAbstract {
   }
 
   protected date() {
-    const {
-      search,
-      knex,
-      field: { options },
-    } = this;
-    const searchValue = search[0];
-    const escapedSearchValue = escapeLikeWildcards(searchValue);
-    const timeZone = (options as IDateFieldOptions).formatting.timeZone;
+    const { search, knex } = this;
+    const range = getDateSearchRange(search[0], this.field.options as IDateFieldOptions);
+    if (!range) {
+      return knex.raw('FALSE');
+    }
+
     return knex.raw(
-      `TO_CHAR(TIMEZONE(?, ${this.fieldName}), 'YYYY-MM-DD HH24:MI') ILIKE ? ESCAPE '\\'`,
-      [timeZone, `%${escapedSearchValue}%`]
+      `(${this.fieldName} >= ?::timestamptz AND ${this.fieldName} < ?::timestamptz)`,
+      [range.start, range.end]
     );
   }
 
@@ -199,20 +201,24 @@ export class SearchQueryPostgres extends SearchQueryAbstract {
 
   protected multipleDate() {
     const { search, knex } = this;
-    const searchValue = search[0];
-    const escapedSearchValue = escapeLikeWildcards(searchValue);
-    const timeZone = (this.field.options as IDateFieldOptions).formatting.timeZone;
+    const range = getDateSearchRange(search[0], this.field.options as IDateFieldOptions);
+    if (!range) {
+      return knex.raw('FALSE');
+    }
+
     return knex.raw(
       `
       EXISTS (
         SELECT 1 FROM (
-          SELECT string_agg(TO_CHAR(TIMEZONE(?, CAST(elem AS timestamp with time zone)), 'YYYY-MM-DD HH24:MI'), ', ') as aggregated
+          SELECT 1
           FROM jsonb_array_elements_text(${this.fieldName}::jsonb) as elem
+          WHERE CAST(elem AS timestamp with time zone) >= ?::timestamptz
+            AND CAST(elem AS timestamp with time zone) < ?::timestamptz
+          LIMIT 1
         ) as sub
-        WHERE sub.aggregated ILIKE ? ESCAPE '\\'
       )
       `,
-      [timeZone, `%${escapedSearchValue}%`]
+      [range.start, range.end]
     );
   }
 
@@ -298,8 +304,11 @@ export class SearchQueryPostgresBuilder {
 
     return conditions
       .filter(({ field }) => {
-        // global search does not support checkbox
-        if (isSearchAllFields && field.cellValueType === CellValueType.Boolean) {
+        // global search does not support date time and checkbox
+        if (
+          isSearchAllFields &&
+          [CellValueType.DateTime, CellValueType.Boolean].includes(field.cellValueType)
+        ) {
           return false;
         }
         return true;
diff --git a/apps/nestjs-backend/src/features/ai/ai.service.spec.ts b/apps/nestjs-backend/src/features/ai/ai.service.spec.ts
new file mode 100644
index 0000000000..3c0f7e8b6f
--- /dev/null
+++ b/apps/nestjs-backend/src/features/ai/ai.service.spec.ts
@@ -0,0 +1,63 @@
+import { LLMProviderType } from '@teable/openapi';
+import { describe, expect, it } from 'vitest';
+import { AiService } from './ai.service';
+
+const openAIProviderName = 'custom-openai';
+const openRouterProviderName = 'custom-openrouter';
+const gptImage2Model = 'gpt-image-2';
+const openRouterModel = `openai/${gptImage2Model}`;
+const imageGenerationTag = 'image-generation';
+
+describe('AiService.getModelTags', () => {
+  const service = Object.create(AiService.prototype) as AiService;
+
+  it('does not infer tags for direct OpenAI GPT image models without explicit config', async () => {
+    const tags = await service.getModelTags(
+      `${LLMProviderType.OPENAI}@${gptImage2Model}@${openAIProviderName}`,
+      [
+        {
+          type: LLMProviderType.OPENAI,
+          name: openAIProviderName,
+          models: gptImage2Model,
+        },
+      ]
+    );
+
+    expect(tags).toEqual([]);
+  });
+
+  it('returns explicit direct OpenAI GPT image tags without inference', async () => {
+    const tags = await service.getModelTags(
+      `${LLMProviderType.OPENAI}@${gptImage2Model}@${openAIProviderName}`,
+      [
+        {
+          type: LLMProviderType.OPENAI,
+          name: openAIProviderName,
+          models: gptImage2Model,
+          modelConfigs: {
+            [gptImage2Model]: {
+              tags: [imageGenerationTag],
+            },
+          },
+        },
+      ]
+    );
+
+    expect(tags).toEqual([imageGenerationTag]);
+  });
+
+  it('does not infer tags for OpenRouter models without explicit config', async () => {
+    const tags = await service.getModelTags(
+      `${LLMProviderType.OPENROUTER}@${openRouterModel}@${openRouterProviderName}`,
+      [
+        {
+          type: LLMProviderType.OPENROUTER,
+          name: openRouterProviderName,
+          models: openRouterModel,
+        },
+      ]
+    );
+
+    expect(tags).toEqual([]);
+  });
+});
diff --git a/apps/nestjs-backend/src/features/ai/ai.service.ts b/apps/nestjs-backend/src/features/ai/ai.service.ts
index 016db3ae36..89a84d0fad 100644
--- a/apps/nestjs-backend/src/features/ai/ai.service.ts
+++ b/apps/nestjs-backend/src/features/ai/ai.service.ts
@@ -10,6 +10,7 @@ import {
   Task,
   convertGatewayApiModel,
   normalizeGatewayPricing,
+  supportsImageInputForImageGeneration,
 } from '@teable/openapi';
 import type {
   IAIConfig,
@@ -558,18 +559,8 @@ export class AiService {
     if (type === LLMProviderType.AI_GATEWAY) {
       try {
         const gatewayModel = await this.getGatewayModelConfig(model);
-        if (gatewayModel?.tags?.length) {
-          const tags = [...gatewayModel.tags];
-          // Patch: Google models with image-generation capability also support vision (image-to-image)
-          // This is because Gemini image models can accept images as input for image generation
-          if (
-            model.startsWith('google/') &&
-            tags.includes('image-generation') &&
-            !tags.includes('vision')
-          ) {
-            tags.push('vision');
-          }
-          return tags;
+        if (gatewayModel) {
+          return this.addImageInputTagForImageGeneration(model, gatewayModel.tags ?? []);
         }
       } catch (error) {
         this.logger.warn(`[getModelTags] Failed to get gateway config for ${model}: ${error}`);
@@ -594,6 +585,19 @@ export class AiService {
     return [];
   }
 
+  private addImageInputTagForImageGeneration(
+    modelId: string,
+    tags: readonly GatewayModelTag[]
+  ): GatewayModelTag[] {
+    const nextTags = [...tags];
+    // Some image generation models accept image inputs but Gateway may only report
+    // image-generation. Add vision so AI fields forward attachment source images.
+    if (supportsImageInputForImageGeneration(modelId, nextTags) && !nextTags.includes('vision')) {
+      nextTags.push('vision');
+    }
+    return nextTags;
+  }
+
   /**
    * Convert deprecated IChatModelAbility to GatewayModelTag[]
    * Used for backward compatibility with old ability format
diff --git a/apps/nestjs-backend/src/features/attachments/attachments-crop.processor.ts b/apps/nestjs-backend/src/features/attachments/attachments-crop.processor.ts
index 0783666b7b..0b93b38a0c 100644
--- a/apps/nestjs-backend/src/features/attachments/attachments-crop.processor.ts
+++ b/apps/nestjs-backend/src/features/attachments/attachments-crop.processor.ts
@@ -5,6 +5,7 @@ import { isImage, isPdf } from '@teable/core';
 import { PrismaService } from '@teable/db-main-prisma';
 import { Queue } from 'bullmq';
 import type { Job } from 'bullmq';
+import sharp from 'sharp';
 import { EventEmitterService } from '../../event-emitter/event-emitter.service';
 import { Events } from '../../event-emitter/events';
 import { AttachmentsStorageService } from '../attachments/attachments-storage.service';
@@ -59,7 +60,11 @@ export class AttachmentsCropQueueProcessor extends WorkerHost {
       where: { token },
       select: { thumbnailPath: true },
     });
-    if (existing?.thumbnailPath) {
+    if (!existing) {
+      this.logger.log(`Attachment with token(${token}) does not exist.`);
+      return;
+    }
+    if (existing.thumbnailPath) {
       this.logger.log(`path(${path}) already has thumbnail`);
       return;
     }
@@ -83,6 +88,12 @@ export class AttachmentsCropQueueProcessor extends WorkerHost {
         const pdfBuffer = Buffer.concat(chunks);
         const { buffer, height: imgHeight } = await renderPdfFirstPageAsImage(pdfBuffer);
 
+        const isBlank = await this.isBlankImage(buffer);
+        if (isBlank) {
+          this.logger.warn(`PDF thumbnail for ${path} is blank, skipping storage`);
+          return;
+        }
+
         ({ lgThumbnailPath, smThumbnailPath } =
           await this.attachmentsStorageService.uploadTableImageThumbnailsFromBuffer(
             bucket,
@@ -91,7 +102,6 @@ export class AttachmentsCropQueueProcessor extends WorkerHost {
             imgHeight
           ));
       } catch (error) {
-        console.error(`Failed to render PDF thumbnail for ${path}`, error);
         this.logger.error(`PDF thumbnail failed for ${path}`, error);
         // Non-fatal: frontend falls back to PDF icon
         return;
@@ -109,4 +119,9 @@ export class AttachmentsCropQueueProcessor extends WorkerHost {
     });
     this.logger.log(`path(${path}) crop thumbnails success`);
   }
+
+  private async isBlankImage(pngBuffer: Buffer): Promise<boolean> {
+    const { channels } = await sharp(pngBuffer).stats();
+    return channels.slice(0, 3).every((ch) => ch.min >= 250);
+  }
 }
diff --git a/apps/nestjs-backend/src/features/auth/guard/base-node-permission.guard.ts b/apps/nestjs-backend/src/features/auth/guard/base-node-permission.guard.ts
index 5af107d066..e43d519cf6 100644
--- a/apps/nestjs-backend/src/features/auth/guard/base-node-permission.guard.ts
+++ b/apps/nestjs-backend/src/features/auth/guard/base-node-permission.guard.ts
@@ -1,7 +1,7 @@
 import type { ExecutionContext } from '@nestjs/common';
 import { Injectable } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
-import { HttpErrorCode } from '@teable/core';
+import { HttpErrorCode, IdPrefix, identify } from '@teable/core';
 import { PrismaService } from '@teable/db-main-prisma';
 import type { BaseNodeResourceType } from '@teable/openapi';
 import { ClsService } from 'nestjs-cls';
@@ -53,6 +53,7 @@ export class BaseNodePermissionGuard extends PermissionGuard {
         },
       });
     }
+    await this.resolveRequestNodeIds(context, baseId);
     const permissionContext = await this.getPermissionContext();
     return this.checkActivate(context, baseId, permissionContext);
   }
@@ -147,6 +148,30 @@ export class BaseNodePermissionGuard extends PermissionGuard {
     }
   }
 
+  async resolveRequestNodeIds(context: ExecutionContext, baseId: string) {
+    const req = context.switchToHttp().getRequest();
+    const needsResolve = (id?: string): id is string =>
+      typeof id === 'string' && identify(id) !== IdPrefix.BaseNode;
+
+    const { nodeId } = req.params;
+    const { parentId, anchorId } = req.body ?? {};
+
+    const resourceIds = [nodeId, parentId, anchorId].filter(needsResolve);
+    if (!resourceIds.length) {
+      return;
+    }
+
+    const nodes = await this.prismaService.baseNode.findMany({
+      where: { baseId, resourceId: { in: [...new Set(resourceIds)] } },
+      select: { id: true, resourceId: true },
+    });
+    const resolved = new Map(nodes.map((n) => [n.resourceId, n.id]));
+
+    if (resolved.has(nodeId)) req.params.nodeId = resolved.get(nodeId)!;
+    if (resolved.has(parentId)) req.body.parentId = resolved.get(parentId)!;
+    if (resolved.has(anchorId)) req.body.anchorId = resolved.get(anchorId)!;
+  }
+
   private async getPermissionContext() {
     const permissions = this.clsInner.get('permissions');
     const permissionSet = new Set(permissions);
diff --git a/apps/nestjs-backend/src/features/base-node/base-node.service.spec.ts b/apps/nestjs-backend/src/features/base-node/base-node.service.spec.ts
index 9bbb40858b..3aaaa70932 100644
--- a/apps/nestjs-backend/src/features/base-node/base-node.service.spec.ts
+++ b/apps/nestjs-backend/src/features/base-node/base-node.service.spec.ts
@@ -240,4 +240,43 @@ describe('BaseNodeService', () => {
       });
     });
   });
+
+  describe('getCreateTableV2Decision', () => {
+    it('uses the base v2 marker when deciding table creation routing', async () => {
+      const canaryService = {
+        shouldUseV2ForBaseWithReason: vi
+          .fn()
+          .mockResolvedValue({ useV2: true, reason: 'new_base' }),
+      };
+      const prismaService = {
+        txClient: vi.fn(() => ({
+          base: {
+            findUnique: vi.fn().mockResolvedValue({ spaceId: 'spc1', v2Enabled: true }),
+          },
+        })),
+      };
+      const routingService = new BaseNodeService(
+        {} as never,
+        {} as never,
+        prismaService as never,
+        {} as never,
+        {} as never,
+        { get: vi.fn(), set: vi.fn() } as never,
+        {} as never,
+        canaryService as never,
+        {} as never,
+        {} as never,
+        {} as never,
+        {} as never
+      );
+
+      const decision = await routingService.getCreateTableV2Decision(baseId);
+
+      expect(canaryService.shouldUseV2ForBaseWithReason).toHaveBeenCalledWith(
+        { spaceId: 'spc1', v2Enabled: true },
+        'createTable'
+      );
+      expect(decision).toEqual({ useV2: true, reason: 'new_base' });
+    });
+  });
 });
diff --git a/apps/nestjs-backend/src/features/base-node/base-node.service.ts b/apps/nestjs-backend/src/features/base-node/base-node.service.ts
index 551c9c5ba0..1f533440f8 100644
--- a/apps/nestjs-backend/src/features/base-node/base-node.service.ts
+++ b/apps/nestjs-backend/src/features/base-node/base-node.service.ts
@@ -141,14 +141,10 @@ export class BaseNodeService {
 
     const base = await this.prismaService.txClient().base.findUnique({
       where: { id: baseId, deletedTime: null },
-      select: { spaceId: true },
+      select: { spaceId: true, v2Enabled: true },
     });
 
-    if (!base?.spaceId) {
-      return { useV2: false, reason: 'disabled' };
-    }
-
-    return this.canaryService.shouldUseV2WithReason(base.spaceId, feature);
+    return this.canaryService.shouldUseV2ForBaseWithReason(base, feature);
   }
 
   async getDeleteTableV2Decision(baseId: string, nodeId: string): Promise<IV2Decision | undefined> {
@@ -158,14 +154,10 @@ export class BaseNodeService {
   async getCreateTableV2Decision(baseId: string): Promise<IV2Decision | undefined> {
     const base = await this.prismaService.txClient().base.findUnique({
       where: { id: baseId, deletedTime: null },
-      select: { spaceId: true },
+      select: { spaceId: true, v2Enabled: true },
     });
 
-    if (!base?.spaceId) {
-      return { useV2: false, reason: 'disabled' };
-    }
-
-    return this.canaryService.shouldUseV2WithReason(base.spaceId, 'createTable');
+    return this.canaryService.shouldUseV2ForBaseWithReason(base, 'createTable');
   }
 
   private generateDefaultUrl(
@@ -969,22 +961,8 @@ export class BaseNodeService {
         );
       }
 
-      if (node.resourceType === BaseNodeResourceType.Folder && parentId) {
-        await this.assertFolderDepth(baseId, parentId);
-      }
-
-      // Check for circular reference
-      const isCircular = await this.isCircularReference(baseId, nodeId, parentId);
-      if (isCircular) {
-        throw new CustomHttpException(
-          'Cannot move node to its own child (circular reference)',
-          HttpErrorCode.VALIDATION_ERROR,
-          {
-            localization: {
-              i18nKey: 'httpErrors.baseNode.circularReference',
-            },
-          }
-        );
+      if (node.resourceType === BaseNodeResourceType.Folder) {
+        await this.assertFolderMoveDepth(baseId, parentId, nodeId);
       }
 
       const maxOrder = await this.getMaxOrder(baseId);
@@ -1032,7 +1010,7 @@ export class BaseNodeService {
         });
 
       if (node.resourceType === BaseNodeResourceType.Folder && anchor.parentId) {
-        await this.assertFolderDepth(baseId, anchor.parentId);
+        await this.assertFolderMoveDepth(baseId, anchor.parentId, nodeId);
       }
 
       await updateOrder({
@@ -1125,33 +1103,45 @@ export class BaseNodeService {
     }
   }
 
-  private async getFolderDepth(baseId: string, id: string) {
-    const prisma = this.prismaService.txClient();
-    const allFolders = await prisma.baseNode.findMany({
+  private async assertFolderMoveDepth(baseId: string, parentId: string, nodeId: string) {
+    const allFolders = await this.getAllFolders(baseId);
+
+    const parentDepth = this.getFolderDepthFromList(allFolders, parentId, nodeId);
+    const subtreeDepth = this.getFolderSubtreeDepth(allFolders, nodeId);
+
+    if (parentDepth + subtreeDepth >= this.maxFolderDepth) {
+      throw new CustomHttpException('Folder depth limit exceeded', HttpErrorCode.VALIDATION_ERROR, {
+        localization: {
+          i18nKey: 'httpErrors.baseNode.folderDepthLimitExceeded',
+        },
+      });
+    }
+  }
+
+  private async getAllFolders(baseId: string) {
+    return this.prismaService.txClient().baseNode.findMany({
       where: { baseId, resourceType: BaseNodeResourceType.Folder },
       select: { id: true, parentId: true },
     });
+  }
 
+  private getFolderDepthFromList(
+    allFolders: { id: string; parentId: string | null }[],
+    id: string,
+    circularCheckNodeId?: string
+  ) {
     let depth = 0;
     if (allFolders.length === 0) {
       return depth;
     }
 
     const folderMap = keyBy(allFolders, 'id');
+    const visited = new Set<string>();
     let current = id;
     while (current) {
-      depth++;
-      const folder = folderMap[current];
-      if (!folder) {
-        throw new CustomHttpException('Folder not found', HttpErrorCode.NOT_FOUND, {
-          localization: {
-            i18nKey: 'httpErrors.baseNode.folderNotFound',
-          },
-        });
-      }
-      if (folder.parentId === id) {
+      if ((circularCheckNodeId && current === circularCheckNodeId) || visited.has(current)) {
         throw new CustomHttpException(
-          'A folder cannot be its own parent',
+          'Circular reference detected in folder hierarchy',
           HttpErrorCode.VALIDATION_ERROR,
           {
             localization: {
@@ -1160,52 +1150,42 @@ export class BaseNodeService {
           }
         );
       }
+      visited.add(current);
+      depth++;
+      const folder = folderMap[current];
+      if (!folder) {
+        throw new CustomHttpException('Folder not found', HttpErrorCode.NOT_FOUND, {
+          localization: {
+            i18nKey: 'httpErrors.baseNode.folderNotFound',
+          },
+        });
+      }
       current = folder.parentId ?? '';
     }
     return depth;
   }
 
-  private async isCircularReference(
-    baseId: string,
-    nodeId: string,
-    parentId: string
-  ): Promise<boolean> {
-    const knex = this.knex;
-
-    // Non-recursive query: Start with the parent node
-    const nonRecursiveQuery = knex
-      .select('id', 'parent_id', 'base_id')
-      .from('base_node')
-      .where('id', parentId)
-      .andWhere('base_id', baseId);
-
-    // Recursive query: Traverse up the parent chain
-    const recursiveQuery = knex
-      .select('bn.id', 'bn.parent_id', 'bn.base_id')
-      .from('base_node as bn')
-      .innerJoin('ancestors as a', function () {
-        // Join condition: bn.id = a.parent_id (get parent of current ancestor)
-        this.on('bn.id', '=', 'a.parent_id').andOn('bn.base_id', '=', knex.raw('?', [baseId]));
-      });
-
-    // Combine non-recursive and recursive queries
-    const cteQuery = nonRecursiveQuery.union(recursiveQuery);
-
-    // Build final query with recursive CTE
-    const finalQuery = knex
-      .withRecursive('ancestors', ['id', 'parent_id', 'base_id'], cteQuery)
-      .select('id')
-      .from('ancestors')
-      .where('id', nodeId)
-      .limit(1)
-      .toQuery();
-
-    // Execute query
-    const result = await this.prismaService
-      .txClient()
-      .$queryRawUnsafe<Array<{ id: string }>>(finalQuery);
+  private getFolderSubtreeDepth(
+    allFolders: { id: string; parentId: string | null }[],
+    nodeId: string
+  ) {
+    const childrenMap: Record<string, string[]> = {};
+    for (const folder of allFolders) {
+      if (folder.parentId) {
+        (childrenMap[folder.parentId] ??= []).push(folder.id);
+      }
+    }
+    const calc = (id: string): number => {
+      const children = childrenMap[id];
+      if (!children?.length) return 0;
+      return 1 + Math.max(...children.map(calc));
+    };
+    return calc(nodeId);
+  }
 
-    return result.length > 0;
+  private async getFolderDepth(baseId: string, id: string) {
+    const allFolders = await this.getAllFolders(baseId);
+    return this.getFolderDepthFromList(allFolders, id);
   }
 
   async batchUpdateBaseNodes(data: { id: string; values: { [key: string]: unknown } }[]) {
diff --git a/apps/nestjs-backend/src/features/base-sql-executor/utils.spec.ts b/apps/nestjs-backend/src/features/base-sql-executor/utils.spec.ts
index 2458f4ad13..dc37594fc4 100644
--- a/apps/nestjs-backend/src/features/base-sql-executor/utils.spec.ts
+++ b/apps/nestjs-backend/src/features/base-sql-executor/utils.spec.ts
@@ -1,5 +1,6 @@
 /* eslint-disable sonarjs/no-duplicate-string */
 import { DriverClient } from '@teable/core';
+import { CustomHttpException } from '../../custom.exception';
 import { validateRoleOperations, checkTableAccess } from './utils';
 
 describe('base sql executor utils', () => {
@@ -116,6 +117,16 @@ describe('base sql executor utils', () => {
       );
     });
 
+    it('should throw CustomHttpException for SQL syntax errors instead of SyntaxError', () => {
+      const invalidSql = 'SELEC * FORM users';
+      expect(() =>
+        checkTableAccess(invalidSql, {
+          tableNames: ['users'],
+          database: DriverClient.Pg,
+        })
+      ).toThrow(CustomHttpException);
+    });
+
     it('correctly-split "schema"."table" form passes the whitelist', () => {
       const sql = 'SELECT count(*) FROM "bseXXX"."tblYYY"';
       expect(() =>
diff --git a/apps/nestjs-backend/src/features/base-sql-executor/utils.ts b/apps/nestjs-backend/src/features/base-sql-executor/utils.ts
index b0999ca713..5266615464 100644
--- a/apps/nestjs-backend/src/features/base-sql-executor/utils.ts
+++ b/apps/nestjs-backend/src/features/base-sql-executor/utils.ts
@@ -64,52 +64,60 @@ export const checkTableAccess = (
   const opt = {
     database: databaseTypeMap[database],
   };
-  const { ast } = parser.parse(sql, opt);
-  const withNames = Array.isArray(ast) ? ast.map(collectWithNames).flat() : collectWithNames(ast);
-  const allWithNames = new Set([...withNames, ...tableNames]);
-  const whiteColumnList = Array.from(allWithNames).map((table) => {
+  const { ast } = (() => {
+    try {
+      return parser.parse(sql, opt);
+    } catch {
+      throw new CustomHttpException(
+        'SQL syntax error, please check your query',
+        HttpErrorCode.VALIDATION_ERROR,
+        {
+          localization: {
+            i18nKey: 'httpErrors.baseSqlExecutor.sqlSyntaxError',
+          },
+        }
+      );
+    }
+  })();
+  const withNames = Array.isArray(ast) ? ast.flatMap(collectWithNames) : collectWithNames(ast);
+  const allowedTables = new Set([...withNames, ...tableNames]);
+  const whiteColumnList = Array.from(allowedTables).map((table) => {
     const [schema, tableName] = table.includes('.') ? table.split('.') : [null, table];
     return `select::${schema}::${tableName}`;
   });
 
+  let whiteListError: Error | undefined;
   try {
-    const error = parser.whiteListCheck(sql, whiteColumnList, opt);
-    if (error) {
-      throw error;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  } catch (error: any) {
-    const sqlTableList = parser.tableList(sql, opt);
-    const invalidEntries = sqlTableList.filter((t: string) => !whiteColumnList.includes(t));
-    const invalidTableNames = invalidEntries.map((t: string) => {
-      const parts = t.split('::');
-      return parts[parts.length - 1];
-    });
+    whiteListError = parser.whiteListCheck(sql, whiteColumnList, opt);
+    if (!whiteListError) return;
+  } catch (e) {
+    whiteListError = e as Error;
+  }
+
+  const sqlTableList = parser.tableList(sql, opt);
+  const invalidTableNames = sqlTableList
+    .filter((t: string) => !whiteColumnList.includes(t))
+    .map((t: string) => t.split('::').pop()!);
 
-    let message: string;
-    if (invalidTableNames.length > 0) {
-      const invalidList = invalidTableNames.map((n: string) => `'${n}'`).join(', ');
-      message =
-        `Table ${invalidList} not found. ` +
+  const message =
+    invalidTableNames.length > 0
+      ? `Table ${invalidTableNames.map((n: string) => `'${n}'`).join(', ')} not found. ` +
         `dbTableName from get-tables-meta is already \`schema.table\` (e.g. \`bseXXX.tblYYY\`); ` +
-        `use it in SQL as \`FROM "bseXXX"."tblYYY"\`.`;
-    } else {
-      message = error?.message as string;
-    }
+        `use it in SQL as \`FROM "bseXXX"."tblYYY"\`.`
+      : String(whiteListError?.message ?? whiteListError);
 
-    throw new CustomHttpException(
-      `An error occurred while checking table access: ${message}`,
-      HttpErrorCode.VALIDATION_ERROR,
-      {
-        localization: {
-          i18nKey: 'httpErrors.baseSqlExecutor.whiteListCheckError',
-          context: {
-            message,
-          },
+  throw new CustomHttpException(
+    `An error occurred while checking table access: ${message}`,
+    HttpErrorCode.VALIDATION_ERROR,
+    {
+      localization: {
+        i18nKey: 'httpErrors.baseSqlExecutor.whiteListCheckError',
+        context: {
+          message,
         },
-      }
-    );
-  }
+      },
+    }
+  );
 };
 
 export const getTableNames = (sql: string) => {
diff --git a/apps/nestjs-backend/src/features/base/base-export.service.ts b/apps/nestjs-backend/src/features/base/base-export.service.ts
index 11ad3730af..be038b1125 100644
--- a/apps/nestjs-backend/src/features/base/base-export.service.ts
+++ b/apps/nestjs-backend/src/features/base/base-export.service.ts
@@ -28,6 +28,7 @@ import { EventEmitterService } from '../../event-emitter/event-emitter.service';
 import { Events } from '../../event-emitter/events';
 import type { IClsStore } from '../../types/cls';
 import type { I18nPath } from '../../types/i18n.generated';
+import { resolveBuildVersion } from '../../utils/build-version';
 import { second } from '../../utils/second';
 import StorageAdapter from '../attachments/plugins/adapter';
 import { InjectStorageAdapter } from '../attachments/plugins/storage';
@@ -460,7 +461,7 @@ export class BaseExportService {
       id: baseId,
       name: baseName,
       icon: baseIcon,
-      version: process.env.NEXT_PUBLIC_BUILD_VERSION!,
+      version: resolveBuildVersion(),
       tables,
       plugins,
       folders,
diff --git a/apps/nestjs-backend/src/features/base/base-import.service.ts b/apps/nestjs-backend/src/features/base/base-import.service.ts
index 2601cf993a..f6cc7207e8 100644
--- a/apps/nestjs-backend/src/features/base/base-import.service.ts
+++ b/apps/nestjs-backend/src/features/base/base-import.service.ts
@@ -87,6 +87,7 @@ export class BaseImportService {
           spaceId,
           order,
           icon,
+          v2Enabled: true,
           createdBy: userId,
         },
         select: {
diff --git a/apps/nestjs-backend/src/features/base/base.service.spec.ts b/apps/nestjs-backend/src/features/base/base.service.spec.ts
index 58d97dcce2..bf82bc9cb9 100644
--- a/apps/nestjs-backend/src/features/base/base.service.spec.ts
+++ b/apps/nestjs-backend/src/features/base/base.service.spec.ts
@@ -1,5 +1,7 @@
 import type { TestingModule } from '@nestjs/testing';
 import { Test } from '@nestjs/testing';
+import { Role } from '@teable/core';
+import { CollaboratorType } from '@teable/openapi';
 import { GlobalModule } from '../../global/global.module';
 import { BaseModule } from './base.module';
 import { BaseService } from './base.service';
@@ -18,4 +20,127 @@ describe('BaseService', () => {
   it('should be defined', () => {
     expect(service).toBeDefined();
   });
+
+  describe('getBaseById', () => {
+    const createService = (params: {
+      base: {
+        id: string;
+        name: string;
+        icon: string | null;
+        spaceId: string;
+        v2Enabled: boolean;
+        createdBy: string;
+      };
+      decision: { useV2: boolean; reason: 'new_base' | 'space_feature' | 'feature_not_enabled' };
+    }) => {
+      const prismaService = {
+        base: {
+          findFirstOrThrow: vi.fn().mockResolvedValue(params.base),
+        },
+      };
+      const cls = {
+        get: vi.fn((key: string) => {
+          if (key === 'template') {
+            return { id: 'tpl1', baseId: params.base.id };
+          }
+          return undefined;
+        }),
+      };
+      const permissionService = {
+        generateTemplateHeader: vi.fn().mockReturnValue('template-header'),
+      };
+      const canaryService = {
+        shouldUseV2ForBaseWithReason: vi.fn().mockResolvedValue(params.decision),
+        isSpaceInCanary: vi.fn().mockResolvedValue(params.decision.reason === 'space_feature'),
+      };
+
+      return {
+        service: new BaseService(
+          prismaService as never,
+          cls as never,
+          {} as never,
+          {} as never,
+          permissionService as never,
+          {} as never,
+          {} as never,
+          {} as never,
+          canaryService as never,
+          {} as never,
+          {} as never
+        ),
+        canaryService,
+      };
+    };
+
+    it('returns the unified v2 status for new bases without exposing v2Enabled', async () => {
+      const base = {
+        id: 'bse1',
+        name: 'Base',
+        icon: null,
+        spaceId: 'spc1',
+        v2Enabled: true,
+        createdBy: 'usr1',
+      };
+      const { service, canaryService } = createService({
+        base,
+        decision: { useV2: true, reason: 'new_base' },
+      });
+
+      const result = await service.getBaseById(base.id);
+
+      expect(canaryService.shouldUseV2ForBaseWithReason).toHaveBeenCalledWith(
+        expect.objectContaining({ spaceId: 'spc1', v2Enabled: true }),
+        'getRecords'
+      );
+      expect(canaryService.isSpaceInCanary).toHaveBeenCalledWith('spc1');
+      expect(result).toMatchObject({
+        id: base.id,
+        role: Role.Viewer,
+        collaboratorType: CollaboratorType.Base,
+        v2Status: { useV2: true, reason: 'new_base' },
+      });
+      expect(result.isCanary).toBeUndefined();
+      expect(result).not.toHaveProperty('v2Enabled');
+    });
+
+    it('returns a v1 decision reason when the unified decision disables v2', async () => {
+      const base = {
+        id: 'bse1',
+        name: 'Base',
+        icon: null,
+        spaceId: 'spc1',
+        v2Enabled: false,
+        createdBy: 'usr1',
+      };
+      const { service } = createService({
+        base,
+        decision: { useV2: false, reason: 'feature_not_enabled' },
+      });
+
+      const result = await service.getBaseById(base.id);
+
+      expect(result.isCanary).toBeUndefined();
+      expect(result.v2Status).toEqual({ useV2: false, reason: 'feature_not_enabled' });
+    });
+
+    it('keeps the legacy isCanary flag for canary rollout decisions', async () => {
+      const base = {
+        id: 'bse1',
+        name: 'Base',
+        icon: null,
+        spaceId: 'spc1',
+        v2Enabled: false,
+        createdBy: 'usr1',
+      };
+      const { service } = createService({
+        base,
+        decision: { useV2: true, reason: 'space_feature' },
+      });
+
+      const result = await service.getBaseById(base.id);
+
+      expect(result.isCanary).toBe(true);
+      expect(result.v2Status).toEqual({ useV2: true, reason: 'space_feature' });
+    });
+  });
 });
diff --git a/apps/nestjs-backend/src/features/base/base.service.ts b/apps/nestjs-backend/src/features/base/base.service.ts
index 22fef1b101..0dc93325b6 100644
--- a/apps/nestjs-backend/src/features/base/base.service.ts
+++ b/apps/nestjs-backend/src/features/base/base.service.ts
@@ -103,6 +103,7 @@ export class BaseService {
           name: true,
           icon: true,
           spaceId: true,
+          v2Enabled: true,
           createdBy: true,
         },
         where: {
@@ -124,18 +125,25 @@ export class BaseService {
         ? { role: Role.Viewer, collaboratorType: CollaboratorType.Base }
         : await this.getRoleByBaseId(baseId, base.spaceId);
 
-    // Check if this base's space is in canary release
-    const isCanary = await this.canaryService.isSpaceInCanary(base.spaceId);
+    const [v2Status, isCanary] = await Promise.all([
+      this.canaryService.shouldUseV2ForBaseWithReason(base, 'getRecords'),
+      this.canaryService.isSpaceInCanary(base.spaceId),
+    ]);
 
     return {
-      ...base,
+      id: base.id,
+      name: base.name,
+      icon: base.icon,
+      spaceId: base.spaceId,
+      createdBy: base.createdBy,
       role,
       collaboratorType,
       template:
         template?.baseId === baseId
           ? { id: template.id, headers: this.permissionService.generateTemplateHeader(template.id) }
           : undefined,
-      isCanary: isCanary || undefined, // Only include if true
+      isCanary: isCanary || undefined,
+      v2Status,
     };
   }
 
@@ -227,6 +235,7 @@ export class BaseService {
           spaceId,
           order,
           icon,
+          v2Enabled: true,
           createdBy: userId,
         },
         select: {
diff --git a/apps/nestjs-backend/src/features/canary/canary.service.spec.ts b/apps/nestjs-backend/src/features/canary/canary.service.spec.ts
new file mode 100644
index 0000000000..a098e02046
--- /dev/null
+++ b/apps/nestjs-backend/src/features/canary/canary.service.spec.ts
@@ -0,0 +1,133 @@
+import { SettingKey } from '@teable/openapi';
+import { CanaryService } from './canary.service';
+
+describe('CanaryService', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+    vi.restoreAllMocks();
+  });
+
+  const createService = (params?: {
+    canaryHeader?: string;
+    config?: { enabled: boolean; spaceIds?: string[]; forceV2All?: boolean };
+  }) => {
+    const settingService = {
+      getSetting: vi.fn().mockResolvedValue({
+        [SettingKey.CANARY_CONFIG]: params?.config ?? null,
+      }),
+    };
+    const cls = {
+      get: vi.fn((key: string) => (key === 'canaryHeader' ? params?.canaryHeader : undefined)),
+    };
+
+    return {
+      service: new CanaryService(settingService as never, cls as never),
+      settingService,
+      cls,
+    };
+  };
+
+  it('forces v2 for a marked new base before disabled canary, config, or header decisions', async () => {
+    process.env.ENABLE_CANARY_FEATURE = 'false';
+    process.env.FORCE_V2_ALL = 'false';
+    const { service, settingService, cls } = createService({
+      canaryHeader: 'false',
+      config: { enabled: false, spaceIds: [], forceV2All: false },
+    });
+
+    const decision = await service.shouldUseV2ForBaseWithReason(
+      { spaceId: 'spc1', v2Enabled: true },
+      'createRecord'
+    );
+
+    expect(decision).toEqual({ useV2: true, reason: 'new_base' });
+    expect(settingService.getSetting).not.toHaveBeenCalled();
+    expect(cls.get).not.toHaveBeenCalled();
+  });
+
+  it('reports new_base for a marked new base even when force v2 all is enabled', async () => {
+    process.env.ENABLE_CANARY_FEATURE = 'true';
+    process.env.FORCE_V2_ALL = 'true';
+    const { service, settingService, cls } = createService({
+      canaryHeader: 'false',
+      config: { enabled: true, spaceIds: ['spc1'], forceV2All: true },
+    });
+
+    const decision = await service.shouldUseV2ForBaseWithReason(
+      { spaceId: 'spc1', v2Enabled: true },
+      'createRecord'
+    );
+
+    expect(decision).toEqual({ useV2: true, reason: 'new_base' });
+    expect(settingService.getSetting).not.toHaveBeenCalled();
+    expect(cls.get).not.toHaveBeenCalled();
+  });
+
+  it('falls back to rollout decisions for unmarked bases', async () => {
+    process.env.ENABLE_CANARY_FEATURE = 'true';
+    process.env.FORCE_V2_ALL = 'false';
+    const { service } = createService({
+      config: { enabled: true, spaceIds: ['spc1'], forceV2All: false },
+    });
+
+    const decision = await service.shouldUseV2ForBaseWithReason(
+      { spaceId: 'spc1', v2Enabled: false },
+      'createRecord'
+    );
+
+    expect(decision).toEqual({ useV2: true, reason: 'space_feature' });
+  });
+
+  it('reports env_force_v2_all before rollout config for unmarked bases', async () => {
+    process.env.ENABLE_CANARY_FEATURE = 'false';
+    process.env.FORCE_V2_ALL = 'true';
+    const { service } = createService({
+      config: { enabled: false, spaceIds: [], forceV2All: false },
+    });
+
+    const decision = await service.shouldUseV2ForBaseWithReason(
+      { spaceId: 'spc1', v2Enabled: false },
+      'getRecords'
+    );
+
+    expect(decision).toEqual({ useV2: true, reason: 'env_force_v2_all' });
+  });
+
+  it('reports config_force_v2_all before request header override for unmarked bases', async () => {
+    process.env.ENABLE_CANARY_FEATURE = 'true';
+    process.env.FORCE_V2_ALL = 'false';
+    const { service } = createService({
+      canaryHeader: 'false',
+      config: { enabled: true, spaceIds: [], forceV2All: true },
+    });
+
+    const decision = await service.shouldUseV2ForBaseWithReason(
+      { spaceId: 'spc1', v2Enabled: false },
+      'getRecords'
+    );
+
+    expect(decision).toEqual({ useV2: true, reason: 'config_force_v2_all' });
+  });
+
+  it('reports header_override when request header controls an unmarked base', async () => {
+    process.env.ENABLE_CANARY_FEATURE = 'true';
+    process.env.FORCE_V2_ALL = 'false';
+    const { service } = createService({
+      canaryHeader: 'true',
+      config: { enabled: true, spaceIds: [], forceV2All: false },
+    });
+
+    const decision = await service.shouldUseV2ForBaseWithReason(
+      { spaceId: 'spc1', v2Enabled: false },
+      'getRecords'
+    );
+
+    expect(decision).toEqual({ useV2: true, reason: 'header_override' });
+  });
+});
diff --git a/apps/nestjs-backend/src/features/canary/canary.service.ts b/apps/nestjs-backend/src/features/canary/canary.service.ts
index fdbf9dbd20..9ef17a6a1b 100644
--- a/apps/nestjs-backend/src/features/canary/canary.service.ts
+++ b/apps/nestjs-backend/src/features/canary/canary.service.ts
@@ -10,6 +10,11 @@ export interface IV2Decision {
   reason: V2Reason;
 }
 
+export interface IBaseV2DecisionContext {
+  spaceId?: string | null;
+  v2Enabled?: boolean | null;
+}
+
 @Injectable()
 export class CanaryService {
   constructor(
@@ -34,7 +39,7 @@ export class CanaryService {
 
   /**
    * Check if V2 is forced globally via environment variable (FORCE_V2_ALL=true)
-   * This has the highest priority over all other settings
+   * This is the fallback priority for bases that are not explicitly marked as new-base V2.
    */
   isForceV2AllEnabled(): boolean {
     return process.env.FORCE_V2_ALL === 'true';
@@ -86,7 +91,7 @@ export class CanaryService {
   /**
    * Determine if V2 implementation should be used for a specific feature
    * Priority:
-   * 1. FORCE_V2_ALL env var (highest priority, bypasses all checks)
+   * 1. FORCE_V2_ALL env var (highest priority for space-only checks)
    * 2. If canary feature is disabled globally, return false
    * 3. forceV2All in config (database setting)
    * 4. x-canary header override
@@ -127,12 +132,29 @@ export class CanaryService {
     return config.spaceIds?.includes(spaceId) ?? false;
   }
 
+  /**
+   * New bases are V2-first regardless of canary, request headers, or rollout config.
+   * Unsupported features still do not call this path because they have no @UseV2Feature marker.
+   */
+  async shouldUseV2ForBaseWithReason(
+    base: IBaseV2DecisionContext | null | undefined,
+    feature: V2Feature
+  ): Promise<IV2Decision> {
+    if (base?.v2Enabled) {
+      return { useV2: true, reason: 'new_base' };
+    }
+
+    return base?.spaceId
+      ? this.shouldUseV2WithReason(base.spaceId, feature)
+      : this.shouldUseV2WithReason('', feature);
+  }
+
   /**
    * Determine if V2 implementation should be used for a specific feature,
    * with detailed reason information.
    *
    * Priority:
-   * 1. FORCE_V2_ALL env var (highest priority, bypasses all checks)
+   * 1. FORCE_V2_ALL env var (highest priority for space-only checks)
    * 2. If canary feature is disabled globally, return false
    * 3. forceV2All in config (database setting)
    * 4. x-canary header override
diff --git a/apps/nestjs-backend/src/features/canary/guards/v2-feature.guard.ts b/apps/nestjs-backend/src/features/canary/guards/v2-feature.guard.ts
index 5669ba2b6e..f3fe88b325 100644
--- a/apps/nestjs-backend/src/features/canary/guards/v2-feature.guard.ts
+++ b/apps/nestjs-backend/src/features/canary/guards/v2-feature.guard.ts
@@ -5,7 +5,7 @@ import { PrismaService } from '@teable/db-main-prisma';
 import type { V2Feature } from '@teable/openapi';
 import { ClsService } from 'nestjs-cls';
 import type { IClsStore } from '../../../types/cls';
-import { CanaryService } from '../canary.service';
+import { CanaryService, type IBaseV2DecisionContext } from '../canary.service';
 import { USE_V2_FEATURE_KEY } from '../decorators/use-v2-feature.decorator';
 
 /**
@@ -65,26 +65,16 @@ export class V2FeatureGuard implements CanActivate {
       return true;
     }
 
-    // 2. Check FORCE_V2_ALL first (highest priority)
-    if (this.canaryService.isForceV2AllEnabled()) {
-      this.cls.set('useV2', true);
-      this.cls.set('v2Feature', feature);
-      this.cls.set('v2Reason', 'env_force_v2_all');
-      return true;
-    }
-
-    // 3. Get spaceId from request context
-    const spaceId = await this.getSpaceIdFromContext(context);
-
-    if (!spaceId) {
+    if (this.isUnsupportedV2Payload(req.body, feature)) {
       this.cls.set('useV2', false);
       this.cls.set('v2Feature', feature);
-      this.cls.set('v2Reason', 'disabled');
+      this.cls.set('v2Reason', 'unsupported_feature');
       return true;
     }
 
-    // 4. Determine if V2 should be used with reason
-    const decision = await this.canaryService.shouldUseV2WithReason(spaceId, feature);
+    // 2. Resolve base context when possible. Marked new bases are V2-first and bypass rollout config.
+    const base = await this.getBaseV2DecisionContext(context);
+    const decision = await this.canaryService.shouldUseV2ForBaseWithReason(base, feature);
     this.cls.set('useV2', decision.useV2);
     this.cls.set('v2Feature', feature);
     this.cls.set('v2Reason', decision.reason);
@@ -92,11 +82,30 @@ export class V2FeatureGuard implements CanActivate {
     return true;
   }
 
+  private isUnsupportedV2Payload(body: unknown, feature: V2Feature): boolean {
+    if (feature !== 'updateRecord') {
+      return false;
+    }
+
+    const updateRecordBody = body as
+      | {
+          record?: { fields?: Record<string, unknown> | null } | null;
+          order?: unknown;
+        }
+      | undefined;
+    const fields = updateRecordBody?.record?.fields ?? {};
+
+    // V2 does not yet support updateRecord calls that only reorder a record.
+    return Boolean(updateRecordBody?.order) && Object.keys(fields).length === 0;
+  }
+
   /**
-   * Extract spaceId from request context.
+   * Extract base V2 decision context from request context.
    * Supports: spaceId (direct), baseId (lookup), tableId (lookup via base)
    */
-  private async getSpaceIdFromContext(context: ExecutionContext): Promise<string | undefined> {
+  private async getBaseV2DecisionContext(
+    context: ExecutionContext
+  ): Promise<IBaseV2DecisionContext | undefined> {
     const req = context.switchToHttp().getRequest();
     const resourceId = req.params.spaceId || req.params.baseId || req.params.tableId;
 
@@ -106,16 +115,16 @@ export class V2FeatureGuard implements CanActivate {
 
     // Direct spaceId
     if (resourceId.startsWith(IdPrefix.Space)) {
-      return resourceId;
+      return { spaceId: resourceId };
     }
 
     // BaseId -> lookup spaceId
     if (resourceId.startsWith(IdPrefix.Base)) {
       const base = await this.prismaService.txClient().base.findUnique({
         where: { id: resourceId, deletedTime: null },
-        select: { spaceId: true },
+        select: { spaceId: true, v2Enabled: true },
       });
-      return base?.spaceId;
+      return base ?? undefined;
     }
 
     // TableId -> lookup baseId -> lookup spaceId
@@ -129,9 +138,9 @@ export class V2FeatureGuard implements CanActivate {
 
       const base = await this.prismaService.txClient().base.findUnique({
         where: { id: table.baseId, deletedTime: null },
-        select: { spaceId: true },
+        select: { spaceId: true, v2Enabled: true },
       });
-      return base?.spaceId;
+      return base ?? undefined;
     }
 
     return undefined;
diff --git a/apps/nestjs-backend/src/features/field/field-calculate/field-converting.service.ts b/apps/nestjs-backend/src/features/field/field-calculate/field-converting.service.ts
index cf6f63ed64..99e51fe35e 100644
--- a/apps/nestjs-backend/src/features/field/field-calculate/field-converting.service.ts
+++ b/apps/nestjs-backend/src/features/field/field-calculate/field-converting.service.ts
@@ -7,10 +7,8 @@ import type {
   IConvertFieldRo,
   ILinkFieldOptions,
   FieldCore,
-  LinkFieldCore,
 } from '@teable/core';
 import {
-  CellValueType,
   ColorUtils,
   DbFieldType,
   FIELD_VO_PROPERTIES,
@@ -1488,10 +1486,7 @@ export class FieldConvertingService {
         select: { dbTableName: true, name: true },
       });
 
-    // index do not support date cell value type
-    if (newField.cellValueType !== CellValueType.DateTime) {
-      await this.tableIndexService.createSearchFieldSingleIndex(tableId, newField);
-    }
+    await this.tableIndexService.createSearchFieldSingleIndex(tableId, newField);
 
     if (!this.needTempleCloseFieldConstraint(newField, oldField)) {
       return;
@@ -1594,6 +1589,28 @@ export class FieldConvertingService {
       );
     }
 
+    // Primary fields must stay as regular (editable) fields. Converting a primary to a
+    // lookup / conditional-lookup produces a computed primary whose cell value is derived
+    // from a link, which in turn breaks base duplication (findFirstOrThrow for the foreign
+    // table's primary can't locate a valid static primary). See T3367.
+    // lookupOptions is included for symmetry with the createField guard — leaving stray
+    // lookupOptions on a primary is the same semantic corruption even without isLookup=true.
+    if (
+      oldField.isPrimary &&
+      (updateFieldRo.isLookup || updateFieldRo.isConditionalLookup || updateFieldRo.lookupOptions)
+    ) {
+      throw new CustomHttpException(
+        'Primary field cannot be configured as a lookup field',
+        HttpErrorCode.VALIDATION_ERROR,
+        {
+          localization: {
+            i18nKey: 'httpErrors.field.primaryCannotBeLookup',
+            context: {},
+          },
+        }
+      );
+    }
+
     const newFieldVo = await this.fieldSupplementService.prepareUpdateField(
       tableId,
       updateFieldRo,
diff --git a/apps/nestjs-backend/src/features/field/field-calculate/field-supplement.service.ts b/apps/nestjs-backend/src/features/field/field-calculate/field-supplement.service.ts
index c75b7d158f..f4a3382325 100644
--- a/apps/nestjs-backend/src/features/field/field-calculate/field-supplement.service.ts
+++ b/apps/nestjs-backend/src/features/field/field-calculate/field-supplement.service.ts
@@ -29,6 +29,7 @@ import {
   LastModifiedTimeFieldCore,
   LongTextFieldCore,
   NumberFieldCore,
+  PRIMARY_SUPPORTED_TYPES,
   RatingFieldCore,
   Relationship,
   RelationshipRevert,
@@ -1764,10 +1765,70 @@ export class FieldSupplementService {
 
     this.validateFormattingShowAs(fieldVo);
     this.validateAiConfig(fieldVo);
+    await this.validatePrimaryConfigurations(tableId, [fieldVo]);
 
     return fieldVo;
   }
 
+  // Primary fields must be a static, supported type with no lookup configuration, and a table
+  // can have at most one primary. Bulk paths (table/base/field duplicate, .tea import, AI tools)
+  // historically passed isPrimary=true on raw field VOs, allowing link/checkbox/attachment/rollup
+  // primaries to slip in and tables to end up with multiple primaries. See T3367 follow-up.
+  // Aligns with v2's CreateFieldCommand guard (community/packages/v2/.../CreateFieldCommand.ts:52).
+  private async validatePrimaryConfigurations(tableId: string, fieldVos: IFieldVo[]) {
+    const newPrimaries = fieldVos.filter((f) => f.isPrimary);
+    if (newPrimaries.length === 0) return;
+
+    if (newPrimaries.length > 1) {
+      throw new CustomHttpException(
+        'Cannot create more than one primary field in a single batch',
+        HttpErrorCode.VALIDATION_ERROR,
+        {
+          localization: { i18nKey: 'httpErrors.field.primaryFieldAlreadyExists', context: {} },
+        }
+      );
+    }
+
+    for (const fieldVo of newPrimaries) {
+      if (!PRIMARY_SUPPORTED_TYPES.has(fieldVo.type)) {
+        throw new CustomHttpException(
+          `Field type ${fieldVo.type} is not supported as primary field`,
+          HttpErrorCode.VALIDATION_ERROR,
+          {
+            localization: {
+              i18nKey: 'httpErrors.field.unsupportedPrimaryFieldType',
+              context: { type: fieldVo.type },
+            },
+          }
+        );
+      }
+
+      if (fieldVo.isLookup || fieldVo.isConditionalLookup || fieldVo.lookupOptions) {
+        throw new CustomHttpException(
+          'Primary field cannot be configured as a lookup field',
+          HttpErrorCode.VALIDATION_ERROR,
+          {
+            localization: { i18nKey: 'httpErrors.field.primaryCannotBeLookup', context: {} },
+          }
+        );
+      }
+    }
+
+    const existing = await this.prismaService.txClient().field.findFirst({
+      where: { tableId, isPrimary: true, deletedTime: null },
+      select: { id: true },
+    });
+    if (existing) {
+      throw new CustomHttpException(
+        'Table already has a primary field',
+        HttpErrorCode.VALIDATION_ERROR,
+        {
+          localization: { i18nKey: 'httpErrors.field.primaryFieldAlreadyExists', context: {} },
+        }
+      );
+    }
+  }
+
   async prepareCreateFields(tableId: string, fieldRos: IFieldRo[], batchFieldVos?: IFieldVo[]) {
     // throw error when dbFieldName is duplicated
     const fieldRoDbFieldNames = fieldRos
@@ -1807,7 +1868,7 @@ export class FieldSupplementService {
 
     const dbFieldNames = await this.fieldService.generateDbFieldNames(tableId, uniqFieldNames);
 
-    return fieldRos.map((fieldRo, index) => {
+    const fieldVos = fieldRos.map((fieldRo, index) => {
       const field = fields[index];
       const fieldId = field.id || generateFieldId();
       const fieldName = uniqFieldNames[index];
@@ -1823,6 +1884,8 @@ export class FieldSupplementService {
       this.validateAiConfig(fieldVo);
       return fieldVo;
     });
+    await this.validatePrimaryConfigurations(tableId, fieldVos);
+    return fieldVos;
   }
 
   async prepareUpdateField(
diff --git a/apps/nestjs-backend/src/features/integrity/integrity-v2.service.spec.ts b/apps/nestjs-backend/src/features/integrity/integrity-v2.service.spec.ts
new file mode 100644
index 0000000000..6165ee5650
--- /dev/null
+++ b/apps/nestjs-backend/src/features/integrity/integrity-v2.service.spec.ts
@@ -0,0 +1,253 @@
+import * as Sentry from '@sentry/nestjs';
+import type * as V2AdapterTableRepositoryPostgres from '@teable/v2-adapter-table-repository-postgres';
+import type { ITracer, Table } from '@teable/v2-core';
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+
+import { IntegrityV2Service } from './integrity-v2.service';
+
+type IMetaValidationIssue = V2AdapterTableRepositoryPostgres.MetaValidationIssue;
+type ISchemaRepairResult = V2AdapterTableRepositoryPostgres.SchemaRepairResult;
+
+const schemaIntegrityRepairFeatureTag = 'schema-integrity-repair';
+const repairRuleId = 'column:fldIntegrity0001';
+const metaFieldId = 'fldIntegrity0001';
+const metaReferenceRuleId = 'meta:reference';
+const repairFailureSpanName = 'teable.IntegrityV2Service.reportRepairFailure';
+const integrityFailureKindAttribute = 'teable.integrity.failure_kind';
+const integrityRuleIdAttribute = 'teable.integrity.rule_id';
+const integrityScopeAttribute = 'teable.integrity.scope';
+const integrityTargetIdAttribute = 'teable.integrity.target_id';
+const repairStreamCrashedMessage = 'repair stream crashed';
+const createThrowingRepairStream = (message: string): AsyncGenerator<ISchemaRepairResult> =>
+  ({
+    async next() {
+      throw new Error(message);
+    },
+    async return() {
+      return {
+        done: true,
+        value: undefined,
+      };
+    },
+    async throw(error) {
+      throw error;
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+  }) as AsyncGenerator<ISchemaRepairResult>;
+
+class FakeSpan {
+  name: string;
+  attributes?: Record<string, string | number | boolean>;
+  errors: string[] = [];
+  ended = false;
+
+  constructor(name: string, attributes?: Record<string, string | number | boolean>) {
+    this.name = name;
+    this.attributes = attributes;
+  }
+
+  setAttribute(key: string, value: string | number | boolean): void {
+    this.attributes = {
+      ...(this.attributes ?? {}),
+      [key]: value,
+    };
+  }
+
+  setAttributes(attributes: Record<string, string | number | boolean>): void {
+    this.attributes = {
+      ...(this.attributes ?? {}),
+      ...attributes,
+    };
+  }
+
+  recordError(message: string): void {
+    this.errors.push(message);
+  }
+
+  end(): void {
+    this.ended = true;
+  }
+}
+
+class FakeTracer implements ITracer {
+  spans: FakeSpan[] = [];
+
+  startSpan(name: string, attributes?: Record<string, string | number | boolean>) {
+    const span = new FakeSpan(name, attributes);
+    this.spans.push(span);
+    return span;
+  }
+
+  async withSpan<T>(_span: FakeSpan, callback: () => Promise<T>): Promise<T> {
+    return await callback();
+  }
+
+  getActiveSpan(): FakeSpan | undefined {
+    return this.spans.at(-1);
+  }
+}
+
+const sentryScope = {
+  setLevel: vi.fn(),
+  setTag: vi.fn(),
+  setContext: vi.fn(),
+};
+
+vi.mock('@sentry/nestjs', () => ({
+  withScope: (callback: (scope: typeof sentryScope) => void) => callback(sentryScope),
+  captureException: vi.fn(),
+}));
+
+const createTable = (fields: unknown[] = []): Table =>
+  ({
+    id: () => ({ toString: () => 'tblIntegrity000001' }),
+    name: () => ({ toString: () => 'Tasks' }),
+    baseId: () => ({ toString: () => 'baseIntegrity0001' }),
+    getFields: () => fields,
+  }) as unknown as Table;
+
+const createMetaIssue = (): IMetaValidationIssue => ({
+  fieldId: metaFieldId,
+  fieldName: 'Status',
+  fieldType: 'lookup',
+  category: 'reference',
+  severity: 'error',
+  message: 'Link field not found: fldMissing',
+  details: {
+    relatedFieldId: 'fldMissing',
+  },
+});
+
+const createMetaIssueStream = (issue: IMetaValidationIssue): AsyncGenerator<IMetaValidationIssue> =>
+  (async function* () {
+    yield issue;
+  })();
+
+const createRepairResult = (): ISchemaRepairResult => ({
+  id: 'tblIntegrity000001:rule:error',
+  fieldId: metaFieldId,
+  fieldName: 'Status',
+  ruleId: repairRuleId,
+  ruleDescription: 'Physical column "Status" (text)',
+  status: 'error',
+  outcome: 'unchanged',
+  message: 'Schema repair failed',
+  required: true,
+  timestamp: Date.now(),
+  dependencies: [],
+  depth: 0,
+  details: {
+    statementCount: 1,
+  },
+});
+
+const collect = async <T>(stream: AsyncGenerator<T, void, unknown>): Promise<T[]> => {
+  const results: T[] = [];
+  for await (const item of stream) {
+    results.push(item);
+  }
+  return results;
+};
+
+describe('IntegrityV2Service repair telemetry', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('marks metadata reference check results as auto repairable', async () => {
+    const service = new IntegrityV2Service({} as never, {} as never);
+    const table = createTable();
+    const issue = createMetaIssue();
+
+    const stream = service['decorateMetaCheckStream'](
+      table,
+      createMetaIssueStream(issue),
+      undefined
+    );
+
+    const results = await collect(stream);
+
+    expect(results).toHaveLength(1);
+    expect(results[0]).toMatchObject({
+      fieldId: issue.fieldId,
+      ruleId: metaReferenceRuleId,
+      status: 'error',
+      repair: {
+        available: true,
+        mode: 'auto',
+      },
+    });
+  });
+
+  it('captures result-level repair failures to sentry and trace spans', async () => {
+    const service = new IntegrityV2Service({} as never, {} as never);
+    const tracer = new FakeTracer();
+    const table = createTable();
+    const result = createRepairResult();
+
+    const stream = service['decorateRepairStream'](
+      table,
+      (async function* () {
+        yield result;
+      })(),
+      undefined,
+      {
+        tracer,
+        scope: 'table',
+        targetId: table.id().toString(),
+      }
+    );
+
+    const serialized = await collect(stream);
+
+    expect(serialized).toHaveLength(1);
+    expect(Sentry.captureException).toHaveBeenCalledTimes(1);
+    expect(sentryScope.setTag).toHaveBeenCalledWith('feature', schemaIntegrityRepairFeatureTag);
+    expect(sentryScope.setTag).toHaveBeenCalledWith('integrity.failure_kind', 'result_error');
+    expect(sentryScope.setContext).toHaveBeenCalledWith(
+      'schema-integrity-repair',
+      expect.objectContaining({
+        tableId: 'tblIntegrity000001',
+        ruleId: repairRuleId,
+        failureKind: 'result_error',
+      })
+    );
+    expect(tracer.spans[0]?.name).toBe(repairFailureSpanName);
+    expect(tracer.spans[0]?.attributes).toMatchObject({
+      [integrityFailureKindAttribute]: 'result_error',
+      [integrityRuleIdAttribute]: repairRuleId,
+      [integrityScopeAttribute]: 'table',
+    });
+    expect(tracer.spans[0]?.errors).toContain('Schema repair failed');
+  });
+
+  it('captures thrown repair stream exceptions to sentry and trace spans', async () => {
+    const service = new IntegrityV2Service({} as never, {} as never);
+    const tracer = new FakeTracer();
+    const table = createTable();
+
+    const stream = service['decorateRepairStream'](
+      table,
+      createThrowingRepairStream(repairStreamCrashedMessage),
+      undefined,
+      {
+        tracer,
+        scope: 'base',
+        targetId: table.baseId().toString(),
+      }
+    );
+
+    await expect(collect(stream)).rejects.toThrow(repairStreamCrashedMessage);
+
+    expect(Sentry.captureException).toHaveBeenCalledTimes(1);
+    expect(sentryScope.setTag).toHaveBeenCalledWith('integrity.failure_kind', 'stream_exception');
+    expect(tracer.spans[0]?.attributes).toMatchObject({
+      [integrityFailureKindAttribute]: 'stream_exception',
+      [integrityScopeAttribute]: 'base',
+      [integrityTargetIdAttribute]: 'baseIntegrity0001',
+    });
+    expect(tracer.spans[0]?.errors).toContain(repairStreamCrashedMessage);
+  });
+});
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 2f8fa2b09a..498cd18bda 100644
--- a/apps/nestjs-backend/src/features/integrity/integrity-v2.service.ts
+++ b/apps/nestjs-backend/src/features/integrity/integrity-v2.service.ts
@@ -1,4 +1,5 @@
 import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
+import * as Sentry from '@sentry/nestjs';
 import type {
   IV2BaseSchemaIntegrityRepairRo,
   IV2SchemaIntegrityFilterStatus,
@@ -12,20 +13,30 @@ import type {
 } from '@teable/openapi';
 import { v2PostgresDbTokens } from '@teable/v2-adapter-db-postgres-pg';
 import {
+  checkTableMetaWithTables,
+  createMetaRepairer,
   createSchemaChecker,
   createSchemaRepairer,
+  getMetaIssueDetails,
+  getMetaRepairHint,
+  getMetaRuleId,
+  isMetaRuleId,
+  metaRuleDescription,
   PostgresSchemaIntrospector,
+  type MetaValidationIssue,
   type SchemaCheckResult,
   type SchemaRepairResult,
   type SchemaRuleRepairHint,
 } from '@teable/v2-adapter-table-repository-postgres';
 import {
   BaseId,
+  TeableSpanAttributes,
   TableByBaseIdSpec,
   TableByIdSpec,
   TableId,
   v2CoreTokens,
   type IBaseRepository,
+  type ITracer,
   type ITableRepository,
   type Table,
 } from '@teable/v2-core';
@@ -33,6 +44,17 @@ import { V2ContainerService } from '../v2/v2-container.service';
 import { V2ExecutionContextFactory } from '../v2/v2-execution-context.factory';
 
 type ISchemaIntegrityDb = Parameters<typeof createSchemaChecker>[0]['db'];
+type IRepairTelemetryScope = 'table' | 'base';
+type IRepairTelemetryKind = 'result_error' | 'stream_exception';
+
+const schemaIntegrityRepairFeatureTag = 'schema-integrity-repair';
+const teableBaseIdAttribute = 'teable.base_id';
+const integrityScopeAttribute = 'teable.integrity.scope';
+const integrityTargetIdAttribute = 'teable.integrity.target_id';
+const integrityFailureKindAttribute = 'teable.integrity.failure_kind';
+const integrityRuleIdAttribute = 'teable.integrity.rule_id';
+const integrityOutcomeAttribute = 'teable.integrity.outcome';
+const integrityRequiredAttribute = 'teable.integrity.required';
 
 @Injectable()
 export class IntegrityV2Service {
@@ -45,27 +67,48 @@ export class IntegrityV2Service {
     tableId: string,
     statuses?: IV2SchemaIntegrityFilterStatus[]
   ): Promise<AsyncGenerator<IV2SchemaIntegrityCheckResult, void, unknown>> {
-    const { table, db, schema } = await this.resolveSchemaTarget(tableId);
+    const { table, tables, db, schema } = await this.resolveSchemaTarget(tableId, {
+      includeBaseTables: true,
+    });
     const checker = createSchemaChecker({
       db,
       introspector: new PostgresSchemaIntrospector(db),
       schema,
     });
 
-    return this.decorateCheckStream(table, checker.checkTable(table), statuses);
+    return this.streamTableChecks(table, tables, checker, statuses);
   }
 
   async createRepairStream(
     tableId: string,
     repairRo: IV2SchemaIntegrityRepairRo
   ): Promise<AsyncGenerator<IV2SchemaIntegrityRepairResult, void, unknown>> {
-    const { table, db, schema } = await this.resolveSchemaTarget(tableId);
+    const { table, tables, db, schema, context } = await this.resolveSchemaTarget(tableId, {
+      includeBaseTables: true,
+    });
 
     const repairer = createSchemaRepairer({
       db,
       introspector: new PostgresSchemaIntrospector(db),
       schema,
     });
+    const metaRepairer = createMetaRepairer({ db });
+
+    if (repairRo.fieldId && isMetaRuleId(repairRo.ruleId)) {
+      return this.decorateRepairStream(
+        table,
+        metaRepairer.repairRule(table, tables, repairRo.fieldId, repairRo.ruleId, {
+          dryRun: repairRo.dryRun,
+          targetStatuses: repairRo.targetStatuses,
+        }),
+        repairRo.statuses,
+        {
+          tracer: context.tracer,
+          scope: 'table',
+          targetId: tableId,
+        }
+      );
+    }
 
     if (repairRo.fieldId && repairRo.ruleId) {
       return this.decorateRepairStream(
@@ -75,28 +118,55 @@ export class IntegrityV2Service {
           manualRepairValues: repairRo.manualRepairValues,
           targetStatuses: repairRo.targetStatuses,
         }),
-        repairRo.statuses
+        repairRo.statuses,
+        {
+          tracer: context.tracer,
+          scope: 'table',
+          targetId: tableId,
+        }
       );
     }
 
     if (repairRo.fieldId) {
       return this.decorateRepairStream(
         table,
-        repairer.repairField(table, repairRo.fieldId, {
-          dryRun: repairRo.dryRun,
-          targetStatuses: repairRo.targetStatuses,
-        }),
-        repairRo.statuses
+        this.combineRepairStreams(
+          repairer.repairField(table, repairRo.fieldId, {
+            dryRun: repairRo.dryRun,
+            targetStatuses: repairRo.targetStatuses,
+          }),
+          metaRepairer.repairField(table, tables, repairRo.fieldId, {
+            dryRun: repairRo.dryRun,
+            targetStatuses: repairRo.targetStatuses,
+          })
+        ),
+        repairRo.statuses,
+        {
+          tracer: context.tracer,
+          scope: 'table',
+          targetId: tableId,
+        }
       );
     }
 
     return this.decorateRepairStream(
       table,
-      repairer.repairTable(table, {
-        dryRun: repairRo.dryRun,
-        targetStatuses: repairRo.targetStatuses,
-      }),
-      repairRo.statuses
+      this.combineRepairStreams(
+        repairer.repairTable(table, {
+          dryRun: repairRo.dryRun,
+          targetStatuses: repairRo.targetStatuses,
+        }),
+        metaRepairer.repairTable(table, tables, {
+          dryRun: repairRo.dryRun,
+          targetStatuses: repairRo.targetStatuses,
+        })
+      ),
+      repairRo.statuses,
+      {
+        tracer: context.tracer,
+        scope: 'table',
+        targetId: tableId,
+      }
     );
   }
 
@@ -118,17 +188,27 @@ export class IntegrityV2Service {
     baseId: string,
     repairRo: IV2BaseSchemaIntegrityRepairRo
   ): Promise<AsyncGenerator<IV2SchemaIntegrityRepairResult, void, unknown>> {
-    const { tables, db, schema } = await this.resolveBaseTarget(baseId);
+    const { tables, db, schema, context } = await this.resolveBaseTarget(baseId);
     const repairer = createSchemaRepairer({
       db,
       introspector: new PostgresSchemaIntrospector(db),
       schema,
     });
+    const metaRepairer = createMetaRepairer({ db });
 
-    return this.streamBaseRepairs(tables, repairer, repairRo);
+    return this.streamBaseRepairs(tables, repairer, metaRepairer, repairRo, {
+      tracer: context.tracer,
+      scope: 'base',
+      targetId: baseId,
+    });
   }
 
-  private async resolveSchemaTarget(tableId: string) {
+  private async resolveSchemaTarget(
+    tableId: string,
+    options?: {
+      includeBaseTables?: boolean;
+    }
+  ) {
     const parsedTableId = TableId.create(tableId);
     if (parsedTableId.isErr()) {
       throw new HttpException(parsedTableId.error.message, HttpStatus.BAD_REQUEST);
@@ -148,11 +228,27 @@ export class IntegrityV2Service {
 
     const db = container.resolve<ISchemaIntegrityDb>(v2PostgresDbTokens.db);
     const table = tableResult.value;
+    let tables: ReadonlyArray<Table> = [table];
+
+    if (options?.includeBaseTables) {
+      const tablesResult = await tableRepository.find(
+        context,
+        TableByBaseIdSpec.create(table.baseId())
+      );
+
+      if (tablesResult.isErr()) {
+        throw new HttpException(tablesResult.error.message, HttpStatus.INTERNAL_SERVER_ERROR);
+      }
+
+      tables = tablesResult.value;
+    }
 
     return {
       table,
+      tables,
       db,
       schema: table.baseId().toString(),
+      context,
     };
   }
 
@@ -194,32 +290,60 @@ export class IntegrityV2Service {
       tables,
       db,
       schema: parsedBaseId.value.toString(),
+      context,
     };
   }
 
+  private async *streamTableChecks(
+    table: Table,
+    allTables: ReadonlyArray<Table>,
+    checker: ReturnType<typeof createSchemaChecker>,
+    statuses?: IV2SchemaIntegrityFilterStatus[]
+  ): AsyncGenerator<IV2SchemaIntegrityCheckResult, void, unknown> {
+    yield* this.decorateCheckStream(table, checker.checkTable(table), statuses);
+    yield* this.decorateMetaCheckStream(
+      table,
+      checkTableMetaWithTables(table, table.baseId(), allTables),
+      statuses
+    );
+  }
+
   private async *streamBaseChecks(
     tables: ReadonlyArray<Table>,
     checker: ReturnType<typeof createSchemaChecker>,
     statuses?: IV2SchemaIntegrityFilterStatus[]
   ): AsyncGenerator<IV2SchemaIntegrityCheckResult, void, unknown> {
     for (const table of tables) {
-      yield* this.decorateCheckStream(table, checker.checkTable(table), statuses);
+      yield* this.streamTableChecks(table, tables, checker, statuses);
     }
   }
 
   private async *streamBaseRepairs(
     tables: ReadonlyArray<Table>,
     repairer: ReturnType<typeof createSchemaRepairer>,
-    repairRo: IV2BaseSchemaIntegrityRepairRo
+    metaRepairer: ReturnType<typeof createMetaRepairer>,
+    repairRo: IV2BaseSchemaIntegrityRepairRo,
+    telemetry: {
+      tracer?: ITracer;
+      scope: IRepairTelemetryScope;
+      targetId: string;
+    }
   ): AsyncGenerator<IV2SchemaIntegrityRepairResult, void, unknown> {
     for (const table of tables) {
       yield* this.decorateRepairStream(
         table,
-        repairer.repairTable(table, {
-          dryRun: repairRo.dryRun,
-          targetStatuses: repairRo.targetStatuses,
-        }),
-        repairRo.statuses
+        this.combineRepairStreams(
+          repairer.repairTable(table, {
+            dryRun: repairRo.dryRun,
+            targetStatuses: repairRo.targetStatuses,
+          }),
+          metaRepairer.repairTable(table, tables, {
+            dryRun: repairRo.dryRun,
+            targetStatuses: repairRo.targetStatuses,
+          })
+        ),
+        repairRo.statuses,
+        telemetry
       );
     }
   }
@@ -243,16 +367,176 @@ export class IntegrityV2Service {
   private async *decorateRepairStream(
     table: Table,
     stream: AsyncGenerator<SchemaRepairResult, void, unknown>,
-    statuses?: IV2SchemaIntegrityFilterStatus[]
+    statuses?: IV2SchemaIntegrityFilterStatus[],
+    telemetry?: {
+      tracer?: ITracer;
+      scope: IRepairTelemetryScope;
+      targetId: string;
+    }
   ): AsyncGenerator<IV2SchemaIntegrityRepairResult, void, unknown> {
     const statusFilter = this.createStatusFilterSet(statuses);
-    for await (const result of stream) {
-      const serialized = this.serializeRepairResult(table, result);
-      if (!this.shouldIncludeResult(serialized.status, statusFilter)) {
+    try {
+      for await (const result of stream) {
+        const serialized = this.serializeRepairResult(table, result);
+        if (serialized.status === 'error' && telemetry) {
+          await this.captureRepairFailure(
+            table,
+            result,
+            new Error(result.message),
+            telemetry,
+            'result_error'
+          );
+        }
+
+        if (!this.shouldIncludeResult(serialized.status, statusFilter)) {
+          continue;
+        }
+
+        yield serialized;
+      }
+    } catch (error) {
+      if (telemetry) {
+        await this.captureRepairFailure(table, undefined, error, telemetry, 'stream_exception');
+      }
+      throw error;
+    }
+  }
+
+  private async *combineRepairStreams(
+    ...streams: ReadonlyArray<AsyncGenerator<SchemaRepairResult, void, unknown>>
+  ): AsyncGenerator<SchemaRepairResult, void, unknown> {
+    for (const stream of streams) {
+      yield* stream;
+    }
+  }
+
+  private async captureRepairFailure(
+    table: Table,
+    result: SchemaRepairResult | undefined,
+    error: unknown,
+    telemetry: {
+      tracer?: ITracer;
+      scope: IRepairTelemetryScope;
+      targetId: string;
+    },
+    kind: IRepairTelemetryKind
+  ): Promise<void> {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const tableId = table.id().toString();
+    const baseId = table.baseId().toString();
+    const spanAttributes: Record<string, string | number | boolean> = {
+      [TeableSpanAttributes.VERSION]: 'v2',
+      [TeableSpanAttributes.COMPONENT]: 'service',
+      [TeableSpanAttributes.OPERATION]: 'integrity.repair.failure',
+      [TeableSpanAttributes.TABLE_ID]: tableId,
+      [teableBaseIdAttribute]: baseId,
+      [integrityScopeAttribute]: telemetry.scope,
+      [integrityTargetIdAttribute]: telemetry.targetId,
+      [integrityFailureKindAttribute]: kind,
+    };
+
+    if (result?.fieldId && result.fieldId !== '__system__') {
+      spanAttributes[TeableSpanAttributes.FIELD_ID] = result.fieldId;
+    }
+    if (result?.ruleId) {
+      spanAttributes[integrityRuleIdAttribute] = result.ruleId;
+    }
+    if (result?.outcome) {
+      spanAttributes[integrityOutcomeAttribute] = result.outcome;
+    }
+    if (result?.required != null) {
+      spanAttributes[integrityRequiredAttribute] = result.required;
+    }
+
+    const reportToSentry = () => {
+      Sentry.withScope((scope) => {
+        scope.setLevel?.('error');
+        scope.setTag('feature', schemaIntegrityRepairFeatureTag);
+        scope.setTag('integrity.scope', telemetry.scope);
+        scope.setTag('integrity.target_id', telemetry.targetId);
+        scope.setTag('integrity.failure_kind', kind);
+        scope.setTag('base.id', baseId);
+        scope.setTag('table.id', tableId);
+
+        if (result?.ruleId) {
+          scope.setTag('integrity.rule_id', result.ruleId);
+        }
+        if (result?.fieldId && result.fieldId !== '__system__') {
+          scope.setTag('field.id', result.fieldId);
+        }
+
+        scope.setContext('schema-integrity-repair', {
+          baseId,
+          tableId,
+          tableName: table.name().toString(),
+          scope: telemetry.scope,
+          targetId: telemetry.targetId,
+          failureKind: kind,
+          resultId: result?.id,
+          fieldId: result?.fieldId,
+          fieldName: result?.fieldName,
+          ruleId: result?.ruleId,
+          ruleDescription: result?.ruleDescription,
+          outcome: result?.outcome,
+          required: result?.required,
+          details: result?.details,
+        });
+
+        Sentry.captureException(err);
+      });
+    };
+
+    const tracer = telemetry.tracer;
+    if (!tracer) {
+      reportToSentry();
+      return;
+    }
+
+    const span = tracer.startSpan('teable.IntegrityV2Service.reportRepairFailure', spanAttributes);
+    try {
+      span.recordError(err.message);
+      await tracer.withSpan(span, async () => {
+        reportToSentry();
+      });
+    } finally {
+      span.end();
+    }
+  }
+
+  private async *decorateMetaCheckStream(
+    table: Table,
+    stream: AsyncGenerator<MetaValidationIssue, void, unknown>,
+    statuses?: IV2SchemaIntegrityFilterStatus[]
+  ): AsyncGenerator<IV2SchemaIntegrityCheckResult, void, unknown> {
+    const statusFilter = this.createStatusFilterSet(statuses);
+
+    for await (const issue of stream) {
+      const status = this.toMetaCheckStatus(issue.severity);
+      if (!status || !this.shouldIncludeResult(status, statusFilter)) {
         continue;
       }
 
-      yield serialized;
+      yield {
+        id: this.createScopedResultId(table, `${issue.fieldId}:${getMetaRuleId(issue)}`),
+        baseId: table.baseId().toString(),
+        tableId: table.id().toString(),
+        tableName: table.name().toString(),
+        fieldId: issue.fieldId,
+        fieldName: issue.fieldName,
+        ruleId: getMetaRuleId(issue),
+        ruleDescription: metaRuleDescription,
+        status,
+        message: issue.message,
+        details: this.toMutableDetails(getMetaIssueDetails(issue)),
+        repair:
+          status === 'error' || status === 'warn'
+            ? this.toMutableRepairHint(getMetaRepairHint(issue))
+            : undefined,
+        required: true,
+        timestamp: Date.now(),
+        dependencies: [],
+        depth: 0,
+      };
     }
   }
 
@@ -262,6 +546,7 @@ export class IntegrityV2Service {
   ): IV2SchemaIntegrityCheckResult {
     return {
       id: this.createScopedResultId(table, result.id),
+      baseId: table.baseId().toString(),
       tableId: table.id().toString(),
       tableName: table.name().toString(),
       fieldId: result.fieldId,
@@ -270,14 +555,7 @@ export class IntegrityV2Service {
       ruleDescription: result.ruleDescription,
       status: result.status,
       message: result.message,
-      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,
+      details: this.toMutableDetails(result.details),
       repair: result.repair ? this.toMutableRepairHint(result.repair) : undefined,
       required: result.required,
       timestamp: result.timestamp,
@@ -292,6 +570,7 @@ export class IntegrityV2Service {
   ): IV2SchemaIntegrityRepairResult {
     return {
       id: this.createScopedResultId(table, result.id),
+      baseId: table.baseId().toString(),
       tableId: table.id().toString(),
       tableName: table.name().toString(),
       fieldId: result.fieldId,
@@ -301,15 +580,7 @@ export class IntegrityV2Service {
       status: result.status,
       outcome: result.outcome,
       message: result.message,
-      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,
+      details: this.toMutableDetails(result.details),
       repair: result.repair ? this.toMutableRepairHint(result.repair) : undefined,
       required: result.required,
       timestamp: result.timestamp,
@@ -322,6 +593,22 @@ export class IntegrityV2Service {
     return `${table.id().toString()}:${id}`;
   }
 
+  private toMutableDetails(details?: SchemaRepairResult['details']) {
+    return details
+      ? {
+          missing: this.toMutableArray(details.missing),
+          missingItems: this.toMutableDetailItems(details.missingItems),
+          extra: this.toMutableArray(details.extra),
+          extraItems: this.toMutableDetailItems(details.extraItems),
+          statementCount: details.statementCount,
+          statements: details.statements?.map((statement) => ({
+            sql: statement.sql,
+            parameters: [...statement.parameters],
+          })),
+        }
+      : undefined;
+  }
+
   private toMutableArray(values?: ReadonlyArray<string>): string[] | undefined {
     return values ? [...values] : undefined;
   }
@@ -461,4 +748,12 @@ export class IntegrityV2Service {
 
     return statusFilter.has(status as IV2SchemaIntegrityFilterStatus);
   }
+
+  private toMetaCheckStatus(
+    severity: MetaValidationIssue['severity']
+  ): IV2SchemaIntegrityCheckResult['status'] | undefined {
+    if (severity === 'error') return 'error';
+    if (severity === 'warning') return 'warn';
+    return undefined;
+  }
 }
diff --git a/apps/nestjs-backend/src/features/integrity/integrity.module.ts b/apps/nestjs-backend/src/features/integrity/integrity.module.ts
index aa045bd587..5eff36fec6 100644
--- a/apps/nestjs-backend/src/features/integrity/integrity.module.ts
+++ b/apps/nestjs-backend/src/features/integrity/integrity.module.ts
@@ -1,5 +1,6 @@
 import { Module } from '@nestjs/common';
 import { CanaryModule } from '../canary/canary.module';
+import { FieldOpenApiModule } from '../field/open-api/field-open-api.module';
 import { FieldModule } from '../field/field.module';
 import { TableDomainQueryModule } from '../table-domain';
 import { V2Module } from '../v2/v2.module';
@@ -12,7 +13,7 @@ import { LinkIntegrityService } from './link-integrity.service';
 import { UniqueIndexService } from './unique-index.service';
 
 @Module({
-  imports: [FieldModule, TableDomainQueryModule, V2Module, CanaryModule],
+  imports: [FieldModule, FieldOpenApiModule, TableDomainQueryModule, V2Module, CanaryModule],
   controllers: [IntegrityController, IntegrityV2Controller],
   providers: [
     ForeignKeyIntegrityService,
diff --git a/apps/nestjs-backend/src/features/integrity/link-integrity.service.ts b/apps/nestjs-backend/src/features/integrity/link-integrity.service.ts
index f86ae63fbd..967849cd50 100644
--- a/apps/nestjs-backend/src/features/integrity/link-integrity.service.ts
+++ b/apps/nestjs-backend/src/features/integrity/link-integrity.service.ts
@@ -4,6 +4,7 @@ import {
   FieldType,
   CellValueType,
   DbFieldType,
+  PRIMARY_SUPPORTED_TYPES,
   Relationship,
   DriverClient,
   getValidFilterOperators,
@@ -27,6 +28,7 @@ import { LinkFieldQueryService } from '../field/field-calculate/link-field-query
 import { FieldService } from '../field/field.service';
 import { createFieldInstanceByRaw } from '../field/model/factory';
 import type { LinkFieldDto } from '../field/model/field-dto/link-field.dto';
+import { FieldOpenApiService } from '../field/open-api/field-open-api.service';
 import { TableDomainQueryService } from '../table-domain';
 import { ForeignKeyIntegrityService } from './foreign-key.service';
 import { LinkFieldIntegrityService } from './link-field.service';
@@ -44,6 +46,7 @@ export class LinkIntegrityService {
     private readonly tableDomainQueryService: TableDomainQueryService,
     private readonly linkFieldQueryService: LinkFieldQueryService,
     private readonly fieldService: FieldService,
+    private readonly fieldOpenApiService: FieldOpenApiService,
     @InjectDbProvider() private readonly dbProvider: IDbProvider,
     @InjectModel('CUSTOM_KNEX') private readonly knex: Knex
   ) {}
@@ -161,12 +164,102 @@ export class LinkIntegrityService {
       });
     }
 
+    const invalidPrimaryIssues = await this.checkInvalidPrimary(baseId);
+    if (invalidPrimaryIssues.length > 0) {
+      linkFieldIssues.push({
+        baseId: mainBase.id,
+        baseName: mainBase.name,
+        issues: invalidPrimaryIssues,
+      });
+    }
+
+    const missingPrimaryIssues = await this.checkMissingPrimary(baseId);
+    if (missingPrimaryIssues.length > 0) {
+      linkFieldIssues.push({
+        baseId: mainBase.id,
+        baseName: mainBase.name,
+        issues: missingPrimaryIssues,
+      });
+    }
+
     return {
       hasIssues: linkFieldIssues.length > 0,
       linkFieldIssues,
     };
   }
 
+  // Detect primary fields that break base duplication / symmetric link generation:
+  //   1. Lookup-ish primaries — isLookup, isConditionalLookup, or stray lookupOptions.
+  //      Origin: convertField path before T3367 (e.g. AI flipped Employee→lookup).
+  //   2. Unsupported-type primaries — link/checkbox/attachment/rollup as primary.
+  //      Origin: bulk createFieldsByRo (duplicate/import/AI), now blocked at the source.
+  // Both states make `findFirstOrThrow({tableId, isPrimary: true})` return a field that can't
+  // serve as a static lookupFieldId for symmetric links.
+  private async checkInvalidPrimary(baseId: string): Promise<IIntegrityIssue[]> {
+    const fields = await this.prismaService.field.findMany({
+      where: {
+        deletedTime: null,
+        isPrimary: true,
+        table: { baseId, deletedTime: null },
+        OR: [
+          { isLookup: true },
+          { isConditionalLookup: true },
+          { lookupOptions: { not: null } },
+          { type: { notIn: Array.from(PRIMARY_SUPPORTED_TYPES) } },
+        ],
+      },
+      select: {
+        id: true,
+        name: true,
+        type: true,
+        isLookup: true,
+        isConditionalLookup: true,
+        lookupOptions: true,
+        tableId: true,
+        table: { select: { name: true } },
+      },
+    });
+
+    return fields.map((f) => {
+      const isLookupish = f.isLookup || f.isConditionalLookup || f.lookupOptions !== null;
+      const type = isLookupish
+        ? IntegrityIssueType.InvalidPrimaryLookup
+        : IntegrityIssueType.InvalidPrimaryType;
+      const reason = isLookupish
+        ? 'is incorrectly configured as a lookup field'
+        : `has unsupported type "${f.type}"`;
+      return {
+        fieldId: f.id,
+        tableId: f.tableId,
+        type,
+        message: `Primary field "${f.name}" in table "${f.table.name}" ${reason}, which breaks base duplication. Fixing will demote it and promote an existing eligible field as primary; if no candidate qualifies, a new formula field mirroring the current value is added and the bad primary is renamed with a "(before-fix)" suffix.`,
+      };
+    });
+  }
+
+  // Detect tables that have no primary field at all. `field-supplement.generateSymmetricField`
+  // does `findFirstOrThrow({tableId, isPrimary: true})` when creating link fields during base
+  // duplication; a missing primary makes that throw.
+  private async checkMissingPrimary(baseId: string): Promise<IIntegrityIssue[]> {
+    const tables = await this.prismaService.tableMeta.findMany({
+      where: {
+        baseId,
+        deletedTime: null,
+        fields: { none: { isPrimary: true, deletedTime: null } },
+      },
+      select: { id: true, name: true },
+    });
+
+    return tables.map((t) => ({
+      // fieldId is required by the schema; use tableId as a stable placeholder so the fix
+      // dispatcher can locate the table without a real field reference.
+      fieldId: t.id,
+      tableId: t.id,
+      type: IntegrityIssueType.MissingPrimary,
+      message: `Table "${t.name}" has no primary field, which breaks base duplication. Fixing will promote the first existing eligible field as primary, or add a new "Name" text field if none qualifies.`,
+    }));
+  }
+
   private async checkReferenceField(baseId: string): Promise<IIntegrityIssue[]> {
     const tables = await this.prismaService.tableMeta.findMany({
       where: { baseId, deletedTime: null },
@@ -859,6 +952,18 @@ export class LinkIntegrityService {
             result && fixResults.push(result);
             break;
           }
+          case IntegrityIssueType.InvalidPrimaryLookup:
+          case IntegrityIssueType.InvalidPrimaryType: {
+            const result = await this.fixInvalidPrimary(issue.fieldId, issue.type);
+            result && fixResults.push(result);
+            break;
+          }
+          case IntegrityIssueType.MissingPrimary: {
+            // For missing-primary issues fieldId carries the tableId (see checkMissingPrimary).
+            const result = await this.fixMissingPrimary(issue.fieldId);
+            result && fixResults.push(result);
+            break;
+          }
           default:
             break;
         }
@@ -886,6 +991,189 @@ export class LinkIntegrityService {
     };
   }
 
+  async fixInvalidPrimary(
+    fieldId: string,
+    issueType: IntegrityIssueType
+  ): Promise<IIntegrityIssue | undefined> {
+    const oldField = await this.prismaService.field.findFirst({
+      where: {
+        id: fieldId,
+        deletedTime: null,
+        isPrimary: true,
+      },
+      select: { id: true, name: true, tableId: true },
+    });
+    if (!oldField) return;
+
+    // Strategy: atomic via outer $tx — inner $tx calls from updateField / createField reuse
+    // the same transaction, so any failure rolls back all partial mutations.
+    //   1. Demote the bad primary (direct DB — no service for primary toggle).
+    //   2. If the table still has a separate valid primary → keep it as-is (defensive).
+    //   3. Else if any field qualifies as primary → promote it directly.
+    //   4. Else fall back: rename the bad primary to "(before-fix)" so the original name
+    //      is free, then create + promote a formula field mirroring the old value.
+    // The old bad primary is always preserved so existing references (link preview
+    // `options.lookupFieldId`, downstream lookups/rollups/formulas) keep working.
+
+    const primaryFieldFilter = {
+      deletedTime: null,
+      isLookup: null,
+      isConditionalLookup: null,
+      lookupOptions: null,
+      type: { in: Array.from(PRIMARY_SUPPORTED_TYPES) },
+    };
+
+    const result = await this.prismaService.$tx(async (prisma) => {
+      // Demote the bad primary first. Rename is deferred — only the formula fallback path
+      // needs to free up the original name for the new field.
+      await prisma.field.update({
+        where: { id: oldField.id },
+        data: { isPrimary: null },
+      });
+
+      // Defensive: if a separate valid primary already exists in the table, leave it alone.
+      // Avoids leaving the table with multiple primaries (which the integrity check doesn't
+      // detect today). Production has zero such tables and validatePrimaryConfigurations
+      // blocks new ones, but this guards races / direct SQL writes / future regressions.
+      const existingValidPrimary = await prisma.field.findFirst({
+        where: { tableId: oldField.tableId, isPrimary: true, ...primaryFieldFilter },
+        select: { id: true, name: true },
+      });
+
+      if (existingValidPrimary) {
+        return { kind: 'kept' as const, field: existingValidPrimary };
+      }
+
+      // Prefer promoting an existing eligible candidate over creating a new formula field.
+      // Mirrors fixMissingPrimary's behavior — fewer artifact fields, simpler table shape.
+      // The promoted field's displayed value will replace the bad primary's value; the bad
+      // primary itself stays untouched (no rename needed since no name collision).
+      const candidate = await prisma.field.findFirst({
+        where: { tableId: oldField.tableId, ...primaryFieldFilter },
+        orderBy: { order: 'asc' },
+        select: { id: true, name: true },
+      });
+
+      if (candidate) {
+        await prisma.field.update({
+          where: { id: candidate.id },
+          data: { isPrimary: true },
+        });
+        return { kind: 'promoted' as const, field: candidate };
+      }
+
+      // Fallback: no eligible candidate exists. Rename the bad primary so the new formula
+      // field can take its name, then create the formula mirroring the original value.
+      const legacyName = `${oldField.name} (before-fix)`;
+      await this.fieldOpenApiService.updateField(oldField.tableId, oldField.id, {
+        name: legacyName,
+      });
+      const newField = await this.fieldOpenApiService.createField(oldField.tableId, {
+        type: FieldType.Formula,
+        name: oldField.name,
+        options: {
+          expression: `{${oldField.id}}`,
+        },
+      });
+
+      await prisma.field.update({
+        where: { id: newField.id },
+        data: { isPrimary: true },
+      });
+
+      return {
+        kind: 'created' as const,
+        field: { id: newField.id, name: oldField.name },
+        legacyName,
+      };
+    });
+
+    const baseMsg = `Demoted invalid primary "${oldField.name}" (id ${oldField.id}).`;
+    if (result.kind === 'kept') {
+      return {
+        type: issueType,
+        fieldId,
+        message: `${baseMsg} Existing valid primary "${result.field.name}" (${result.field.id}) preserved.`,
+      };
+    }
+    if (result.kind === 'promoted') {
+      return {
+        type: issueType,
+        fieldId,
+        message: `${baseMsg} Promoted existing field "${result.field.name}" (${result.field.id}) to primary.`,
+      };
+    }
+    return {
+      type: issueType,
+      fieldId,
+      message: `Demoted invalid primary "${oldField.name}" (renamed to "${result.legacyName}", id ${oldField.id}). Added new formula field "${result.field.name}" (${result.field.id}) as primary, mirroring the original value.`,
+    };
+  }
+
+  async fixMissingPrimary(tableId: string): Promise<IIntegrityIssue | undefined> {
+    const table = await this.prismaService.tableMeta.findFirst({
+      where: { id: tableId, deletedTime: null },
+      select: { id: true, name: true },
+    });
+    if (!table) return;
+
+    // Re-check inside the transaction to avoid racing with a concurrent promotion.
+    return this.prismaService.$tx(async () => {
+      const prisma = this.prismaService.txClient();
+      const existing = await prisma.field.findFirst({
+        where: { tableId, isPrimary: true, deletedTime: null },
+        select: { id: true },
+      });
+      if (existing) return undefined;
+
+      // Prefer promoting an existing valid candidate. Avoids leaving a stray "Name 2"
+      // alongside the user's existing fields and matches the natural intuition that
+      // the first usable column should be primary.
+      const candidate = await prisma.field.findFirst({
+        where: {
+          tableId,
+          deletedTime: null,
+          isLookup: null,
+          isConditionalLookup: null,
+          lookupOptions: null,
+          type: { in: Array.from(PRIMARY_SUPPORTED_TYPES) },
+        },
+        orderBy: { order: 'asc' },
+        select: { id: true, name: true },
+      });
+
+      if (candidate) {
+        await prisma.field.update({
+          where: { id: candidate.id },
+          data: { isPrimary: true },
+        });
+        return {
+          type: IntegrityIssueType.MissingPrimary,
+          fieldId: candidate.id,
+          tableId,
+          message: `Promoted existing field "${candidate.name}" (${candidate.id}) to primary in table "${table.name}".`,
+        };
+      }
+
+      // Fallback: no usable candidate (every field is link / checkbox / attachment /
+      // rollup / lookup-ish). Create a new "Name" text field as primary.
+      const newField = await this.fieldOpenApiService.createField(tableId, {
+        type: FieldType.SingleLineText,
+        name: 'Name',
+      });
+      await prisma.field.update({
+        where: { id: newField.id },
+        data: { isPrimary: true },
+      });
+      return {
+        type: IntegrityIssueType.MissingPrimary,
+        fieldId: newField.id,
+        tableId,
+        message: `Added "Name" text field (${newField.id}) as primary in table "${table.name}".`,
+      };
+    });
+  }
+
   async fixOneWayLinkField(fieldId: string): Promise<IIntegrityIssue | undefined> {
     const field = await this.prismaService.field.findFirstOrThrow({
       where: { id: fieldId, deletedTime: null },
diff --git a/apps/nestjs-backend/src/features/record/query-builder/sql-conversion.visitor.ts b/apps/nestjs-backend/src/features/record/query-builder/sql-conversion.visitor.ts
index 5d40cc615d..7d38463274 100644
--- a/apps/nestjs-backend/src/features/record/query-builder/sql-conversion.visitor.ts
+++ b/apps/nestjs-backend/src/features/record/query-builder/sql-conversion.visitor.ts
@@ -1621,9 +1621,26 @@ abstract class BaseSqlConversionVisitor<
     return `((${valueSql}))::boolean`;
   }
 
+  private unwrapExpression(ctx: ExprContext): ExprContext {
+    if (ctx instanceof BracketsContext) {
+      return this.unwrapExpression(ctx.expr());
+    }
+
+    if (
+      ctx instanceof LeftWhitespaceOrCommentsContext ||
+      ctx instanceof RightWhitespaceOrCommentsContext
+    ) {
+      return this.unwrapExpression(ctx.expr());
+    }
+
+    return ctx;
+  }
+
   private isBlankLikeExpression(ctx: ExprContext): boolean {
-    if (ctx instanceof StringLiteralContext) {
-      const raw = ctx.text;
+    const normalizedCtx = this.unwrapExpression(ctx);
+
+    if (normalizedCtx instanceof StringLiteralContext) {
+      const raw = normalizedCtx.text;
       if (raw.startsWith("'") && raw.endsWith("'")) {
         const unescaped = unescapeString(raw.slice(1, -1));
         return unescaped === '';
@@ -1631,8 +1648,8 @@ abstract class BaseSqlConversionVisitor<
       return false;
     }
 
-    if (ctx instanceof FunctionCallContext) {
-      const rawName = ctx.func_name().text.toUpperCase();
+    if (normalizedCtx instanceof FunctionCallContext) {
+      const rawName = normalizedCtx.func_name().text.toUpperCase();
       const fnName = normalizeFunctionNameAlias(rawName) as FunctionName;
       return fnName === FunctionName.Blank;
     }
diff --git a/apps/nestjs-backend/src/features/record/record.service.ts b/apps/nestjs-backend/src/features/record/record.service.ts
index deb96b682f..15d623b81f 100644
--- a/apps/nestjs-backend/src/features/record/record.service.ts
+++ b/apps/nestjs-backend/src/features/record/record.service.ts
@@ -2140,6 +2140,9 @@ export class RecordService {
               return false;
             }
             if (isSearchAllFields) {
+              if (field.cellValueType === CellValueType.DateTime) {
+                return false;
+              }
               if (field.cellValueType === CellValueType.Number && isNaN(Number(search[0]))) {
                 return false;
               }
diff --git a/apps/nestjs-backend/src/features/setting/open-api/admin-open-api.service.ts b/apps/nestjs-backend/src/features/setting/open-api/admin-open-api.service.ts
index 3a74d1f632..6c0f57752f 100644
--- a/apps/nestjs-backend/src/features/setting/open-api/admin-open-api.service.ts
+++ b/apps/nestjs-backend/src/features/setting/open-api/admin-open-api.service.ts
@@ -1,3 +1,4 @@
+/* eslint-disable sonarjs/no-duplicate-string */
 import { Session } from 'node:inspector';
 import { Readable } from 'node:stream';
 import {
@@ -41,11 +42,11 @@ export class AdminOpenApiService {
   }
 
   async repairTableAttachmentThumbnail() {
-    // once handle 1000 attachments
     const take = 1000;
     let total = 0;
-    for (let skip = 0; ; skip += take) {
-      const sqlNative = this.knex('attachments_table')
+    let lastToken: string | null = null;
+    for (;;) {
+      const query = this.knex('attachments_table')
         .select(
           'attachments.token',
           'attachments.height',
@@ -53,13 +54,29 @@ export class AdminOpenApiService {
           'attachments.path'
         )
         .leftJoin('attachments', 'attachments_table.token', 'attachments.token')
-        .whereNotNull('attachments.height')
+        .where((qb) =>
+          qb
+            .where((image) =>
+              image
+                .where('attachments.mimetype', 'like', 'image/%')
+                .whereNotNull('attachments.height')
+            )
+            .orWhereIn('attachments.mimetype', ['application/pdf', 'application/x-pdf'])
+        )
         .whereNull('attachments.deleted_time')
         .whereNull('attachments.thumbnail_path')
-        .limit(take)
-        .offset(skip)
-        .toSQL()
-        .toNative();
+        .groupBy(
+          'attachments.token',
+          'attachments.height',
+          'attachments.mimetype',
+          'attachments.path'
+        )
+        .orderBy('attachments.token')
+        .limit(take);
+      if (lastToken) {
+        query.where('attachments.token', '>', lastToken);
+      }
+      const sqlNative = query.toSQL().toNative();
       const attachments = await this.prismaService.$queryRawUnsafe<
         { token: string; height?: number; mimetype: string; path: string }[]
       >(sqlNative.sql, ...sqlNative.bindings);
@@ -67,6 +84,7 @@ export class AdminOpenApiService {
       if (attachments.length === 0) {
         break;
       }
+      lastToken = attachments[attachments.length - 1].token;
       total += attachments.length;
       await this.attachmentsCropQueueProcessor.queue.addBulk(
         attachments.map((attachment) => ({
diff --git a/apps/nestjs-backend/src/features/setting/open-api/setting-open-api.service.spec.ts b/apps/nestjs-backend/src/features/setting/open-api/setting-open-api.service.spec.ts
new file mode 100644
index 0000000000..75085ce3d7
--- /dev/null
+++ b/apps/nestjs-backend/src/features/setting/open-api/setting-open-api.service.spec.ts
@@ -0,0 +1,180 @@
+import { LLMProviderType } from '@teable/openapi';
+import { generateImage as aiGenerateImage } from 'ai';
+import axios from 'axios';
+import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { SettingOpenApiService } from './setting-open-api.service';
+
+vi.mock('ai', () => ({
+  createGateway: vi.fn(),
+  generateImage: vi.fn(),
+  generateText: vi.fn(),
+  tool: vi.fn((config) => config),
+}));
+
+const providerName = 'custom-openai';
+const apiKey = 'sk-test';
+const openAIBaseUrl = 'https://api.openai.com/v1';
+const gptImage2Model = 'gpt-image-2';
+const gptImage2ModelKey = `${LLMProviderType.OPENAI}@${gptImage2Model}@${providerName}`;
+const testImageBuffer = Buffer.from([1, 2, 3]);
+
+describe('SettingOpenApiService', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+    delete process.env.BUILD_VERSION;
+    delete process.env.NEXT_PUBLIC_BUILD_VERSION;
+    delete process.env.APP_VERSION;
+    vi.restoreAllMocks();
+  });
+
+  afterAll(() => {
+    process.env = originalEnv;
+  });
+
+  const createService = () =>
+    new SettingOpenApiService(
+      undefined as never,
+      undefined as never,
+      { provider: 'local' } as never,
+      undefined as never,
+      undefined as never,
+      undefined as never,
+      undefined as never
+    );
+
+  it('sends runtime build version to public access checker', async () => {
+    process.env.BUILD_VERSION = '20260429.1';
+    process.env.NEXT_PUBLIC_BUILD_VERSION = 'legacy-build';
+    const getSpy = vi.spyOn(axios, 'get').mockResolvedValue({
+      data: {
+        success: true,
+        statusCode: 200,
+        latencyMs: 10,
+        checkedFrom: 'test',
+      },
+    });
+
+    await (
+      createService() as unknown as {
+        checkUrlAccessible: (
+          url: string,
+          setting: { instanceId?: string; createdTime?: string }
+        ) => Promise<unknown>;
+      }
+    ).checkUrlAccessible('https://teable.ai/health', {
+      instanceId: 'ins_123',
+      createdTime: '2026-04-29T00:00:00.000Z',
+    });
+
+    expect(getSpy).toHaveBeenCalledWith(
+      'https://access-checker.teable.ai/check',
+      expect.objectContaining({
+        params: {
+          url: 'https://teable.ai/health',
+          instanceId: 'ins_123',
+          version: '20260429.1',
+          deployedAt: '2026-04-29T00:00:00.000Z',
+        },
+      })
+    );
+  });
+});
+
+describe('SettingOpenApiService.testLLM image generation', () => {
+  const service = Object.create(SettingOpenApiService.prototype) as SettingOpenApiService;
+  let getTestFileBufferMock: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    getTestFileBufferMock = vi.fn().mockResolvedValue(testImageBuffer);
+    (
+      service as unknown as {
+        getTestFileBuffer: typeof getTestFileBufferMock;
+      }
+    ).getTestFileBuffer = getTestFileBufferMock;
+    vi.mocked(aiGenerateImage).mockResolvedValue({
+      image: { mediaType: 'image/png', uint8Array: new Uint8Array([1]) },
+      images: [{ mediaType: 'image/png', uint8Array: new Uint8Array([1]) }],
+      warnings: [],
+      responses: [],
+      providerMetadata: {},
+      usage: {
+        inputTokens: 1,
+        outputTokens: 1,
+        totalTokens: 2,
+      },
+    } as never);
+  });
+
+  it('uses the catalog default size when testing GPT image text-to-image generation', async () => {
+    const result = await service.testLLM({
+      type: LLMProviderType.OPENAI,
+      name: providerName,
+      apiKey,
+      baseUrl: openAIBaseUrl,
+      models: gptImage2Model,
+      modelKey: gptImage2ModelKey,
+      testImageGeneration: true,
+    });
+
+    expect(result.success).toBe(true);
+    expect(aiGenerateImage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        prompt: 'A simple test: draw a small red circle',
+        n: 1,
+        size: '1024x1024',
+      })
+    );
+  });
+
+  it('infers image generation testing from catalog when testImageGeneration is omitted', async () => {
+    const result = await service.testLLM({
+      type: LLMProviderType.OPENAI,
+      name: providerName,
+      apiKey,
+      baseUrl: openAIBaseUrl,
+      models: gptImage2Model,
+      modelKey: gptImage2ModelKey,
+    });
+
+    expect(result.success).toBe(true);
+    expect(aiGenerateImage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        prompt: 'A simple test: draw a small red circle',
+        n: 1,
+        size: '1024x1024',
+      })
+    );
+  });
+
+  it('uses prompt images when testing GPT image image-to-image generation', async () => {
+    const result = await service.testLLM({
+      type: LLMProviderType.OPENAI,
+      name: providerName,
+      apiKey,
+      baseUrl: openAIBaseUrl,
+      models: gptImage2Model,
+      modelKey: gptImage2ModelKey,
+      testImageGeneration: true,
+      testImageToImage: true,
+    });
+
+    expect(result.success).toBe(true);
+    expect(aiGenerateImage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        prompt: {
+          text: 'Create a very simple variation of this image.',
+          images: [testImageBuffer],
+        },
+        n: 1,
+        size: '1024x1024',
+      })
+    );
+    expect(getTestFileBufferMock).toHaveBeenCalledWith('static/test/test-image.png');
+    expect(vi.mocked(aiGenerateImage).mock.calls[0][0]).not.toHaveProperty(
+      'providerOptions.openai.image'
+    );
+  });
+});
diff --git a/apps/nestjs-backend/src/features/setting/open-api/setting-open-api.service.ts b/apps/nestjs-backend/src/features/setting/open-api/setting-open-api.service.ts
index 31f79eae45..229480ac78 100644
--- a/apps/nestjs-backend/src/features/setting/open-api/setting-open-api.service.ts
+++ b/apps/nestjs-backend/src/features/setting/open-api/setting-open-api.service.ts
@@ -24,9 +24,17 @@ import type {
   GatewayModelType,
   GatewayModelTag,
   GatewayModelProvider,
+  IImageSize,
 } from '@teable/openapi';
-import { chatModelAbilityType, UploadType, LLMProviderType, SettingKey } from '@teable/openapi';
-import { createGateway, generateText, tool, experimental_generateImage } from 'ai';
+import {
+  chatModelAbilityType,
+  getImageModelConfig,
+  getImageModelConfigByGatewayId,
+  UploadType,
+  LLMProviderType,
+  SettingKey,
+} from '@teable/openapi';
+import { createGateway, generateText, tool, generateImage } from 'ai';
 import type { LanguageModel, TextPart, FilePart } from 'ai';
 import axios from 'axios';
 import { uniq } from 'lodash';
@@ -36,13 +44,14 @@ import { BaseConfig, IBaseConfig } from '../../../configs/base.config';
 import { type IStorageConfig, StorageConfig } from '../../../configs/storage';
 import { CustomHttpException } from '../../../custom.exception';
 import type { IClsStore } from '../../../types/cls';
+import { resolveBuildVersion } from '../../../utils/build-version';
 import { INSTANCE_PROVIDER_NAME } from '../../ai/ai.service';
 import { getAdaptedProviderOptions, modelProviders } from '../../ai/util';
 import { AttachmentsStorageService } from '../../attachments/attachments-storage.service';
 import StorageAdapter from '../../attachments/plugins/adapter';
 import { InjectStorageAdapter } from '../../attachments/plugins/storage';
 import { getPublicFullStorageUrl } from '../../attachments/plugins/utils';
-import { EMAIL_LOGO_TOKEN } from '../../builtin-assets-init/builtin-assets-init.service';
+import { EMAIL_LOGO_TOKEN } from '../../builtin-assets-init';
 import { verifyTransport } from '../../mail-sender/mail-helpers';
 import { SettingService } from '../setting.service';
 
@@ -324,20 +333,29 @@ export class SettingOpenApiService {
   }
 
   /**
-   * Get base64 data URL for a test file
+   * Get test file buffer
    */
-  private async getTestFileBase64(filePath: string, contentType: string): Promise<string | null> {
+  private async getTestFileBuffer(filePath: string): Promise<Buffer | null> {
     try {
       const fullPath = resolve(process.cwd(), filePath);
-      const fileBuffer = await readFile(fullPath);
-      const base64 = fileBuffer.toString('base64');
-      return `data:${contentType};base64,${base64}`;
+      return await readFile(fullPath);
     } catch (error) {
-      this.logger.error(`Failed to read file for base64 ${filePath}: ${error}`);
+      this.logger.error(`Failed to read test file ${filePath}: ${error}`);
       return null;
     }
   }
 
+  /**
+   * Get base64 data URL for a test file
+   */
+  private async getTestFileBase64(filePath: string, contentType: string): Promise<string | null> {
+    const fileBuffer = await this.getTestFileBuffer(filePath);
+    if (!fileBuffer) return null;
+
+    const base64 = fileBuffer.toString('base64');
+    return `data:${contentType};base64,${base64}`;
+  }
+
   /**
    * Test image or PDF support with both URL and base64 forms in parallel
    * Returns detailed support info: { url: boolean, base64: boolean }
@@ -504,7 +522,7 @@ export class SettingOpenApiService {
 
         // Handle image generation model testing
         if (testImageGeneration) {
-          // Gemini image models via Gateway use generateText, not experimental_generateImage
+          // Gemini image models via Gateway use generateText, not generateImage
           throw new CustomHttpException(
             'Image generation testing not supported for AI Gateway models yet',
             HttpErrorCode.VALIDATION_ERROR
@@ -527,6 +545,11 @@ export class SettingOpenApiService {
         };
       }
 
+      const shouldTestImageGeneration = this.shouldTestImageGenerationModel(
+        type,
+        model,
+        testImageGeneration
+      );
       const provider = modelProviders[type as keyof typeof modelProviders];
       const providerOptions = getAdaptedProviderOptions(type, {
         name: model,
@@ -538,7 +561,7 @@ export class SettingOpenApiService {
       } as never) as OpenAIProvider;
 
       // Handle image generation model testing
-      if (testImageGeneration) {
+      if (shouldTestImageGeneration) {
         return await this.testImageGenerationModel(modelProvider, model, type, testImageToImage);
       }
 
@@ -570,6 +593,20 @@ export class SettingOpenApiService {
     }
   }
 
+  private shouldTestImageGenerationModel(
+    providerType: LLMProviderType,
+    model: string,
+    testImageGeneration?: boolean
+  ): boolean {
+    if (testImageGeneration != null) return testImageGeneration;
+
+    const config =
+      providerType === LLMProviderType.AI_GATEWAY
+        ? getImageModelConfigByGatewayId(model)
+        : getImageModelConfig(providerType, model);
+    return config?.modelType === 'image';
+  }
+
   private async testImageGenerationModel(
     modelProvider: OpenAIProvider,
     model: string,
@@ -582,33 +619,38 @@ export class SettingOpenApiService {
         return await this.testGoogleImageGeneration(modelProvider, model, testImageToImage);
       }
 
-      // OpenAI-style image generation (DALL-E, etc.)
-
+      // OpenAI-style image generation (DALL-E, GPT Image, etc.)
       const imageModel = modelProvider.image(model);
+      const size = this.getImageGenerationTestSize(providerType, model);
+      const sizeOptions = size ? { size } : {};
 
       if (testImageToImage) {
+        const testImageBuffer = await this.getTestFileBuffer(testImagePath);
+        if (!testImageBuffer) {
+          return {
+            success: false,
+            response: 'Test image file not found',
+          };
+        }
+
         // Test image-to-image: provide an image as input
         // Note: Not all image models support this, so we catch errors gracefully
-        const testImageUrl =
-          'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==';
-        await experimental_generateImage({
+        await generateImage({
           model: imageModel,
-          prompt: 'A simple test image',
-          n: 1,
-          size: '256x256',
-          providerOptions: {
-            openai: {
-              image: testImageUrl,
-            },
+          prompt: {
+            text: 'Create a very simple variation of this image.',
+            images: [testImageBuffer],
           },
+          n: 1,
+          ...sizeOptions,
         });
       } else {
         // Test basic text-to-image generation
-        await experimental_generateImage({
+        await generateImage({
           model: imageModel,
           prompt: 'A simple test: draw a small red circle',
           n: 1,
-          size: '256x256',
+          ...sizeOptions,
         });
       }
 
@@ -619,6 +661,7 @@ export class SettingOpenApiService {
           : 'Image generation successful',
       };
     } catch (error) {
+      this.logger.error('testImageGenerationModel Error', (error as Error)?.stack);
       const message = error instanceof Error ? error.message : 'Image generation failed';
       return {
         success: false,
@@ -627,6 +670,15 @@ export class SettingOpenApiService {
     }
   }
 
+  private getImageGenerationTestSize(
+    providerType: LLMProviderType,
+    model: string
+  ): IImageSize | undefined {
+    const config = getImageModelConfig(providerType, model);
+    if (!config || config.modelType !== 'image') return undefined;
+    return config.defaultSize ?? config.supportedSizes?.[0];
+  }
+
   /**
    * Test Google Gemini native image generation models
    * These models use generateText with responseModalities: ['TEXT', 'IMAGE']
@@ -949,7 +1001,7 @@ export class SettingOpenApiService {
       params: {
         url,
         instanceId: setting.instanceId || '',
-        version: process.env.NEXT_PUBLIC_BUILD_VERSION || '',
+        version: resolveBuildVersion(),
         deployedAt,
       },
       headers: {
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 c0b9a799fc..9233684794 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
@@ -199,13 +199,15 @@ export class TableOpenApiService {
       const tableVo = await this.createTableMeta(baseId, tableRo);
       const tableId = tableVo.id;
 
-      const preparedFields = await this.prepareFields(tableId, tableRo.fields);
-
-      // set the first field to be the primary field if not set
-      if (!preparedFields.find((field) => field.isPrimary)) {
-        preparedFields[0].isPrimary = true;
+      // Mark the first field as primary BEFORE prepareFields so the validation in
+      // prepareCreateFields catches bad-type / lookup-ish primaries from internal callers
+      // (template/import/AI) that don't go through the prepareCreateTableRo pipe.
+      if (tableRo.fields.length && !tableRo.fields.find((field) => (field as IFieldVo).isPrimary)) {
+        (tableRo.fields[0] as IFieldVo).isPrimary = true;
       }
 
+      const preparedFields = await this.prepareFields(tableId, tableRo.fields);
+
       // create teable should not set computed field isPending, because noting need to calculate when create
       preparedFields.forEach((field) => delete field.isPending);
       await this.createFields(tableId, preparedFields);
diff --git a/apps/nestjs-backend/src/features/table/table-index.service.ts b/apps/nestjs-backend/src/features/table/table-index.service.ts
index 2c4a79e1b2..fe7f4bcdd7 100644
--- a/apps/nestjs-backend/src/features/table/table-index.service.ts
+++ b/apps/nestjs-backend/src/features/table/table-index.service.ts
@@ -1,6 +1,6 @@
 /* eslint-disable sonarjs/no-duplicate-string */
-import { BadRequestException, Injectable, Logger } from '@nestjs/common';
-import { CellValueType, FieldType, HttpErrorCode } from '@teable/core';
+import { Injectable, Logger } from '@nestjs/common';
+import { FieldType, HttpErrorCode } from '@teable/core';
 import { PrismaService } from '@teable/db-main-prisma';
 import { TableIndex } from '@teable/openapi';
 import type { IGetAbnormalVo, ITableIndexType, IToggleIndexRo } from '@teable/openapi';
@@ -15,8 +15,6 @@ import type { IClsStore } from '../../types/cls';
 import type { IFieldInstance } from '../field/model/factory';
 import { createFieldInstanceByRaw } from '../field/model/factory';
 
-const unSupportTableIndex = 'Unsupport table index type';
-
 @Injectable()
 export class TableIndexService {
   private logger = new Logger(TableIndexService.name);
@@ -175,10 +173,7 @@ export class TableIndexService {
   }
 
   async createSearchFieldSingleIndex(tableId: string, fieldInstance: IFieldInstance) {
-    if (
-      fieldInstance.cellValueType === CellValueType.DateTime ||
-      fieldInstance.type === FieldType.Button
-    ) {
+    if (fieldInstance.type === FieldType.Button) {
       return;
     }
     const tableRaw = await this.prismaService.txClient().tableMeta.findFirstOrThrow({
diff --git a/apps/nestjs-backend/src/features/trash/trash.service.ts b/apps/nestjs-backend/src/features/trash/trash.service.ts
index 323bbc4613..ab456e179b 100644
--- a/apps/nestjs-backend/src/features/trash/trash.service.ts
+++ b/apps/nestjs-backend/src/features/trash/trash.service.ts
@@ -686,14 +686,14 @@ export class TrashService {
 
     const base = await this.prismaService.txClient().base.findUnique({
       where: { id: baseId, deletedTime: null },
-      select: { spaceId: true },
+      select: { spaceId: true, v2Enabled: true },
     });
 
     if (!base?.spaceId) {
       return { useV2: false, reason: 'disabled', baseId, tableId: trash.resourceId };
     }
 
-    const decision = await this.canaryService.shouldUseV2WithReason(base.spaceId, 'restoreTable');
+    const decision = await this.canaryService.shouldUseV2ForBaseWithReason(base, 'restoreTable');
     return {
       ...decision,
       baseId,
diff --git a/apps/nestjs-backend/src/features/v2/v2-base-node-compat.service.ts b/apps/nestjs-backend/src/features/v2/v2-base-node-compat.service.ts
index 6f496a594f..2828bc815f 100644
--- a/apps/nestjs-backend/src/features/v2/v2-base-node-compat.service.ts
+++ b/apps/nestjs-backend/src/features/v2/v2-base-node-compat.service.ts
@@ -13,9 +13,11 @@ import {
   type Result,
 } from '@teable/v2-core';
 import type { DependencyContainer } from '@teable/v2-di';
+import { ClsService } from 'nestjs-cls';
 import { PerformanceCacheService } from '../../performance-cache';
 import { generateBaseNodeListCacheKey } from '../../performance-cache/generate-keys';
 import { ShareDbService } from '../../share-db/share-db.service';
+import type { IClsStore } from '../../types/cls';
 import { presenceHandler } from '../base-node/helper';
 import { V2ProjectionRegistrar, type IV2ProjectionRegistrar } from './v2-projection-registrar';
 
@@ -28,13 +30,18 @@ export class V2TableBaseNodeProjection
 {
   constructor(
     private readonly performanceCacheService: PerformanceCacheService,
-    private readonly shareDbService: ShareDbService
+    private readonly shareDbService: ShareDbService,
+    private readonly cls: ClsService<IClsStore & { ignoreBaseNodeListener?: boolean }>
   ) {}
 
   async handle(
     _context: IExecutionContext,
     event: TableCreated | TableTrashed | TableDeleted | TableRestored
   ): Promise<Result<void, DomainError>> {
+    const ignoreBaseNodeListener = this.cls.get('ignoreBaseNodeListener');
+    if (ignoreBaseNodeListener) {
+      return ok(undefined);
+    }
     const baseId = event.baseId.toString();
     this.performanceCacheService.del(generateBaseNodeListCacheKey(baseId));
 
@@ -59,7 +66,8 @@ export class V2BaseNodeCompatService implements IV2ProjectionRegistrar {
 
   constructor(
     private readonly performanceCacheService: PerformanceCacheService,
-    private readonly shareDbService: ShareDbService
+    private readonly shareDbService: ShareDbService,
+    private readonly cls: ClsService<IClsStore & { ignoreBaseNodeListener?: boolean }>
   ) {}
 
   registerProjections(container: DependencyContainer): void {
@@ -67,7 +75,7 @@ export class V2BaseNodeCompatService implements IV2ProjectionRegistrar {
 
     container.registerInstance(
       V2TableBaseNodeProjection,
-      new V2TableBaseNodeProjection(this.performanceCacheService, this.shareDbService)
+      new V2TableBaseNodeProjection(this.performanceCacheService, this.shareDbService, this.cls)
     );
   }
 }
diff --git a/apps/nestjs-backend/src/features/view/open-api/view-open-api.service.ts b/apps/nestjs-backend/src/features/view/open-api/view-open-api.service.ts
index b7feaf5f49..c6dd4f8ee6 100644
--- a/apps/nestjs-backend/src/features/view/open-api/view-open-api.service.ts
+++ b/apps/nestjs-backend/src/features/view/open-api/view-open-api.service.ts
@@ -12,6 +12,7 @@ import type {
   ILinkFieldOptions,
   IPluginViewOptions,
   IViewPropertyKeys,
+  CellValueType,
   ISort,
   IGroup,
   TableDomain,
@@ -28,7 +29,7 @@ import {
   generatePluginInstallId,
   generateOperationId,
   extractFieldIdsFromFilter,
-  validateFilterOperatorModeCompatibility,
+  analyzeFilterValidationIssues,
   HttpErrorCode,
 } from '@teable/core';
 import { PrismaService } from '@teable/db-main-prisma';
@@ -289,7 +290,7 @@ export class ViewOpenApiService {
     if (fieldIds.length > 0) {
       const fields = await this.prismaService.field.findMany({
         where: { tableId, id: { in: fieldIds } },
-        select: { id: true, type: true },
+        select: { id: true, type: true, cellValueType: true, isMultipleCellValue: true },
       });
 
       // Check for unsupported Button type fields
@@ -306,15 +307,26 @@ export class ViewOpenApiService {
         );
       }
 
-      // Validate operator + mode compatibility for date fields
-      const fieldTypeMap = fields.reduce(
+      // Validate filter compatibility with the same shared analyzer used by SDK/query execution.
+      const fieldMetaMap = fields.reduce(
         (acc, f) => {
-          acc[f.id] = f.type as FieldType;
+          acc[f.id] = {
+            type: f.type as FieldType,
+            cellValueType: f.cellValueType as CellValueType,
+            isMultipleCellValue: Boolean(f.isMultipleCellValue),
+          };
           return acc;
         },
-        {} as Record<string, FieldType>
+        {} as Record<
+          string,
+          {
+            type: FieldType;
+            cellValueType: CellValueType;
+            isMultipleCellValue: boolean;
+          }
+        >
       );
-      const validationErrors = validateFilterOperatorModeCompatibility(filter, fieldTypeMap);
+      const validationErrors = analyzeFilterValidationIssues(filter, fieldMetaMap);
       if (validationErrors.length > 0) {
         throw new CustomHttpException(validationErrors[0].message, HttpErrorCode.VALIDATION_ERROR, {
           localization: {
diff --git a/apps/nestjs-backend/src/instrument.ts b/apps/nestjs-backend/src/instrument.ts
index 12b97fc61d..0d3fea43c3 100644
--- a/apps/nestjs-backend/src/instrument.ts
+++ b/apps/nestjs-backend/src/instrument.ts
@@ -1,5 +1,6 @@
 import { Logger } from '@nestjs/common';
 import * as Sentry from '@sentry/nestjs';
+import { resolveBuildVersion } from './utils/build-version';
 
 if (process.env.BACKEND_SENTRY_DSN) {
   const traceRate = Number(process.env.BACKEND_SENTRY_TRACE_SAMPLING_RATE ?? 0.1);
@@ -11,7 +12,7 @@ if (process.env.BACKEND_SENTRY_DSN) {
     _experiments: {
       enableMetrics: true,
     },
-    release: process.env.NEXT_PUBLIC_BUILD_VERSION || 'development',
+    release: resolveBuildVersion() || 'development',
     environment: process.env.NODE_ENV || 'development',
     defaultIntegrations: false,
     // Only keep error-related integrations, tracing is handled by OTEL
diff --git a/apps/nestjs-backend/src/share-db/share-db.adapter.ts b/apps/nestjs-backend/src/share-db/share-db.adapter.ts
index 1f66f51f57..3e2519a5cb 100644
--- a/apps/nestjs-backend/src/share-db/share-db.adapter.ts
+++ b/apps/nestjs-backend/src/share-db/share-db.adapter.ts
@@ -195,6 +195,21 @@ export class ShareDbAdapter extends ShareDb.DB {
     }, {});
   }
 
+  private snapshots2MapWithMissing(
+    ids: string[],
+    snapshotData: ISnapshotBase<unknown>[]
+  ): Record<string, Snapshot> {
+    const snapshotDataMap = new Map(snapshotData.map((snapshot) => [snapshot.id, snapshot]));
+    const snapshots = ids.map((id) => {
+      const snapshot = snapshotDataMap.get(id);
+      if (!snapshot) {
+        return new Snapshot(id, 0, null, undefined, null);
+      }
+      return new Snapshot(snapshot.id, snapshot.v, snapshot.type, snapshot.data, null);
+    });
+    return this.snapshots2Map(snapshots);
+  }
+
   // Get the named document from the database. The callback is called with (err,
   // snapshot). A snapshot with a version of zero is returned if the document
   // has never been created in the database.
@@ -216,16 +231,7 @@ export class ShareDbAdapter extends ShareDb.DB {
         // For internal (server-side) connections without auth, resolve field docs directly
         if (docType === IdPrefix.Field && this.fieldServiceInner) {
           const snapshotData = await this.fieldServiceInner.getSnapshotBulk(collectionId, ids);
-          if (snapshotData.length) {
-            const snapshots = snapshotData.map(
-              (snapshot) =>
-                new Snapshot(snapshot.id, snapshot.v, snapshot.type, snapshot.data, null)
-            );
-            callback(null, this.snapshots2Map(snapshots));
-          } else {
-            const snapshots = ids.map((id) => new Snapshot(id, 0, null, undefined, null));
-            callback(null, this.snapshots2Map(snapshots));
-          }
+          callback(null, this.snapshots2MapWithMissing(ids, snapshotData));
           return;
         }
         throw new UnauthorizedException('Unauthorized request not authorized');
@@ -243,22 +249,7 @@ export class ShareDbAdapter extends ShareDb.DB {
           );
         }
       );
-      if (snapshotData.length) {
-        const snapshots = snapshotData.map(
-          (snapshot) =>
-            new Snapshot(
-              snapshot.id,
-              snapshot.v,
-              snapshot.type,
-              snapshot.data,
-              null // TODO: metadata
-            )
-        );
-        callback(null, this.snapshots2Map(snapshots));
-      } else {
-        const snapshots = ids.map((id) => new Snapshot(id, 0, null, undefined, null));
-        callback(null, this.snapshots2Map(snapshots));
-      }
+      callback(null, this.snapshots2MapWithMissing(ids, snapshotData));
     } catch (err) {
       this.logger.error(err);
       callback(exceptionParse(err as Error));
diff --git a/apps/nestjs-backend/src/share-db/share-db.spec.ts b/apps/nestjs-backend/src/share-db/share-db.spec.ts
index 649cd2fb41..1820036315 100644
--- a/apps/nestjs-backend/src/share-db/share-db.spec.ts
+++ b/apps/nestjs-backend/src/share-db/share-db.spec.ts
@@ -1,6 +1,9 @@
 import type { TestingModule } from '@nestjs/testing';
 import { Test } from '@nestjs/testing';
+import { IdPrefix } from '@teable/core';
+import { vi } from 'vitest';
 import { GlobalModule } from '../global/global.module';
+import { ShareDbAdapter } from './share-db.adapter';
 import { ShareDbModule } from './share-db.module';
 import { ShareDbService } from './share-db.service';
 
@@ -19,6 +22,56 @@ describe('ShareDb', () => {
     expect(provider).toBeDefined();
   });
 
+  it('returns empty snapshots for stale query ids missing from snapshot bulk', async () => {
+    const cls = {
+      get: vi.fn(() => undefined),
+      runWith: vi.fn((_store, fn) => fn()),
+    };
+    const recordService = {
+      getSnapshotBulk: vi.fn().mockResolvedValue([
+        {
+          id: 'recExisting',
+          v: 2,
+          type: 'json0',
+          data: { id: 'recExisting', fields: {} },
+        },
+      ]),
+    };
+    const adapter = new ShareDbAdapter(
+      cls as never,
+      {} as never,
+      recordService as never,
+      {} as never,
+      {} as never,
+      {} as never
+    );
+
+    const snapshots = await new Promise<
+      Record<string, { v: number; type: string | null; data?: unknown }>
+    >((resolve, reject) => {
+      adapter.getSnapshotBulk(
+        `${IdPrefix.Record}_tblTest`,
+        ['recExisting', 'recDeleted'],
+        undefined,
+        { cookie: 'teable-session=test' },
+        (error, data) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve(data as Record<string, { v: number; type: string | null; data?: unknown }>);
+        }
+      );
+    });
+
+    expect(snapshots.recExisting.v).toBe(2);
+    expect(snapshots.recDeleted).toMatchObject({
+      v: 0,
+      type: null,
+      data: undefined,
+    });
+  });
+
   // it('create simple document', (done) => {
   //   const randomTitle = `B:${Math.floor(Math.random() * 1000)}`;
   //   const doc = provider.connect().get('books', randomTitle);
diff --git a/apps/nestjs-backend/src/types/cls.ts b/apps/nestjs-backend/src/types/cls.ts
index 788968b86e..40f6dfa245 100644
--- a/apps/nestjs-backend/src/types/cls.ts
+++ b/apps/nestjs-backend/src/types/cls.ts
@@ -10,8 +10,10 @@ import type { IDataLoaderCache } from './data-loader';
 export type V2Reason =
   | 'env_force_v2_all'
   | 'config_force_v2_all'
+  | 'new_base'
   | 'header_override'
   | 'space_feature'
+  | 'unsupported_feature'
   | 'disabled'
   | 'feature_not_enabled'
   | 'no_feature';
@@ -51,6 +53,7 @@ export interface IClsStore extends ClsStore {
     rawOpMaps?: IRawOpMap[];
   };
   shareViewId?: string;
+  baseShareId?: string;
   permissions: Action[];
   // this is used to check if the user is in the space when the user operate in a space
   spaceId?: string;
diff --git a/apps/nestjs-backend/src/types/i18n.generated.ts b/apps/nestjs-backend/src/types/i18n.generated.ts
index d990617ec4..fff4d1895b 100644
--- a/apps/nestjs-backend/src/types/i18n.generated.ts
+++ b/apps/nestjs-backend/src/types/i18n.generated.ts
@@ -358,6 +358,7 @@ export type I18nTranslations = {
         };
         "settings": {
             "title": string;
+            "allSetting": string;
             "personal": {
                 "title": string;
             };
@@ -1414,6 +1415,10 @@ export type I18nTranslations = {
                             "title": string;
                             "message": string;
                         };
+                        "failedSummary": {
+                            "title": string;
+                            "message": string;
+                        };
                     };
                     "billing": {
                         "title": string;
@@ -2087,6 +2092,7 @@ export type I18nTranslations = {
             };
             "invalidateSelected": string;
             "invalidateSelectedTips": string;
+            "invalidConditionTip": string;
             "default": {
                 "empty": string;
                 "placeholder": string;
@@ -2195,6 +2201,7 @@ export type I18nTranslations = {
             "showAll": string;
             "hideAll": string;
             "primaryKey": string;
+            "notInCurrentView": string;
         };
         "expandRecord": {
             "copy": string;
@@ -3060,6 +3067,7 @@ export type I18nTranslations = {
                 "whiteListCheckError": string;
                 "databaseConnectionFailed": string;
                 "executeQuerySqlFailed": string;
+                "sqlSyntaxError": string;
                 "readOnlyCheckFailed": string;
             };
             "permission": {
@@ -3163,6 +3171,8 @@ export type I18nTranslations = {
                     "clickCountReachedMaxCount": string;
                     "notSupportReset": string;
                 };
+                "primaryCannotBeLookup": string;
+                "primaryFieldAlreadyExists": string;
             };
             "view": {
                 "notFound": string;
@@ -3361,6 +3371,7 @@ export type I18nTranslations = {
                 "zipFileTooLarge": string;
                 "invalidZip": string;
                 "domainAlreadyInUse": string;
+                "domainReserved": string;
             };
             "reward": {
                 "notFound": string;
@@ -3384,6 +3395,7 @@ export type I18nTranslations = {
                 "linkedInAuthorNotFound": string;
                 "fetchLinkedInUserFailed": string;
                 "domainAlreadyInUse": string;
+                "domainReserved": string;
             };
         };
         "aiError": {
@@ -3982,6 +3994,7 @@ export type I18nTranslations = {
                     "sortMissingWarningTitle": string;
                     "sortMissingWarningDescription": string;
                 };
+                "fieldUnavailable": string;
                 "lastModifiedScope": string;
                 "lastModifiedAll": string;
                 "lastModifiedSpecific": string;
@@ -4432,6 +4445,7 @@ export type I18nTranslations = {
                             "foreignKeyOrphanRows": string;
                             "junctionForeignKeyTargetTableMissing": string;
                             "junctionForeignKeyOrphanRows": string;
+                            "autoRule": string;
                         };
                         "manual": {
                             "apply": string;
@@ -4450,10 +4464,25 @@ export type I18nTranslations = {
                     };
                     "manualRepairPreview": string;
                     "manualRepairPreviewTip": string;
+                    "repairPreviewTitle": string;
+                    "repairPreviewDescription": string;
+                    "repairPreviewTooltip": string;
+                    "repairPreviewMissingTable": string;
+                    "repairPreviewUnavailableStatus": string;
+                    "repairPreviewWhat": string;
+                    "repairPreviewTarget": string;
+                    "repairPreviewPrinciple": string;
+                    "repairPreviewNoPrinciple": string;
+                    "repairPreviewSql": string;
+                    "repairPreviewNoSql": string;
+                    "repairPreviewCannotConfirm": string;
+                    "repairPreviewParameters": string;
+                    "repairPreviewConfirm": string;
                 };
-                "type": string;
-                "message": string;
                 "errorType": {
+                    "InvalidPrimaryLookup": string;
+                    "InvalidPrimaryType": string;
+                    "MissingPrimary": string;
                     "ForeignTableNotFound": string;
                     "ForeignKeyNotFound": string;
                     "SelfKeyNotFound": string;
@@ -4466,6 +4495,8 @@ export type I18nTranslations = {
                     "EmptyString": string;
                     "InvalidFilterOperator": string;
                 };
+                "type": string;
+                "message": string;
             };
             "index": {
                 "description": string;
@@ -4854,6 +4885,7 @@ export type I18nTranslations = {
             "expand": string;
             "history": string;
             "close": string;
+            "noModel": string;
             "addAttachment": string;
             "noHistory": string;
             "noFoundHistory": string;
@@ -4871,7 +4903,14 @@ export type I18nTranslations = {
                 "emptyContext": string;
                 "selectionRows": string;
             };
+            "mention": {
+                "tables": string;
+                "apps": string;
+                "workflows": string;
+                "folders": string;
+            };
             "inputPlaceholder": string;
+            "inputPlaceholderFiles": string;
             "thought": string;
             "meta": {
                 "input": string;
@@ -4913,6 +4952,8 @@ export type I18nTranslations = {
             "clearChatConfirmTitle": string;
             "clearChatConfirmDesc": string;
             "dontShowAgain": string;
+            "modelSwitchTitle": string;
+            "modelSwitchHint": string;
             "sandboxExpiry": {
                 "expiresIn": string;
                 "reset": string;
@@ -4959,6 +5000,9 @@ export type I18nTranslations = {
             "retry": {
                 "interrupted": string;
                 "button": string;
+                "offline": string;
+                "pausedHidden": string;
+                "maxAttemptsReached": string;
             };
             "guide": {
                 "goToScenario": string;
@@ -4994,6 +5038,8 @@ export type I18nTranslations = {
                 "advancedOptions": string;
                 "namingFieldLabel": string;
                 "selectField": string;
+                "noPrefixOption": string;
+                "noPrefixOptionDesc": string;
                 "groupByRow": string;
                 "groupByRowTip": string;
             };
diff --git a/apps/nestjs-backend/src/utils/build-version.ts b/apps/nestjs-backend/src/utils/build-version.ts
new file mode 100644
index 0000000000..bed1651f7e
--- /dev/null
+++ b/apps/nestjs-backend/src/utils/build-version.ts
@@ -0,0 +1,11 @@
+const buildVersionEnvKeys = ['BUILD_VERSION', 'NEXT_PUBLIC_BUILD_VERSION', 'APP_VERSION'] as const;
+
+export const resolveBuildVersion = () => {
+  for (const key of buildVersionEnvKeys) {
+    const value = process.env[key]?.trim();
+    if (value) {
+      return value;
+    }
+  }
+  return '';
+};
diff --git a/apps/nestjs-backend/test/access-token.e2e-spec.ts b/apps/nestjs-backend/test/access-token.e2e-spec.ts
index 3f587c79e9..6a0c748300 100644
--- a/apps/nestjs-backend/test/access-token.e2e-spec.ts
+++ b/apps/nestjs-backend/test/access-token.e2e-spec.ts
@@ -1,5 +1,6 @@
 /* eslint-disable sonarjs/no-duplicate-string */
 import type { INestApplication } from '@nestjs/common';
+import type { Action } from '@teable/core';
 import { Role } from '@teable/core';
 import type {
   CreateAccessTokenRo,
@@ -97,6 +98,16 @@ describe('OpenAPI AccessTokenController (e2e)', () => {
     expect(error?.message).contain('expiredTime');
   });
 
+  it('create access token with invalid scopes', async () => {
+    const error = await getError(() =>
+      createAccessToken({
+        ...defaultCreateRo,
+        scopes: ['table|write', 'invalid_scope'] as unknown as CreateAccessTokenRo['scopes'],
+      })
+    );
+    expect(error?.status).toEqual(400);
+  });
+
   it('check access token', async () => {
     const accessToken = '1234567890';
     const res = splitAccessToken(accessToken);
diff --git a/apps/nestjs-backend/test/auth.e2e-spec.ts b/apps/nestjs-backend/test/auth.e2e-spec.ts
index 149c4044cc..34d46280bd 100644
--- a/apps/nestjs-backend/test/auth.e2e-spec.ts
+++ b/apps/nestjs-backend/test/auth.e2e-spec.ts
@@ -426,7 +426,7 @@ describe('Auth Controller (e2e)', () => {
     // token
     const tokenRes = await userAxios.post<CreateAccessTokenVo>(CREATE_ACCESS_TOKEN, {
       name: 'test-delete-user-token',
-      scopes: ['record:read'],
+      scopes: ['record|read'],
       expiredTime: new Date(Date.now() + 1000 * 60 * 60 * 24).toISOString(),
     });
     const accessTokenId = tokenRes.data.id;
diff --git a/apps/nestjs-backend/test/base-node.e2e-spec.ts b/apps/nestjs-backend/test/base-node.e2e-spec.ts
index 70c30673ab..90c4d0040c 100644
--- a/apps/nestjs-backend/test/base-node.e2e-spec.ts
+++ b/apps/nestjs-backend/test/base-node.e2e-spec.ts
@@ -39,7 +39,6 @@ const testFolder = 'Test Folder';
 const updatedName = 'Updated Name';
 const testTableName = 'Test Table';
 const windowIdHeader = 'x-window-id';
-const isForceV2 = process.env.FORCE_V2_ALL === 'true';
 
 describe('BaseNodeController (e2e) /api/base/:baseId/node', () => {
   let app: INestApplication;
@@ -185,9 +184,9 @@ describe('BaseNodeController (e2e) /api/base/:baseId/node', () => {
       );
 
       expect(response.status).toBe(201);
-      expect(response.headers['x-teable-v2']).toBe(isForceV2 ? 'true' : 'false');
+      expect(response.headers['x-teable-v2']).toBe('true');
       expect(response.headers['x-teable-v2-feature']).toBe('createTable');
-      expect(response.headers['x-teable-v2-reason']).toBeTruthy();
+      expect(response.headers['x-teable-v2-reason']).toBe('new_base');
 
       nodesToCleanup.push(response.data.id);
     });
@@ -384,9 +383,9 @@ describe('BaseNodeController (e2e) /api/base/:baseId/node', () => {
       );
 
       expect(response.status).toBe(201);
-      expect(response.headers['x-teable-v2']).toBe(isForceV2 ? 'true' : 'false');
+      expect(response.headers['x-teable-v2']).toBe('true');
       expect(response.headers['x-teable-v2-feature']).toBe('createTable');
-      expect(response.headers['x-teable-v2-reason']).toBeTruthy();
+      expect(response.headers['x-teable-v2-reason']).toBe('new_base');
 
       nodesToCleanup.push(response.data.id);
 
@@ -673,9 +672,9 @@ describe('BaseNodeController (e2e) /api/base/:baseId/node', () => {
       );
 
       expect(response.status).toBe(200);
-      expect(response.headers['x-teable-v2']).toBe(isForceV2 ? 'true' : 'false');
+      expect(response.headers['x-teable-v2']).toBe('true');
       expect(response.headers['x-teable-v2-feature']).toBe('deleteTable');
-      expect(response.headers['x-teable-v2-reason']).toBeTruthy();
+      expect(response.headers['x-teable-v2-reason']).toBe('new_base');
 
       const error = await getError(() => getBaseNode(baseId, table.data.id));
       expect(error?.status).toBeGreaterThanOrEqual(400);
@@ -1032,9 +1031,9 @@ describe('BaseNodeController (e2e) /api/base/:baseId/node', () => {
       );
 
       expect(response.status).toBe(201);
-      expect(response.headers['x-teable-v2']).toBe(isForceV2 ? 'true' : 'false');
+      expect(response.headers['x-teable-v2']).toBe('true');
       expect(response.headers['x-teable-v2-feature']).toBe('duplicateTable');
-      expect(response.headers['x-teable-v2-reason']).toBeTruthy();
+      expect(response.headers['x-teable-v2-reason']).toBe('new_base');
 
       nodesToCleanup.push(response.data.id);
       expect(response.data.resourceMeta?.name).toBe('Duplicated Table Via Node Route');
@@ -1410,6 +1409,101 @@ describe('BaseNodeController (e2e) /api/base/:baseId/node', () => {
       expect(response.data).toHaveProperty('maxFolderDepth');
       expect(response.data.maxFolderDepth).toBe(2);
     });
+
+    it('should fail when moving folder-with-subfolder into another root folder via parentId', async () => {
+      const folderA = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Folder,
+        name: 'Subtree Depth A',
+      });
+      nodesToCleanup.push(folderA.data.id);
+
+      const subfolderB = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Folder,
+        name: 'Subtree Depth B',
+        parentId: folderA.data.id,
+      });
+      nodesToCleanup.push(subfolderB.data.id);
+
+      const folderC = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Folder,
+        name: 'Subtree Depth C',
+      });
+      nodesToCleanup.push(folderC.data.id);
+
+      // Moving folderA (which contains subfolderB) into folderC
+      // Result would be: C(1) > A(2) > B(3) — depth 3 exceeds maxFolderDepth=2
+      const error = await getError(() =>
+        moveBaseNode(baseId, folderA.data.id, {
+          parentId: folderC.data.id,
+        })
+      );
+
+      expect(error?.status).toBe(400);
+    });
+
+    it('should fail when moving folder-with-subfolder via anchorId inside a folder', async () => {
+      const folderD = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Folder,
+        name: 'Subtree Anchor D',
+      });
+      nodesToCleanup.push(folderD.data.id);
+
+      const subfolderE = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Folder,
+        name: 'Subtree Anchor E',
+        parentId: folderD.data.id,
+      });
+      nodesToCleanup.push(subfolderE.data.id);
+
+      const folderF = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Folder,
+        name: 'Subtree Anchor F',
+      });
+      nodesToCleanup.push(folderF.data.id);
+
+      // Create a child inside folderF to use as anchor
+      const childInF = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Table,
+        name: 'Table in F',
+        parentId: folderF.data.id,
+        fields: [{ name: 'Field1', type: FieldType.SingleLineText }],
+        views: [{ name: 'Grid view', type: ViewType.Grid }],
+      });
+      nodesToCleanup.push(childInF.data.id);
+
+      // Moving folderD (with subfolderE) next to childInF (inside folderF)
+      // Result would be: F(1) > D(2) > E(3) — depth 3 exceeds maxFolderDepth=2
+      const error = await getError(() =>
+        moveBaseNode(baseId, folderD.data.id, {
+          anchorId: childInF.data.id,
+          position: 'after',
+        })
+      );
+
+      expect(error?.status).toBe(400);
+    });
+
+    it('should allow moving leaf folder into another root folder', async () => {
+      const targetFolder = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Folder,
+        name: 'Target Folder',
+      });
+      nodesToCleanup.push(targetFolder.data.id);
+
+      const leafFolder = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Folder,
+        name: 'Leaf Folder',
+      });
+      nodesToCleanup.push(leafFolder.data.id);
+
+      // Moving a leaf folder (no children) into targetFolder — depth=2, within limit
+      const response = await moveBaseNode(baseId, leafFolder.data.id, {
+        parentId: targetFolder.data.id,
+      });
+
+      expect(response.data.id).toBe(leafFolder.data.id);
+      expect(response.data.parentId).toBe(targetFolder.data.id);
+    });
   });
 
   describe('Permission tests', () => {
@@ -1907,4 +2001,170 @@ describe('BaseNodeController (e2e) /api/base/:baseId/node', () => {
       });
     });
   });
+
+  describe('Resource ID resolution (using resourceId instead of nodeId)', () => {
+    const nodesToCleanup: string[] = [];
+
+    afterEach(async () => {
+      for (const nodeId of [...nodesToCleanup].reverse()) {
+        await deleteBaseNode(baseId, nodeId);
+      }
+      nodesToCleanup.length = 0;
+    });
+
+    it('should get node by resourceId (tableId)', async () => {
+      const node = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Table,
+        name: 'Resolve Get Test',
+        fields: [{ name: 'Field1', type: FieldType.SingleLineText }],
+        views: [{ name: 'Grid view', type: ViewType.Grid }],
+      });
+      nodesToCleanup.push(node.data.id);
+
+      const response = await getBaseNode(baseId, node.data.resourceId);
+
+      expect(response.data.id).toBe(node.data.id);
+      expect(response.data.resourceId).toBe(node.data.resourceId);
+      expect(response.data.resourceMeta?.name).toBe('Resolve Get Test');
+    });
+
+    it('should update node by resourceId', async () => {
+      const node = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Table,
+        name: 'Resolve Update Test',
+        fields: [{ name: 'Field1', type: FieldType.SingleLineText }],
+        views: [{ name: 'Grid view', type: ViewType.Grid }],
+      });
+      nodesToCleanup.push(node.data.id);
+
+      const response = await updateBaseNode(baseId, node.data.resourceId, {
+        name: 'Resolve Updated',
+      });
+
+      expect(response.data.id).toBe(node.data.id);
+      expect(response.data.resourceMeta?.name).toBe('Resolve Updated');
+    });
+
+    it('should duplicate node by resourceId', async () => {
+      const node = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Table,
+        name: 'Resolve Duplicate Test',
+        fields: [{ name: 'Field1', type: FieldType.SingleLineText }],
+        views: [{ name: 'Grid view', type: ViewType.Grid }],
+      });
+      nodesToCleanup.push(node.data.id);
+
+      const duplicate = await duplicateBaseNode(baseId, node.data.resourceId, {
+        name: 'Resolve Duplicated',
+      });
+      nodesToCleanup.push(duplicate.data.id);
+
+      expect(duplicate.data.id).not.toBe(node.data.id);
+      expect(duplicate.data.resourceMeta?.name).toBe('Resolve Duplicated');
+    });
+
+    it('should move node by resourceId', async () => {
+      const folder = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Folder,
+        name: 'Resolve Move Folder',
+      });
+      nodesToCleanup.push(folder.data.id);
+
+      const node = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Table,
+        name: 'Resolve Move Test',
+        fields: [{ name: 'Field1', type: FieldType.SingleLineText }],
+        views: [{ name: 'Grid view', type: ViewType.Grid }],
+      });
+      nodesToCleanup.push(node.data.id);
+
+      const response = await moveBaseNode(baseId, node.data.resourceId, {
+        parentId: folder.data.id,
+      });
+
+      expect(response.data.id).toBe(node.data.id);
+      expect(response.data.parentId).toBe(folder.data.id);
+    });
+
+    it('should delete node by resourceId', async () => {
+      const node = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Table,
+        name: 'Resolve Delete Test',
+        fields: [{ name: 'Field1', type: FieldType.SingleLineText }],
+        views: [{ name: 'Grid view', type: ViewType.Grid }],
+      });
+
+      await deleteBaseNode(baseId, node.data.resourceId);
+
+      const error = await getError(() => getBaseNode(baseId, node.data.id));
+      expect(error?.status).toBeGreaterThanOrEqual(400);
+    });
+
+    it('should move node with resourceId as parentId', async () => {
+      const folder = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Folder,
+        name: 'Resolve Parent Folder',
+      });
+      nodesToCleanup.push(folder.data.id);
+
+      const node = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Table,
+        name: 'Resolve Parent Move Test',
+        fields: [{ name: 'Field1', type: FieldType.SingleLineText }],
+        views: [{ name: 'Grid view', type: ViewType.Grid }],
+      });
+      nodesToCleanup.push(node.data.id);
+
+      const response = await moveBaseNode(baseId, node.data.id, {
+        parentId: folder.data.resourceId,
+      });
+
+      expect(response.data.id).toBe(node.data.id);
+      expect(response.data.parentId).toBe(folder.data.id);
+    });
+
+    it('should create node with resourceId as parentId', async () => {
+      const folder = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Folder,
+        name: 'Resolve Create Parent Folder',
+      });
+      nodesToCleanup.push(folder.data.id);
+
+      const node = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Table,
+        name: 'Resolve Create In Folder Test',
+        parentId: folder.data.resourceId,
+        fields: [{ name: 'Field1', type: FieldType.SingleLineText }],
+        views: [{ name: 'Grid view', type: ViewType.Grid }],
+      });
+      nodesToCleanup.push(node.data.id);
+
+      expect(node.data.parentId).toBe(folder.data.id);
+    });
+
+    it('should move node with resourceId as anchorId', async () => {
+      const anchor = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Table,
+        name: 'Anchor Table',
+        fields: [{ name: 'Field1', type: FieldType.SingleLineText }],
+        views: [{ name: 'Grid view', type: ViewType.Grid }],
+      });
+      nodesToCleanup.push(anchor.data.id);
+
+      const node = await createBaseNode(baseId, {
+        resourceType: BaseNodeResourceType.Table,
+        name: 'Movable Table',
+        fields: [{ name: 'Field1', type: FieldType.SingleLineText }],
+        views: [{ name: 'Grid view', type: ViewType.Grid }],
+      });
+      nodesToCleanup.push(node.data.id);
+
+      const response = await moveBaseNode(baseId, node.data.id, {
+        anchorId: anchor.data.resourceId,
+        position: 'before',
+      });
+
+      expect(response.data.id).toBe(node.data.id);
+    });
+  });
 });
diff --git a/apps/nestjs-backend/test/computed-orchestrator.e2e-spec.ts b/apps/nestjs-backend/test/computed-orchestrator.e2e-spec.ts
index 422a6081f0..efdad47b33 100644
--- a/apps/nestjs-backend/test/computed-orchestrator.e2e-spec.ts
+++ b/apps/nestjs-backend/test/computed-orchestrator.e2e-spec.ts
@@ -56,6 +56,7 @@ dayjs.extend(utc);
 dayjs.extend(timezone);
 
 const isForceV2 = process.env.FORCE_V2_ALL === 'true';
+let isV2Mode = isForceV2;
 
 describe('Computed Orchestrator (e2e)', () => {
   let app: INestApplication;
@@ -78,6 +79,11 @@ describe('Computed Orchestrator (e2e)', () => {
     tableDomainQueryService = app.get(TableDomainQueryService);
     recordDialect = app.get<IRecordQueryDialectProvider>(RECORD_QUERY_DIALECT_SYMBOL as any);
     v2ContainerService = app.get(V2ContainerService);
+    const base = await prisma.base.findUnique({
+      where: { id: baseId },
+      select: { v2Enabled: true },
+    });
+    isV2Mode = isForceV2 || Boolean(base?.v2Enabled);
   });
 
   afterAll(async () => {
@@ -89,7 +95,7 @@ describe('Computed Orchestrator (e2e)', () => {
    * This ensures all async computed updates are completed before assertions.
    */
   async function processV2Outbox(times = 1): Promise<void> {
-    if (!isForceV2) return;
+    if (!isV2Mode) return;
 
     const container = await v2ContainerService.getContainer();
     const drainService = container.resolve<IComputedUpdateDrainService>(
@@ -132,7 +138,7 @@ describe('Computed Orchestrator (e2e)', () => {
     _count: number = 1
   ) {
     return async function fn<T>(fn: () => Promise<T>) {
-      if (isForceV2) {
+      if (isV2Mode) {
         // In v2 mode, execute and process outbox to ensure async updates complete
         const result = await fn();
         await processV2Outbox();
@@ -143,11 +149,17 @@ describe('Computed Orchestrator (e2e)', () => {
     };
   }
 
-  async function runAndCaptureRecordUpdates<T>(fn: () => Promise<T>): Promise<{
+  async function runAndCaptureRecordUpdates<T>(
+    fn: () => Promise<T>,
+    options?: {
+      isComplete?: (events: any[]) => boolean;
+      timeoutMs?: number;
+    }
+  ): Promise<{
     result: T;
     events: any[];
   }> {
-    if (isForceV2) {
+    if (isV2Mode) {
       // In v2 mode, execute and process outbox to ensure async updates complete
       // Events are not emitted in V2 mode, so we return an empty array
       const result = await fn();
@@ -160,8 +172,31 @@ describe('Computed Orchestrator (e2e)', () => {
     eventEmitterService.eventEmitter.on(Events.TABLE_RECORD_UPDATE, handler);
     try {
       const result = await fn();
-      // allow async emission to flush
-      await new Promise((r) => setTimeout(r, 50));
+      // Computed updates may emit a short burst of async record.update events after
+      // the originating mutation resolves. Keep listening until the stream settles.
+      const stableWindowMs = 100;
+      const pollIntervalMs = 25;
+      const deadline = Date.now() + (options?.timeoutMs ?? 2000);
+      let stableSince = Date.now();
+      let lastCount = events.length;
+
+      while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, pollIntervalMs));
+
+        if (events.length !== lastCount) {
+          lastCount = events.length;
+          stableSince = Date.now();
+          continue;
+        }
+
+        if (
+          Date.now() - stableSince >= stableWindowMs &&
+          (!options?.isComplete || options.isComplete(events))
+        ) {
+          break;
+        }
+      }
+
       return { result, events };
     } finally {
       eventEmitterService.eventEmitter.off(Events.TABLE_RECORD_UPDATE, handler);
@@ -279,7 +314,7 @@ describe('Computed Orchestrator (e2e)', () => {
       })) as any;
 
       // Event payload verification only in v1 mode
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const event = payloads[0] as any; // RecordUpdateEvent
         expect(event.payload.tableId).toBe(table.id);
         const changes = event.payload.record.fields as Record<
@@ -498,7 +533,7 @@ IF(
       })) as any;
 
       // Event payload verification only in v1 mode
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const event = payloads[0] as any;
         const recs = Array.isArray(event.payload.record)
           ? event.payload.record
@@ -556,7 +591,7 @@ IF(
       })) as any;
 
       // Event payload verification only in v1 mode
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const event = payloads[0] as any;
         expect(event.payload.tableId).toBe(table.id);
         const rec = Array.isArray(event.payload.record)
@@ -976,7 +1011,7 @@ IF(
       });
 
       // Event payload verification only in v1 mode
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const changes = findLatestRecordChangeMap(events, t2.id, t2.records[0].id);
         const lkpChange = assertChange(changes[lkp.id]);
         expectNoOldValue(lkpChange);
@@ -1039,7 +1074,7 @@ IF(
       const symmetricFieldId = symmetric.id;
 
       // Event payload verification only in v1 mode
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const evtOnT2 = events.find((e) => e.payload?.tableId === t2.id);
         expect(evtOnT2).toBeDefined();
         const recT2 = Array.isArray(evtOnT2!.payload.record)
@@ -1105,7 +1140,7 @@ IF(
       });
 
       // Event payload verification only in v1 mode
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const changes = findLatestRecordChangeMap(events, t1.id, t1.records[0].id);
         const lkpChange = assertChange(changes[lkp.id]);
         expectNoOldValue(lkpChange);
@@ -1160,7 +1195,7 @@ IF(
       });
 
       // Event payload verification only in v1 mode
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const changes = findLatestRecordChangeMap(events, t1.id, t1.records[0].id);
         const lkpChange = assertChange(changes[lkp.id]);
         expectNoOldValue(lkpChange);
@@ -1212,7 +1247,7 @@ IF(
       });
 
       // Event payload verification only in v1 mode
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const changes = findLatestRecordChangeMap(events, t2.id, t2.records[0].id);
         const lkpChange = assertChange(changes[lkp.id]);
         expectNoOldValue(lkpChange);
@@ -1270,7 +1305,7 @@ IF(
       })) as any;
 
       // Event payload verification only in v1 mode
-      if (!isForceV2) {
+      if (!isV2Mode) {
         // Find T2 event
         const t2Event = (payloads as any[]).find((e) => e.payload.tableId === t2.id)!;
         const changes = t2Event.payload.record.fields as Record<
@@ -1337,7 +1372,7 @@ IF(
       });
 
       // Event payload verification only in v1 mode
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const t2Event = [...events]
           .reverse()
           .find((event) => event.payload.tableId === t2.id && toChangeMap(event)[roll2.id])!;
@@ -1425,7 +1460,7 @@ IF(
       })) as any;
 
       // Event payload verification only in v1 mode
-      if (!isForceV2) {
+      if (!isV2Mode) {
         // T1
         const t1Event = (payloads as any[]).find((e) => e.payload.tableId === t1.id)!;
         const t1Changes = (
@@ -1554,7 +1589,7 @@ IF(
       })) as any;
 
       // Event payload verification only in v1 mode
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const t2Event = (payloads as any[]).find((e) => e.payload.tableId === t2.id)!;
         const t2Changes = (
           Array.isArray(t2Event.payload.record) ? t2Event.payload.record[0] : t2Event.payload.record
@@ -1667,7 +1702,7 @@ IF(
       })) as any;
 
       // Event payload verification only in v1 mode
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const t2Event = (payloads as any[]).find((e) => e.payload.tableId === t2.id)!;
         const t2Changes = (
           Array.isArray(t2Event.payload.record) ? t2Event.payload.record[0] : t2Event.payload.record
@@ -1762,7 +1797,7 @@ IF(
           } as IFieldRo);
         });
 
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const hostCreateEvent = creationEvents.find((e) => e.payload.tableId === host.id);
         expect(hostCreateEvent).toBeDefined();
         const createRecordPayload = Array.isArray(hostCreateEvent!.payload.record)
@@ -1804,7 +1839,7 @@ IF(
         (await getRow(hostDbTable, host.records[0].id))[hostFieldVo.dbFieldName]
       );
       expect(valueAfterStatus).toEqual(2);
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const hostFilterEvent = filterEvents.find((e) => e.payload.tableId === host.id);
         expect(hostFilterEvent).toBeDefined();
         const filterRecordPayload = Array.isArray(hostFilterEvent!.payload.record)
@@ -1825,7 +1860,7 @@ IF(
         (await getRow(hostDbTable, host.records[0].id))[hostFieldVo.dbFieldName]
       );
       expect(valueAfterLookupColumnChange).toEqual(1);
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const hostLookupEvent = lookupColumnEvents.find((e) => e.payload.tableId === host.id);
         expect(hostLookupEvent).toBeDefined();
         const lookupRecordPayload = Array.isArray(hostLookupEvent!.payload.record)
@@ -1901,21 +1936,31 @@ IF(
         filterSet.push(...additionalFilterItems);
       }
 
-      const { result: rollupField, events } = await runAndCaptureRecordUpdates(async () => {
-        return await createField(host.id, {
-          name: `Equality ${expression}`,
-          type: FieldType.ConditionalRollup,
-          options: {
-            foreignTableId: foreign.id,
-            lookupFieldId: foreignAmountId,
-            expression,
-            filter: {
-              conjunction: 'and',
-              filterSet,
+      const { result: rollupField, events } = await runAndCaptureRecordUpdates(
+        async () => {
+          return await createField(host.id, {
+            name: `Equality ${expression}`,
+            type: FieldType.ConditionalRollup,
+            options: {
+              foreignTableId: foreign.id,
+              lookupFieldId: foreignAmountId,
+              expression,
+              filter: {
+                conjunction: 'and',
+                filterSet,
+              },
             },
-          },
-        } as IFieldRo);
-      });
+          } as IFieldRo);
+        },
+        {
+          isComplete: (events) =>
+            Boolean(
+              findRecordChangeMap(events, host.id, aliceRecordId) &&
+                findRecordChangeMap(events, host.id, nobodyRecordId)
+            ),
+          timeoutMs: 5000,
+        }
+      );
 
       const hostDbTable = await getDbTableName(host.id);
       const hostFieldVo = (await getFields(host.id)).find((f) => f.id === rollupField.id)! as any;
@@ -2106,7 +2151,7 @@ IF(
           const ctx = await setupEqualityConditionalRollup(expression);
           const { cleanup } = ctx;
           try {
-            if (!isForceV2) {
+            if (!isV2Mode) {
               const createAliceChange = findRecordChangeMap(
                 ctx.creationEvents,
                 ctx.host.id,
@@ -2146,7 +2191,7 @@ IF(
               await update(ctx);
             });
 
-            if (!isForceV2) {
+            if (!isV2Mode) {
               const updateAliceChange = findRecordChangeMap(
                 updateEvents,
                 ctx.host.id,
@@ -2192,7 +2237,7 @@ IF(
         });
         const { cleanup } = ctx;
         try {
-          if (!isForceV2) {
+          if (!isV2Mode) {
             const createAliceChange = findRecordChangeMap(
               ctx.creationEvents,
               ctx.host.id,
@@ -2233,7 +2278,7 @@ IF(
             });
           });
 
-          if (!isForceV2) {
+          if (!isV2Mode) {
             const updateAliceChange = findRecordChangeMap(
               updateEvents,
               ctx.host.id,
@@ -2310,7 +2355,7 @@ IF(
         }
       );
 
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const createAliceChange = findRecordChangeMap(creationEvents, host.id, aliceId);
         expect(createAliceChange).toBeDefined();
         expect(createAliceChange?.[rollupField.id]?.newValue).toEqual(30);
@@ -2327,7 +2372,7 @@ IF(
       const { events: updateEvents } = await runAndCaptureRecordUpdates(async () => {
         await updateRecordByApi(foreign.id, foreign.records[0].id, foreignAmountId, 15);
       });
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const updateAliceChange = findRecordChangeMap(updateEvents, host.id, aliceId);
         expect(updateAliceChange).toBeDefined();
         expect(updateAliceChange?.[rollupField.id]?.newValue).toEqual(35);
@@ -2422,7 +2467,7 @@ IF(
         }
       );
 
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const createAChange = findRecordChangeMap(creationEvents, host.id, hostAId);
         expect(createAChange).toBeDefined();
         expect(createAChange?.[rollupField.id]?.newValue).toEqual(15);
@@ -2571,7 +2616,7 @@ IF(
           } as IFieldRo);
         });
 
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const createChange = findRecordChangeMap(creationEvents, host.id, hostRecordId);
         expect(createChange).toBeDefined();
         expect(createChange?.[conditionalRollupField.id]?.newValue).toEqual(1);
@@ -2588,7 +2633,7 @@ IF(
       const { events: hostFieldChangeEvents } = await runAndCaptureRecordUpdates(async () => {
         await updateRecordByApi(host.id, hostRecordId, targetFieldId, 'B');
       });
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const hostFieldChange = findRecordChangeMap(hostFieldChangeEvents, host.id, hostRecordId);
         expect(hostFieldChange).toBeDefined();
         const hostFieldLookupChange = assertChange(hostFieldChange?.[conditionalRollupField.id]);
@@ -2603,7 +2648,7 @@ IF(
       const { events: foreignFieldChangeEvents } = await runAndCaptureRecordUpdates(async () => {
         await updateRecordByApi(foreign.id, foreign.records[1].id, statusId, 'B');
       });
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const foreignDrivenChange = findRecordChangeMap(
           foreignFieldChangeEvents,
           host.id,
@@ -2687,7 +2732,7 @@ IF(
         (f) => f.id === conditionalRollupField.id
       )! as any;
 
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const createChangeA = findRecordChangeMap(createEvents, host.id, hostRecordAId);
         expect(createChangeA).toBeDefined();
         expect(createChangeA?.[conditionalRollupField.id]?.newValue).toEqual(1);
@@ -2729,7 +2774,7 @@ IF(
         } as IFieldRo);
       });
 
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const updatedChangeA = findRecordChangeMap(filterChangeEvents, host.id, hostRecordAId);
         if (updatedChangeA?.[conditionalRollupField.id]) {
           const change = assertChange(updatedChangeA[conditionalRollupField.id]);
@@ -2870,7 +2915,7 @@ IF(
       })) as any;
 
       // Event payload verification only in v1 mode
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const event = payloads[0] as any;
         expect(event.payload.tableId).toBe(table.id);
         const rec = Array.isArray(event.payload.record)
@@ -2925,7 +2970,7 @@ IF(
       })) as any;
 
       // Event payload verification only in v1 mode
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const evt = payloads[0];
         const rec = Array.isArray(evt.payload.record) ? evt.payload.record[0] : evt.payload.record;
         const changes = rec.fields as FieldChangeMap;
@@ -3010,7 +3055,7 @@ IF(
         await deleteField(t1.id, aId);
       })) as any;
 
-      if (!isForceV2) {
+      if (!isV2Mode) {
         // T2
         const t2Event = (payloads as any[]).find((e) => e.payload.tableId === t2.id)!;
         const t2Changes = (
@@ -3086,7 +3131,7 @@ IF(
         await deleteField(t1.id, aId);
       })) as any;
 
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const t2Event = (payloads as any[]).find((e) => e.payload.tableId === t2.id)!;
         const changes = (
           Array.isArray(t2Event.payload.record) ? t2Event.payload.record[0] : t2Event.payload.record
@@ -3179,7 +3224,7 @@ IF(
         const { events } = await runAndCaptureRecordUpdates(async () => {
           await createField(table.id, { name: 'B', type: FieldType.SingleLineText } as IFieldRo);
         });
-        if (!isForceV2) {
+        if (!isV2Mode) {
           expect(events.length).toBe(1);
           const baseField = (await getFields(table.id)).find((f) => f.name === 'B')!;
           const changeMap = toChangeMap(events[0]);
@@ -3199,7 +3244,7 @@ IF(
           } as IFieldRo);
         });
         const fId = (await getFields(table.id)).find((f) => f.name === 'F')!.id;
-        if (!isForceV2) {
+        if (!isV2Mode) {
           expect(events.length).toBe(1);
           const changeMap = toChangeMap(events[0]);
           const fChange = assertChange(changeMap[fId]);
@@ -3254,7 +3299,7 @@ IF(
           } as any);
         });
         const lkpField = (await getFields(t2.id)).find((f) => f.name === 'LK')!;
-        if (!isForceV2) {
+        if (!isV2Mode) {
           expect(events.length).toBe(1);
           const changeMap = toChangeMap(events[0]);
           const lkpChange = assertChange(changeMap[lkpField.id]);
@@ -3285,7 +3330,7 @@ IF(
           } as any);
         });
         const rId = (await getFields(t2.id)).find((f) => f.name === 'R')!.id;
-        if (!isForceV2) {
+        if (!isV2Mode) {
           expect(events.length).toBe(1);
           const changeMap = toChangeMap(events[0]);
           const rChange = assertChange(changeMap[rId]);
@@ -3327,7 +3372,7 @@ IF(
           options: { expression: `{${aId}} + 5` },
         } as any);
       });
-      if (!isForceV2) {
+      if (!isV2Mode) {
         expect(events.length).toBe(1);
         const changeMap = toChangeMap(events[0]);
         const fChange = assertChange(changeMap[f.id]);
@@ -3362,7 +3407,7 @@ IF(
         const { events } = await runAndCaptureRecordUpdates(async () => {
           await duplicateField(table.id, textField.id, { name: 'Text_copy' });
         });
-        if (!isForceV2) {
+        if (!isV2Mode) {
           expect(events.length).toBe(1);
           const textCopyField = (await getFields(table.id)).find((f) => f.name === 'Text_copy')!;
           const changeMap = toChangeMap(events[0]);
@@ -3383,7 +3428,7 @@ IF(
           await duplicateField(table.id, f.id, { name: 'F_copy' });
         });
         const fCopyId = (await getFields(table.id)).find((x) => x.name === 'F_copy')!.id;
-        if (!isForceV2) {
+        if (!isV2Mode) {
           expect(events.length).toBe(1);
           const changeMap = toChangeMap(events[0]);
           const fCopyChange = assertChange(changeMap[fCopyId]);
@@ -3437,7 +3482,7 @@ IF(
         await updateRecordByApi(t1.id, t1.records[0].id, titleId, 'Bar');
       })) as any;
 
-      if (!isForceV2) {
+      if (!isV2Mode) {
         // Find T2 event
         const t2Event = (payloads as any[]).find((e) => e.payload.tableId === t2.id)!;
         const changes = t2Event.payload.record.fields as FieldChangeMap;
@@ -3581,7 +3626,7 @@ IF(
           .map((x: any) => x?.id)
           .filter(Boolean);
 
-      if (!isForceV2) {
+      if (!isV2Mode) {
         // Expect: one event on T1[1-1] and one symmetric event on T2[2-1]
         const t1Event = (payloads as any[]).find((e) => e.payload.tableId === t1.id)!;
         const t2Event = (payloads as any[]).find((e) => e.payload.tableId === t2.id)!;
@@ -3679,7 +3724,7 @@ IF(
           await updateRecordByApi(t1.id, rA1, linkOnT1.id, [{ id: rB1 }]);
         })) as any;
 
-        if (!isForceV2) {
+        if (!isV2Mode) {
           const t2Event = (payloads as any[]).find((e) => e.payload.tableId === t2.id)!;
           const change = assertChange(getChangeFromEvent(t2Event, linkOnT2.id, rB1));
           expectNoOldValue(change);
@@ -3697,7 +3742,7 @@ IF(
           await updateRecordByApi(t1.id, rA1, linkOnT1.id, [{ id: rB1 }, { id: rB2 }]);
         })) as any;
 
-        if (!isForceV2) {
+        if (!isV2Mode) {
           const t2Event = (payloads as any[]).find((e) => e.payload.tableId === t2.id)!;
           const change = assertChange(getChangeFromEvent(t2Event, linkOnT2.id, rB2));
           expectNoOldValue(change);
@@ -3715,7 +3760,7 @@ IF(
           await updateRecordByApi(t1.id, rA1, linkOnT1.id, [{ id: rB2 }]);
         })) as any;
 
-        if (!isForceV2) {
+        if (!isV2Mode) {
           const t2Event = (payloads as any[]).find((e) => e.payload.tableId === t2.id)!;
           const change = assertChange(
             getChangeFromEvent(t2Event, linkOnT2.id, rB1) ||
@@ -3791,7 +3836,7 @@ IF(
         )(async () => {
           await updateRecordByApi(t1.id, rA1, linkOnT1.id, { id: rB1 });
         })) as any;
-        if (!isForceV2) {
+        if (!isV2Mode) {
           const t2Event = (payloads as any[]).find((e) => e.payload.tableId === t2.id)!;
           const recs = Array.isArray(t2Event.payload.record)
             ? t2Event.payload.record
@@ -3814,7 +3859,7 @@ IF(
         )(async () => {
           await updateRecordByApi(t1.id, rA1, linkOnT1.id, { id: rB2 });
         })) as any;
-        if (!isForceV2) {
+        if (!isV2Mode) {
           const t2Event = (payloads as any[]).find((e) => e.payload.tableId === t2.id)!;
           const recs = Array.isArray(t2Event.payload.record)
             ? t2Event.payload.record
@@ -3892,7 +3937,7 @@ IF(
         )(async () => {
           await updateRecordByApi(t1.id, rA1, linkOnT1.id, [{ id: rB1 }]);
         })) as any;
-        if (!isForceV2) {
+        if (!isV2Mode) {
           const t2Event = (payloads as any[]).find((e) => e.payload.tableId === t2.id)!;
           const recs = Array.isArray(t2Event.payload.record)
             ? t2Event.payload.record
@@ -3915,7 +3960,7 @@ IF(
         )(async () => {
           await updateRecordByApi(t1.id, rA1, linkOnT1.id, [{ id: rB1 }, { id: rB2 }]);
         })) as any;
-        if (!isForceV2) {
+        if (!isV2Mode) {
           const t2Event = (payloads as any[]).find((e) => e.payload.tableId === t2.id)!;
           const recs = Array.isArray(t2Event.payload.record)
             ? t2Event.payload.record
@@ -3938,7 +3983,7 @@ IF(
         )(async () => {
           await updateRecordByApi(t1.id, rA1, linkOnT1.id, [{ id: rB2 }]);
         })) as any;
-        if (!isForceV2) {
+        if (!isV2Mode) {
           const t2Event = (payloads as any[]).find((e) => e.payload.tableId === t2.id)!;
           const recs = Array.isArray(t2Event.payload.record)
             ? t2Event.payload.record
@@ -4037,7 +4082,7 @@ IF(
         await updateRecordByApi(t2.id, r2_1, linkOnT2.id, [{ id: r1_1 }]);
       })) as any;
 
-      if (!isForceV2) {
+      if (!isV2Mode) {
         const t1Event = (payloads as any[]).find((e) => e.payload.tableId === t1.id)!;
         const recs = Array.isArray(t1Event.payload.record)
           ? t1Event.payload.record
diff --git a/apps/nestjs-backend/test/computed-user-field.e2e-spec.ts b/apps/nestjs-backend/test/computed-user-field.e2e-spec.ts
index b917f242c9..5d15663950 100644
--- a/apps/nestjs-backend/test/computed-user-field.e2e-spec.ts
+++ b/apps/nestjs-backend/test/computed-user-field.e2e-spec.ts
@@ -1,6 +1,7 @@
 import type { INestApplication } from '@nestjs/common';
 import type { IFieldRo, IFieldVo, ILinkFieldOptionsRo, ILookupOptionsRo } from '@teable/core';
 import { FieldKeyType, FieldType, Relationship, Role } from '@teable/core';
+import { PrismaService } from '@teable/db-main-prisma';
 import {
   deleteSpaceCollaborator,
   emailSpaceInvitation,
@@ -38,16 +39,24 @@ import {
 describe('Computed user field (e2e)', () => {
   let app: INestApplication;
   let v2ContainerService: V2ContainerService;
+  let prisma: PrismaService;
   const spaceId = globalThis.testConfig.spaceId;
   const userName = globalThis.testConfig.userName;
   const isForceV2 = process.env.FORCE_V2_ALL === 'true';
+  let isV2Mode = isForceV2;
   let baseId: string;
   beforeAll(async () => {
     const appCtx = await initApp();
     app = appCtx.app;
     v2ContainerService = app.get(V2ContainerService);
+    prisma = app.get(PrismaService);
     const base = await createBase({ name: 'base1', spaceId });
     baseId = base.id;
+    const baseMeta = await prisma.base.findUnique({
+      where: { id: baseId },
+      select: { v2Enabled: true },
+    });
+    isV2Mode = isForceV2 || Boolean(baseMeta?.v2Enabled);
   });
 
   afterAll(async () => {
@@ -56,7 +65,7 @@ describe('Computed user field (e2e)', () => {
   });
 
   async function processV2Outbox(): Promise<void> {
-    if (!isForceV2) return;
+    if (!isV2Mode) return;
 
     const container = await v2ContainerService.getContainer();
     const drainService = container.resolve<IComputedUpdateDrainService>(
@@ -132,7 +141,7 @@ describe('Computed user field (e2e)', () => {
         title: userName,
       });
 
-      if (isForceV2) {
+      if (isV2Mode) {
         expect(records.data.records[1].fields[lastModifiedByField.id]).toMatchObject({
           title: userName,
         });
@@ -191,7 +200,7 @@ describe('Computed user field (e2e)', () => {
 
       expect(records.data.records[0].fields[formulaField.id]).toEqual(userName);
 
-      if (isForceV2) {
+      if (isV2Mode) {
         expect(records.data.records[1].fields[lastModifiedByField.id]).toMatchObject({
           title: userName,
         });
@@ -255,7 +264,7 @@ describe('Computed user field (e2e)', () => {
         records.data.records[0].lastModifiedTime
       );
 
-      if (isForceV2) {
+      if (isV2Mode) {
         expect(records.data.records[1].fields[lastModifiedTimeField.id]).toEqual(
           records.data.records[1].lastModifiedTime
         );
@@ -317,7 +326,7 @@ describe('Computed user field (e2e)', () => {
       });
 
       let record = await getRecord(table1.id, recordId, { fieldKeyType: FieldKeyType.Id });
-      if (isForceV2) {
+      if (isV2Mode) {
         expect(record.data.fields[lastModifiedByField.id]).toMatchObject({
           id: globalThis.testConfig.userId,
           title: globalThis.testConfig.userName,
@@ -371,7 +380,7 @@ describe('Computed user field (e2e)', () => {
       });
 
       let record = await getRecord(table1.id, recordId, { fieldKeyType: FieldKeyType.Id });
-      if (isForceV2) {
+      if (isV2Mode) {
         expect(record.data.fields[lastModifiedByField.id]).toMatchObject({
           id: globalThis.testConfig.userId,
           title: globalThis.testConfig.userName,
diff --git a/apps/nestjs-backend/test/field-converting.e2e-spec.ts b/apps/nestjs-backend/test/field-converting.e2e-spec.ts
index a5990a4d75..7916738bba 100644
--- a/apps/nestjs-backend/test/field-converting.e2e-spec.ts
+++ b/apps/nestjs-backend/test/field-converting.e2e-spec.ts
@@ -848,6 +848,32 @@ describe('OpenAPI Freely perform column transformations (e2e)', () => {
       await expect(convertField(table1.id, table1.fields[0].id, newFieldRo)).rejects.toThrow();
     });
 
+    it('should not convert primary field to a lookup field (T3367)', async () => {
+      const linkFieldRo: IFieldRo = {
+        name: 'link',
+        type: FieldType.Link,
+        options: {
+          relationship: Relationship.ManyOne,
+          foreignTableId: table2.id,
+        },
+      };
+      const linkField = await createField(table1.id, linkFieldRo);
+
+      const toLookupRo: IFieldRo = {
+        type: FieldType.SingleLineText,
+        isLookup: true,
+        lookupOptions: {
+          foreignTableId: table2.id,
+          lookupFieldId: table2.fields[0].id,
+          linkFieldId: linkField.id,
+        },
+      };
+
+      await expect(convertField(table1.id, table1.fields[0].id, toLookupRo)).rejects.toThrow(
+        /primary/i
+      );
+    });
+
     it('should convert text to date', async () => {
       const newFieldRo: IFieldRo = {
         type: FieldType.Date,
diff --git a/apps/nestjs-backend/test/field-duplicate.e2e-spec.ts b/apps/nestjs-backend/test/field-duplicate.e2e-spec.ts
index d501b5434b..30673deb5f 100644
--- a/apps/nestjs-backend/test/field-duplicate.e2e-spec.ts
+++ b/apps/nestjs-backend/test/field-duplicate.e2e-spec.ts
@@ -905,6 +905,158 @@ describe('OpenAPI FieldOpenApiController for duplicate field (e2e)', () => {
     });
   });
 
+  describe('duplicate filtered lookup fields that target conditional lookups', () => {
+    let issuesTable: ITableFullVo;
+    let releasesTable: ITableFullVo;
+    let launchesTable: ITableFullVo;
+    let originalForceV2All: string | undefined;
+    let issueTitleFieldId: string;
+    let issuePrFieldId: string;
+    let releasePrFieldId: string;
+    let releaseEditionFieldId: string;
+    let issuesTitleLookupFieldId: string;
+    let relatedReleasesFieldId: string;
+    let releaseIssuesFieldId: string;
+
+    beforeAll(async () => {
+      originalForceV2All = process.env.FORCE_V2_ALL;
+      process.env.FORCE_V2_ALL = 'false';
+
+      issuesTable = await createTable(baseId, {
+        name: 'duplicate_nested_lookup_issues',
+        fields: [
+          { name: 'Title', type: FieldType.SingleLineText },
+          { name: 'PR', type: FieldType.SingleLineText },
+        ],
+      });
+
+      const issueFields = (await getFields(issuesTable.id)).data;
+      issueTitleFieldId = issueFields.find((field) => field.name === 'Title')!.id;
+      issuePrFieldId = issueFields.find((field) => field.name === 'PR')!.id;
+
+      releasesTable = await createTable(baseId, {
+        name: 'duplicate_nested_lookup_releases',
+        fields: [
+          { name: 'Tag', type: FieldType.SingleLineText },
+          { name: 'PR', type: FieldType.SingleLineText },
+          {
+            name: 'Edition',
+            type: FieldType.SingleSelect,
+            options: {
+              choices: [{ name: 'cloud' }, { name: 'ee' }],
+            },
+          },
+        ],
+      });
+
+      const releaseFields = (await getFields(releasesTable.id)).data;
+      releasePrFieldId = releaseFields.find((field) => field.name === 'PR')!.id;
+      releaseEditionFieldId = releaseFields.find((field) => field.name === 'Edition')!.id;
+
+      issuesTitleLookupFieldId = (
+        await createField(releasesTable.id, {
+          name: 'Issues title',
+          type: FieldType.SingleLineText,
+          isLookup: true,
+          isConditionalLookup: true,
+          lookupOptions: {
+            foreignTableId: issuesTable.id,
+            lookupFieldId: issueTitleFieldId,
+            filter: {
+              conjunction: 'and',
+              filterSet: [
+                {
+                  fieldId: issuePrFieldId,
+                  operator: 'is',
+                  value: {
+                    type: 'field',
+                    fieldId: releasePrFieldId,
+                    tableId: releasesTable.id,
+                  },
+                },
+              ],
+            },
+          },
+        })
+      ).data.id;
+
+      launchesTable = await createTable(baseId, {
+        name: 'duplicate_nested_lookup_launches',
+        fields: [{ name: 'Launch', type: FieldType.SingleLineText }],
+      });
+
+      relatedReleasesFieldId = (
+        await createField(launchesTable.id, {
+          name: 'Related Releases',
+          type: FieldType.Link,
+          options: {
+            relationship: Relationship.ManyMany,
+            foreignTableId: releasesTable.id,
+            isOneWay: false,
+          },
+        })
+      ).data.id;
+
+      releaseIssuesFieldId = (
+        await createField(launchesTable.id, {
+          name: 'Release Issues',
+          type: FieldType.SingleLineText,
+          isLookup: true,
+          lookupOptions: {
+            foreignTableId: releasesTable.id,
+            linkFieldId: relatedReleasesFieldId,
+            lookupFieldId: issuesTitleLookupFieldId,
+            filter: {
+              conjunction: 'and',
+              filterSet: [
+                {
+                  fieldId: releaseEditionFieldId,
+                  operator: 'is',
+                  value: 'cloud',
+                },
+              ],
+            },
+          },
+        })
+      ).data.id;
+
+      process.env.FORCE_V2_ALL = originalForceV2All;
+    });
+
+    afterAll(async () => {
+      process.env.FORCE_V2_ALL = originalForceV2All;
+      await permanentDeleteTable(baseId, launchesTable.id);
+      await permanentDeleteTable(baseId, releasesTable.id);
+      await permanentDeleteTable(baseId, issuesTable.id);
+    });
+
+    it('should duplicate filtered lookups whose source field is conditional lookup', async () => {
+      const duplicated = (
+        await duplicateField(launchesTable.id, releaseIssuesFieldId, {
+          name: 'Release Issues Copy',
+        })
+      ).data;
+
+      expect(duplicated.isLookup).toBe(true);
+      expect(duplicated.isConditionalLookup).not.toBe(true);
+      expect(duplicated.lookupOptions).toMatchObject({
+        foreignTableId: releasesTable.id,
+        linkFieldId: relatedReleasesFieldId,
+        lookupFieldId: issuesTitleLookupFieldId,
+        filter: {
+          conjunction: 'and',
+          filterSet: [
+            expect.objectContaining({
+              fieldId: releaseEditionFieldId,
+              operator: 'is',
+              value: 'cloud',
+            }),
+          ],
+        },
+      });
+    });
+  });
+
   describe('duplicate rollup fields', () => {
     let table: ITableFullVo;
     let subTable: ITableFullVo;
diff --git a/apps/nestjs-backend/test/formula.e2e-spec.ts b/apps/nestjs-backend/test/formula.e2e-spec.ts
index e8eed84a34..26ac3825b9 100644
--- a/apps/nestjs-backend/test/formula.e2e-spec.ts
+++ b/apps/nestjs-backend/test/formula.e2e-spec.ts
@@ -19,7 +19,13 @@ import {
   Relationship,
   TimeFormatting,
 } from '@teable/core';
-import { getRecord, updateRecords, type ITableFullVo } from '@teable/openapi';
+import {
+  X_CANARY_HEADER,
+  axios,
+  getRecord,
+  updateRecords,
+  type ITableFullVo,
+} from '@teable/openapi';
 import {
   createField,
   createFields,
@@ -692,6 +698,69 @@ describe('OpenAPI formula (e2e)', () => {
     expect(clearedRecord.fields[equalsEmptyField.name]).toEqual(1);
   });
 
+  const expectBlankSpacingComparison = async (canaryHeader: 'true' | 'false') => {
+    const previousCanaryHeader = axios.defaults.headers.common[X_CANARY_HEADER];
+    axios.defaults.headers.common[X_CANARY_HEADER] = canaryHeader;
+
+    try {
+      const localizedNumberField = await createField(table1Id, {
+        id: generateFieldId(),
+        name: '入职体重(kg)',
+        type: FieldType.Number,
+        options: {
+          formatting: { type: NumberFormattingType.Decimal, precision: 0 },
+        },
+      });
+
+      const compactBlankField = await createField(table1Id, {
+        id: generateFieldId(),
+        name: 'blank-compact',
+        type: FieldType.Formula,
+        options: {
+          expression: `{${localizedNumberField.id}} !=BLANK()`,
+        },
+      });
+
+      const spacedBlankField = await createField(table1Id, {
+        id: generateFieldId(),
+        name: 'blank-spaced',
+        type: FieldType.Formula,
+        options: {
+          expression: `{${localizedNumberField.id}} != BLANK()`,
+        },
+      });
+
+      const { records } = await createRecords(table1Id, {
+        fieldKeyType: FieldKeyType.Name,
+        records: [
+          {
+            fields: {
+              [localizedNumberField.name]: 70,
+            },
+          },
+        ],
+      });
+
+      const { data: record } = await getRecord(table1Id, records[0].id);
+      expect(record.fields?.[compactBlankField.name]).toBe(true);
+      expect(record.fields?.[spacedBlankField.name]).toBe(true);
+    } finally {
+      if (previousCanaryHeader == null) {
+        delete axios.defaults.headers.common[X_CANARY_HEADER];
+      } else {
+        axios.defaults.headers.common[X_CANARY_HEADER] = previousCanaryHeader;
+      }
+    }
+  };
+
+  it('should keep BLANK() comparisons stable with spaced function calls in v1 mode', async () => {
+    await expectBlankSpacingComparison('false');
+  });
+
+  it('should keep BLANK() comparisons stable with spaced function calls in canary mode', async () => {
+    await expectBlankSpacingComparison('true');
+  });
+
   it('should calculate formula containing question mark literal', async () => {
     const urlFormulaField = await createField(table1Id, {
       name: 'url formula',
diff --git a/apps/nestjs-backend/test/integrity.e2e-spec.ts b/apps/nestjs-backend/test/integrity.e2e-spec.ts
index 1461a678eb..c8e96ba8a2 100644
--- a/apps/nestjs-backend/test/integrity.e2e-spec.ts
+++ b/apps/nestjs-backend/test/integrity.e2e-spec.ts
@@ -1079,4 +1079,172 @@ describe('OpenAPI integrity (e2e)', () => {
       expect(integrity3.data.hasIssues).toEqual(false);
     });
   });
+
+  describe('fix invalid primary', () => {
+    let baseId1: string;
+    let base1table: ITableFullVo;
+
+    beforeEach(async () => {
+      baseId1 = (await createBase({ spaceId, name: 'base1' })).data.id;
+      base1table = await createTable(baseId1, { name: 'base1table' });
+    });
+
+    afterEach(async () => {
+      await permanentDeleteTable(baseId1, base1table.id);
+      await deleteBase(baseId1);
+    });
+
+    it('detects and fixes a primary field with unsupported type by promoting existing candidate', async () => {
+      // Inject the corrupt state directly: bulk paths historically allowed isPrimary=true on a
+      // checkbox field. Real-world examples in prod were created by AI / .tea import bypassing
+      // the source guards we added.
+      const originalPrimaryId = base1table.fields.find((f) => f.isPrimary)!.id;
+      await prisma.txClient().field.update({
+        where: { id: originalPrimaryId },
+        data: { isPrimary: null },
+      });
+      const checkboxField = await createField(base1table.id, {
+        name: 'broken primary',
+        type: FieldType.Checkbox,
+      });
+      await prisma.txClient().field.update({
+        where: { id: checkboxField.id },
+        data: { isPrimary: true },
+      });
+
+      const integrity = await checkBaseIntegrity(baseId1, base1table.id);
+      const issues = integrity.data.linkFieldIssues.flatMap((i) => i.issues);
+      expect(issues.some((i) => i.type === IntegrityIssueType.InvalidPrimaryType)).toEqual(true);
+
+      await fixBaseIntegrity(baseId1, base1table.id);
+
+      const integrity2 = await checkBaseIntegrity(baseId1, base1table.id);
+      expect(integrity2.data.hasIssues).toEqual(false);
+
+      // Promote-existing path: the demoted original SingleLineText is the first eligible
+      // candidate by order, so it gets re-promoted. No new formula field is created.
+      const primaries = await prisma.txClient().field.findMany({
+        where: { tableId: base1table.id, isPrimary: true, deletedTime: null },
+        select: { id: true },
+      });
+      expect(primaries).toHaveLength(1);
+      expect(primaries[0].id).toEqual(originalPrimaryId);
+
+      // Bad checkbox is demoted but NOT renamed — rename only happens in the formula
+      // fallback path where the new field needs to take the original name.
+      const checkboxAfter = await prisma.txClient().field.findFirst({
+        where: { id: checkboxField.id },
+        select: { isPrimary: true, name: true },
+      });
+      expect(checkboxAfter?.isPrimary).toBeNull();
+      expect(checkboxAfter?.name).toEqual('broken primary');
+    });
+
+    it('falls back to a new formula primary when no eligible candidate exists', async () => {
+      // Make every non-bad field ineligible so promote-existing has nothing to promote, then
+      // verify the formula fallback path runs and mirrors the bad primary's value.
+      const originalPrimary = base1table.fields.find((f) => f.isPrimary)!;
+      const otherFields = base1table.fields.filter((f) => !f.isPrimary);
+
+      // Mutate every non-primary field to attachment (not in PRIMARY_SUPPORTED_TYPES) so
+      // they can't be promoted.
+      for (const field of otherFields) {
+        await prisma.txClient().field.update({
+          where: { id: field.id },
+          data: { type: FieldType.Attachment },
+        });
+      }
+
+      // Replace the original SingleLineText primary with a checkbox bad primary.
+      await prisma.txClient().field.update({
+        where: { id: originalPrimary.id },
+        data: { isPrimary: null, type: FieldType.Attachment },
+      });
+      const checkboxField = await createField(base1table.id, {
+        name: 'broken primary',
+        type: FieldType.Checkbox,
+      });
+      await prisma.txClient().field.update({
+        where: { id: checkboxField.id },
+        data: { isPrimary: true },
+      });
+
+      await fixBaseIntegrity(baseId1, base1table.id);
+
+      const primaries = await prisma.txClient().field.findMany({
+        where: { tableId: base1table.id, isPrimary: true, deletedTime: null },
+        select: { id: true, type: true, name: true, options: true },
+      });
+      expect(primaries).toHaveLength(1);
+      expect(primaries[0].type).toEqual(FieldType.Formula);
+      expect(primaries[0].name).toEqual('broken primary');
+      // Formula expression references the old field id so the displayed value stays continuous.
+      expect(primaries[0].options).toContain(checkboxField.id);
+    });
+
+    it('preserves existing valid primary when an extra invalid primary is fixed', async () => {
+      // Defensive scenario: a valid primary already exists, but somehow a second isPrimary=true
+      // field with bad type sneaks in (race / direct SQL / future regression).
+      // Fix should demote the invalid one and keep the valid primary as-is, without
+      // creating a third "formula" primary.
+      const validPrimaryId = base1table.fields.find((f) => f.isPrimary)!.id;
+
+      const checkboxField = await createField(base1table.id, {
+        name: 'rogue checkbox primary',
+        type: FieldType.Checkbox,
+      });
+      await prisma.txClient().field.update({
+        where: { id: checkboxField.id },
+        data: { isPrimary: true },
+      });
+
+      const before = await prisma.txClient().field.findMany({
+        where: { tableId: base1table.id, isPrimary: true, deletedTime: null },
+      });
+      expect(before).toHaveLength(2);
+
+      await fixBaseIntegrity(baseId1, base1table.id);
+
+      const after = await prisma.txClient().field.findMany({
+        where: { tableId: base1table.id, isPrimary: true, deletedTime: null },
+        select: { id: true, type: true },
+      });
+      expect(after).toHaveLength(1);
+      expect(after[0].id).toEqual(validPrimaryId);
+
+      const checkboxAfter = await prisma.txClient().field.findFirst({
+        where: { id: checkboxField.id },
+        select: { isPrimary: true, name: true },
+      });
+      expect(checkboxAfter?.isPrimary).toBeNull();
+      // Kept-existing path: bad primary is demoted but NOT renamed.
+      expect(checkboxAfter?.name).toEqual('rogue checkbox primary');
+    });
+
+    it('detects and fixes a table missing its primary field by promoting existing candidate', async () => {
+      const primary = base1table.fields.find((f) => f.isPrimary)!;
+      await prisma.txClient().field.update({
+        where: { id: primary.id },
+        data: { isPrimary: null },
+      });
+
+      const integrity = await checkBaseIntegrity(baseId1, base1table.id);
+      const issues = integrity.data.linkFieldIssues.flatMap((i) => i.issues);
+      expect(issues.some((i) => i.type === IntegrityIssueType.MissingPrimary)).toEqual(true);
+
+      await fixBaseIntegrity(baseId1, base1table.id);
+
+      const integrity2 = await checkBaseIntegrity(baseId1, base1table.id);
+      expect(integrity2.data.hasIssues).toEqual(false);
+
+      // Should re-promote the existing primary, not create a duplicate "Name 2".
+      const primaries = await prisma.txClient().field.findMany({
+        where: { tableId: base1table.id, isPrimary: true, deletedTime: null },
+        select: { id: true, name: true },
+      });
+      expect(primaries).toHaveLength(1);
+      expect(primaries[0].id).toEqual(primary.id);
+      expect(primaries[0].name).toEqual(primary.name);
+    });
+  });
 });
diff --git a/apps/nestjs-backend/test/record-filter-query.e2e-spec.ts b/apps/nestjs-backend/test/record-filter-query.e2e-spec.ts
index 7748f50604..21ff2a5894 100644
--- a/apps/nestjs-backend/test/record-filter-query.e2e-spec.ts
+++ b/apps/nestjs-backend/test/record-filter-query.e2e-spec.ts
@@ -157,8 +157,8 @@ describe('OpenAPI Record-Filter-Query (e2e)', () => {
       test.each(MULTIPLE_SELECT_FIELD_CASES)(testDesc, async (param) => doTest(table, param));
     });
 
-    describe('dateRange filter error cases', () => {
-      it('should throw error when start > end (invalid range)', async () => {
+    describe('dateRange invalid filters are skipped instead of crashing the query', () => {
+      it('skips when start > end (compiler-level validation)', async () => {
         const { fieldIndex, operator, queryValue } = DATE_RANGE_ERROR_CASES.invalidRange;
         const filter: IFilter = {
           filterSet: [
@@ -170,10 +170,11 @@ describe('OpenAPI Record-Filter-Query (e2e)', () => {
           ],
           conjunction: and.value,
         };
-        await expect(getFilterRecord(table.id, table.views[0].id, filter)).rejects.toThrow();
+        const result = await getFilterRecord(table.id, table.views[0].id, filter);
+        expect(result.records.length).toBeGreaterThan(0);
       });
 
-      it('should throw error when dateRange is used with isNot operator', async () => {
+      it('skips when dateRange is used with isNot operator (analyzer-level validation)', async () => {
         const { fieldIndex, operator, queryValue } = DATE_RANGE_ERROR_CASES.invalidOperator;
         const filter: IFilter = {
           filterSet: [
@@ -185,7 +186,8 @@ describe('OpenAPI Record-Filter-Query (e2e)', () => {
           ],
           conjunction: and.value,
         };
-        await expect(getFilterRecord(table.id, table.views[0].id, filter)).rejects.toThrow();
+        const result = await getFilterRecord(table.id, table.views[0].id, filter);
+        expect(result.records.length).toBeGreaterThan(0);
       });
     });
   });
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 62918c88fd..a0f65a530a 100644
--- a/apps/nestjs-backend/test/record-search-query.e2e-spec.ts
+++ b/apps/nestjs-backend/test/record-search-query.e2e-spec.ts
@@ -927,35 +927,6 @@ describe('OpenAPI Record-Search-Query (e2e)', async () => {
       });
     });
 
-    it('should search date fields globally when search index is enabled', async () => {
-      await toggleTableIndex(baseId, table.id, { type: TableIndex.search });
-
-      const dateField = table.fields.find(
-        (f) => f.cellValueType === CellValueType.DateTime
-      )! as IFieldInstance;
-
-      const { records } = (
-        await apiGetRecords(table.id, {
-          fieldKeyType: FieldKeyType.Id,
-          viewId: table.views[0].id,
-          search: ['2022-03-02', '', true],
-        })
-      ).data;
-
-      expect(records.length).toBe(1);
-      expect(records[0].fields[dateField.id]).toBe('2022-03-01T16:00:00.000Z');
-
-      const searchIndex = await getSearchIndex(table.id, {
-        viewId: table.views[0].id,
-        take: 10,
-        search: ['2022-03-02', '', true],
-      });
-
-      expect(searchIndex.data).toEqual(
-        expect.arrayContaining([expect.objectContaining({ fieldId: dateField.id })])
-      );
-    });
-
     it('should repair abnormal index', async () => {
       const textfield = table.fields.find(
         (f) => f.cellValueType === CellValueType.String
diff --git a/apps/nestjs-backend/test/record-typecast.e2e-spec.ts b/apps/nestjs-backend/test/record-typecast.e2e-spec.ts
index accdf62ec8..6c900ace3b 100644
--- a/apps/nestjs-backend/test/record-typecast.e2e-spec.ts
+++ b/apps/nestjs-backend/test/record-typecast.e2e-spec.ts
@@ -279,7 +279,8 @@ describe('Record Typecast', () => {
         typecast: true,
       }).then((res) => res.data);
 
-      expect(record.fields[table.fields[1].id]).toBeUndefined();
+      const emptySelectValue = record.fields[table.fields[1].id];
+      expect(emptySelectValue === null || emptySelectValue === undefined).toBe(true);
     });
   });
 });
diff --git a/apps/nestjs-backend/test/table.e2e-spec.ts b/apps/nestjs-backend/test/table.e2e-spec.ts
index 019afa2b2c..5388ef0d74 100644
--- a/apps/nestjs-backend/test/table.e2e-spec.ts
+++ b/apps/nestjs-backend/test/table.e2e-spec.ts
@@ -375,6 +375,20 @@ describe('OpenAPI TableController (e2e)', () => {
     expect(fields[2].type).toEqual(FieldType.LongText);
   });
 
+  it('should reject createTable when first field has unsupported primary type', async () => {
+    // Without the fix, the service would auto-promote a checkbox first field to primary
+    // (bypassing prepareCreateFields validation), persisting a bad-type primary.
+    await expect(
+      createTable(baseId, {
+        name: 'bad primary table',
+        fields: [
+          { name: 'Done', type: FieldType.Checkbox },
+          { name: 'Note', type: FieldType.SingleLineText },
+        ],
+      })
+    ).rejects.toThrow(/primary/i);
+  });
+
   it('should update table simple properties', async () => {
     const result = await createTable(baseId, {
       name: 'table',
diff --git a/apps/nestjs-backend/test/trash.e2e-spec.ts b/apps/nestjs-backend/test/trash.e2e-spec.ts
index 1638299e70..72ecf990ee 100644
--- a/apps/nestjs-backend/test/trash.e2e-spec.ts
+++ b/apps/nestjs-backend/test/trash.e2e-spec.ts
@@ -1,6 +1,7 @@
 /* eslint-disable sonarjs/no-duplicate-string */
 import type { INestApplication } from '@nestjs/common';
 import { FieldType, Relationship } from '@teable/core';
+import { PrismaService } from '@teable/db-main-prisma';
 import type { ITrashItemVo } from '@teable/openapi';
 import {
   getTrash,
@@ -43,18 +44,32 @@ const waitForBaseTrashItems = async (baseId: string, expectedCount = 1, maxRetri
 describe('Trash (e2e)', () => {
   let app: INestApplication;
   let eventEmitterService: EventEmitterService;
+  let prisma: PrismaService;
 
   let awaitWithSpaceEvent: <T>(fn: () => Promise<T>) => Promise<T>;
   let awaitWithBaseEvent: <T>(fn: () => Promise<T>) => Promise<T>;
   let awaitWithTableEvent: <T>(fn: () => Promise<T>) => Promise<T>;
-  const awaitWithTableDeleteSync = async <T>(fn: () => Promise<T>) =>
-    isForceV2 ? await fn() : awaitWithTableEvent(fn);
+  const isBaseV2Mode = async (baseId: string) => {
+    if (isForceV2) {
+      return true;
+    }
+
+    const base = await prisma.base.findUnique({
+      where: { id: baseId },
+      select: { v2Enabled: true },
+    });
+    return Boolean(base?.v2Enabled);
+  };
+
+  const awaitWithTableDeleteSync = async <T>(baseId: string, fn: () => Promise<T>) =>
+    (await isBaseV2Mode(baseId)) ? await fn() : awaitWithTableEvent(fn);
 
   beforeAll(async () => {
     const appCtx = await initApp();
 
     app = appCtx.app;
     eventEmitterService = app.get(EventEmitterService);
+    prisma = app.get(PrismaService);
 
     awaitWithSpaceEvent = createAwaitWithEvent(eventEmitterService, Events.SPACE_DELETE);
     awaitWithBaseEvent = createAwaitWithEvent(eventEmitterService, Events.BASE_DELETE);
@@ -100,7 +115,7 @@ describe('Trash (e2e)', () => {
 
     it('should retrieve trash items for base when a table is deleted', async () => {
       const tableId = (await createTable(baseId, {})).id;
-      await awaitWithTableDeleteSync(() => deleteTable(baseId, tableId));
+      await awaitWithTableDeleteSync(baseId, () => deleteTable(baseId, tableId));
 
       const res = await waitForBaseTrashItems(baseId, 1);
 
@@ -120,7 +135,7 @@ describe('Trash (e2e)', () => {
         },
       });
 
-      await awaitWithTableDeleteSync(() => deleteTable(baseId, foreignTableId));
+      await awaitWithTableDeleteSync(baseId, () => deleteTable(baseId, foreignTableId));
 
       const res = await waitForBaseTrashItems(baseId, 1);
 
@@ -167,7 +182,7 @@ describe('Trash (e2e)', () => {
     });
 
     it('should restore table successfully', async () => {
-      await awaitWithTableDeleteSync(() => deleteTable(baseId, tableId));
+      await awaitWithTableDeleteSync(baseId, () => deleteTable(baseId, tableId));
 
       const trash = (await waitForBaseTrashItems(baseId, 1)).data;
       const restored = await restoreTrash(trash.trashItems[0].id);
@@ -176,15 +191,27 @@ describe('Trash (e2e)', () => {
     });
 
     it('should expose restore-table canary headers when restoring a table trash item', async () => {
-      await awaitWithTableDeleteSync(() => deleteTable(baseId, tableId));
+      await awaitWithTableDeleteSync(baseId, () => deleteTable(baseId, tableId));
 
       const trash = (await waitForBaseTrashItems(baseId, 1)).data;
-      const restored = await restoreTrash(trash.trashItems[0].id);
+      const previousForceV2All = process.env.FORCE_V2_ALL;
+      const restored = await (async () => {
+        process.env.FORCE_V2_ALL = 'true';
+        try {
+          return await restoreTrash(trash.trashItems[0].id);
+        } finally {
+          if (previousForceV2All == null) {
+            delete process.env.FORCE_V2_ALL;
+          } else {
+            process.env.FORCE_V2_ALL = previousForceV2All;
+          }
+        }
+      })();
 
       expect(restored.status).toEqual(201);
-      expect(restored.headers['x-teable-v2']).toBe(isForceV2 ? 'true' : 'false');
+      expect(restored.headers['x-teable-v2']).toBe('true');
       expect(restored.headers['x-teable-v2-feature']).toBe('restoreTable');
-      expect(restored.headers['x-teable-v2-reason']).toBeTruthy();
+      expect(restored.headers['x-teable-v2-reason']).toBe('new_base');
     });
   });
 
@@ -210,9 +237,9 @@ describe('Trash (e2e)', () => {
       const tableId2 = (await createTable(baseId, {})).id;
       const tableId3 = (await createTable(baseId, {})).id;
 
-      await awaitWithTableDeleteSync(() => deleteTable(baseId, tableId1));
-      await awaitWithTableDeleteSync(() => deleteTable(baseId, tableId2));
-      await awaitWithTableDeleteSync(() => deleteTable(baseId, tableId3));
+      await awaitWithTableDeleteSync(baseId, () => deleteTable(baseId, tableId1));
+      await awaitWithTableDeleteSync(baseId, () => deleteTable(baseId, tableId2));
+      await awaitWithTableDeleteSync(baseId, () => deleteTable(baseId, tableId3));
 
       const trash = (await waitForBaseTrashItems(baseId, 3)).data;
 
diff --git a/apps/nestjs-backend/test/undo-redo.e2e-spec.ts b/apps/nestjs-backend/test/undo-redo.e2e-spec.ts
index 5f7dc12ebb..245856727b 100644
--- a/apps/nestjs-backend/test/undo-redo.e2e-spec.ts
+++ b/apps/nestjs-backend/test/undo-redo.e2e-spec.ts
@@ -72,6 +72,23 @@ const waitForTableTrashCount = async (tableId: string, expectedCount: number, ma
 
   return await getTrashItems({ resourceId: tableId, resourceType: ResourceType.Table });
 };
+const waitForViewVisibility = async (
+  tableId: string,
+  viewId: string,
+  visible: boolean,
+  maxRetries = 100
+) => {
+  for (let i = 0; i < maxRetries; i++) {
+    const views = (await getViewList(tableId)).data;
+    const view = views.find((v) => v.id === viewId);
+    if (Boolean(view) === visible) {
+      return view;
+    }
+    await sleep(100);
+  }
+
+  return (await getViewList(tableId)).data.find((v) => v.id === viewId);
+};
 
 describe('Undo Redo (e2e)', () => {
   let app: INestApplication;
@@ -1254,8 +1271,7 @@ describe('Undo Redo (e2e)', () => {
 
     await undo(table.id);
 
-    const viewsAfterUndo = (await getViewList(table.id)).data;
-    expect(viewsAfterUndo.find((v) => v.id === view.id)).toMatchObject({
+    expect(await waitForViewVisibility(table.id, view.id, true)).toMatchObject({
       id: view.id,
       name: view.name,
       type: view.type,
@@ -1263,8 +1279,7 @@ describe('Undo Redo (e2e)', () => {
 
     await redo(table.id);
 
-    const viewsAfterRedo = (await getViewList(table.id)).data;
-    expect(viewsAfterRedo.find((v) => v.id === view.id)).toBeUndefined();
+    expect(await waitForViewVisibility(table.id, view.id, false)).toBeUndefined();
   });
 
   it('should undo / redo update view property', async () => {
diff --git a/apps/nextjs-app/src/components/changelog/ChangelogNotification.tsx b/apps/nextjs-app/src/components/changelog/ChangelogNotification.tsx
index 453b1c105e..6d32e10e7f 100644
--- a/apps/nextjs-app/src/components/changelog/ChangelogNotification.tsx
+++ b/apps/nextjs-app/src/components/changelog/ChangelogNotification.tsx
@@ -1,6 +1,6 @@
 import { ArrowUpRight, X } from '@teable/icons';
 import { LocalStorageKeys } from '@teable/sdk/config';
-import { useIsHydrated, useShareId } from '@teable/sdk/hooks';
+import { useIsHydrated, useIsReadOnlyPreview } from '@teable/sdk/hooks';
 import { Button } from '@teable/ui-lib/shadcn';
 import { Rocket } from 'lucide-react';
 import { useTranslation } from 'next-i18next';
@@ -11,7 +11,7 @@ export const ChangelogNotification = () => {
   const { t } = useTranslation('common');
   const isHydrated = useIsHydrated();
   const isCloud = useIsCloud();
-  const shareId = useShareId();
+  const isReadOnlyPreview = useIsReadOnlyPreview();
   const [visible, setVisible] = useState(false);
 
   const changelogId = t('changelog.id');
@@ -39,7 +39,7 @@ export const ChangelogNotification = () => {
     }
   }, [changelogId]);
 
-  if (!isCloud || !isHydrated || !visible || shareId) {
+  if (!isCloud || !isHydrated || !visible || isReadOnlyPreview) {
     return null;
   }
 
diff --git a/apps/nextjs-app/src/features/app/blocks/admin/setting/SettingPage.tsx b/apps/nextjs-app/src/features/app/blocks/admin/setting/SettingPage.tsx
index e18804e356..91a3b49afa 100644
--- a/apps/nextjs-app/src/features/app/blocks/admin/setting/SettingPage.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/admin/setting/SettingPage.tsx
@@ -30,10 +30,11 @@ import { scrollToTarget } from './utils';
 export interface ISettingPageProps {
   settingServerData?: ISettingVo;
   rewardManage?: React.ReactNode;
+  canarySettings?: React.ReactNode;
 }
 
 export const SettingPage = (props: ISettingPageProps) => {
-  const { settingServerData, rewardManage } = props;
+  const { settingServerData, rewardManage, canarySettings } = props;
   const queryClient = useQueryClient();
   const { t } = useTranslation('common');
 
@@ -283,7 +284,7 @@ export const SettingPage = (props: ISettingPageProps) => {
 
           {rewardManage}
 
-          <CanarySettings setting={setting} />
+          {canarySettings ?? <CanarySettings setting={setting} />}
 
           {/* email config */}
           <div className="pb-6" ref={emailRef}>
diff --git a/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/AiFormWizard.tsx b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/AiFormWizard.tsx
index e0b5289845..a9238d05b9 100644
--- a/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/AiFormWizard.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/AiFormWizard.tsx
@@ -22,7 +22,12 @@ import { GatewayModelsStep } from './GatewayModelsStep';
 import { LLMApiConfigStep } from './LLMApiConfigStep';
 import type { IModelTestResult } from './LlmproviderManage';
 import { SetupStepCard } from './SetupStepCard';
-import { generateModelKeyList, generateGatewayModelKeyList, parseModelKey } from './utils';
+import {
+  generateModelKeyList,
+  generateGatewayModelKeyList,
+  normalizeLLMProviderModelConfigs,
+  parseModelKey,
+} from './utils';
 
 // Props to control whether to show pricing-related UI
 interface IAIConfigFormWizardProps {
@@ -125,20 +130,28 @@ export function AIConfigFormWizard({
     reset(defaultValues);
   }, [defaultValues, reset]);
 
+  const normalizeAiConfig = useCallback((data: NonNullable<ISettingVo['aiConfig']>) => {
+    return {
+      ...data,
+      llmProviders: data.llmProviders?.map(normalizeLLMProviderModelConfigs) ?? [],
+    };
+  }, []);
+
   const onSubmit = useCallback(
     (data: NonNullable<ISettingVo['aiConfig']>) => {
-      console.log('onSubmit', data);
-      setAiConfig(data);
+      const normalizedData = normalizeAiConfig(data);
+      setAiConfig(normalizedData);
       toast.success(t('admin.setting.ai.configUpdated'));
     },
-    [setAiConfig, t]
+    [normalizeAiConfig, setAiConfig, t]
   );
 
   const updateProviders = useCallback(
     (providers: LLMProvider[]) => {
-      form.setValue('llmProviders', providers);
+      const normalizedProviders = providers.map(normalizeLLMProviderModelConfigs);
+      form.setValue('llmProviders', normalizedProviders);
       form.trigger('llmProviders');
-      onSubmit(form.getValues());
+      onSubmit({ ...form.getValues(), llmProviders: normalizedProviders });
     },
     [form, onSubmit]
   );
@@ -175,7 +188,7 @@ export function AIConfigFormWizard({
       if (providerIndex === -1) return;
 
       const provider = currentProviders[providerIndex];
-      const updatedProvider = {
+      const updatedProvider = normalizeLLMProviderModelConfigs({
         ...provider,
         modelConfigs: {
           ...provider.modelConfigs,
@@ -186,15 +199,15 @@ export function AIConfigFormWizard({
             testedAt: Date.now(),
           },
         },
-      };
+      });
 
       const newProviders = [...currentProviders];
       newProviders[providerIndex] = updatedProvider;
 
       form.setValue('llmProviders', newProviders);
-      setAiConfig(form.getValues());
+      setAiConfig(normalizeAiConfig({ ...form.getValues(), llmProviders: newProviders }));
     },
-    [form, setAiConfig]
+    [form, normalizeAiConfig, setAiConfig]
   );
 
   const onToggleImageModel = useCallback(
@@ -209,26 +222,26 @@ export function AIConfigFormWizard({
       if (providerIndex === -1) return;
 
       const provider = currentProviders[providerIndex];
-      const updatedProvider = {
+      const currentConfig = provider.modelConfigs?.[model];
+      const updatedProvider = normalizeLLMProviderModelConfigs({
         ...provider,
         modelConfigs: {
           ...provider.modelConfigs,
           [model]: {
-            ...provider.modelConfigs?.[model],
+            ...currentConfig,
             isImageModel,
             ability: isImageModel ? undefined : provider.modelConfigs?.[model]?.ability,
-            imageAbility: isImageModel ? provider.modelConfigs?.[model]?.imageAbility : undefined,
           },
         },
-      };
+      });
 
       const newProviders = [...currentProviders];
       newProviders[providerIndex] = updatedProvider;
 
       form.setValue('llmProviders', newProviders);
-      setAiConfig(form.getValues());
+      setAiConfig(normalizeAiConfig({ ...form.getValues(), llmProviders: newProviders }));
     },
-    [form, setAiConfig]
+    [form, normalizeAiConfig, setAiConfig]
   );
 
   // Handler for updating gateway-related fields in aiConfig
@@ -241,9 +254,9 @@ export function AIConfigFormWizard({
         form.setValue(key as keyof typeof updates, value);
       });
       // Save to backend
-      setAiConfig(updatedConfig);
+      setAiConfig(normalizeAiConfig(updatedConfig));
     },
-    [form, setAiConfig]
+    [form, normalizeAiConfig, setAiConfig]
   );
 
   // Unified wizard view for both Cloud and EE
diff --git a/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/BatchTestModels.tsx b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/BatchTestModels.tsx
index 27bf135674..cdd62128b5 100644
--- a/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/BatchTestModels.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/BatchTestModels.tsx
@@ -11,6 +11,7 @@ import { Button, Progress } from '@teable/ui-lib/shadcn';
 import { useTranslation } from 'next-i18next';
 import { useState, useCallback, useRef, useEffect } from 'react';
 import type { IModelTestResult } from './LlmproviderManage';
+import { testImageModelCapability, TEXT_MODEL_TIMEOUT_MS, withTimeout } from './model-test-utils';
 import { generateModelKeyList, parseModelKey } from './utils';
 
 interface IBatchTestModelsProps {
@@ -33,16 +34,6 @@ interface IBatchTestModelsProps {
 }
 
 const CONCURRENCY = 5;
-const TEXT_MODEL_TIMEOUT_MS = 120000; // 2 minutes timeout for text models
-const IMAGE_MODEL_TIMEOUT_MS = 120000; // 2 minutes timeout for image models
-
-// Helper to wrap promise with timeout
-const withTimeout = <T,>(promise: Promise<T>, ms: number, errorMessage: string): Promise<T> => {
-  return Promise.race([
-    promise,
-    new Promise<T>((_, reject) => setTimeout(() => reject(new Error(errorMessage)), ms)),
-  ]);
-};
 
 export const BatchTestModels = ({
   providers,
@@ -170,71 +161,11 @@ export const BatchTestModels = ({
       modelKey: string,
       provider: Required<LLMProvider>
     ): Promise<Partial<IModelTestResult>> => {
-      try {
-        const { type, name, apiKey, baseUrl, models } = provider;
-
-        // Test image generation (text-to-image)
-        const generationResult = await withTimeout(
-          onTest({
-            type,
-            name,
-            apiKey,
-            baseUrl,
-            models,
-            modelKey,
-            testImageGeneration: true,
-          }),
-          IMAGE_MODEL_TIMEOUT_MS,
-          `Timeout after ${IMAGE_MODEL_TIMEOUT_MS / 1000}s`
-        );
-
-        // Test image-to-image if generation works
-        let imageToImage = false;
-        if (generationResult.success) {
-          try {
-            const i2iResult = await withTimeout(
-              onTest({
-                type,
-                name,
-                apiKey,
-                baseUrl,
-                models,
-                modelKey,
-                testImageGeneration: true,
-                testImageToImage: true,
-              }),
-              IMAGE_MODEL_TIMEOUT_MS,
-              `Timeout`
-            );
-            imageToImage = i2iResult.success;
-          } catch {
-            // Image-to-image not supported, that's ok
-          }
-        }
-
-        if (!generationResult.success) {
-          return {
-            status: 'failed',
-            error: generationResult.response || 'Image generation test failed',
-            isImageModel: true,
-          };
-        }
-
-        return {
-          status: 'success',
-          isImageModel: true,
-          imageAbility: {
-            generation: true,
-            imageToImage,
-          },
-        };
-      } catch (error) {
-        return {
-          status: 'failed',
-          isImageModel: true,
-          error: error instanceof Error ? error.message : 'Unknown error',
-        };
-      }
+      return testImageModelCapability({
+        modelKey,
+        provider,
+        onTest,
+      });
     },
     [onTest]
   );
diff --git a/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/LlmProviderForm.tsx b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/LlmProviderForm.tsx
index ed40795316..7337393711 100644
--- a/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/LlmProviderForm.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/LlmProviderForm.tsx
@@ -1,7 +1,12 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { zodResolver } from '@hookform/resolvers/zod';
 import { AlertCircle, Check, Loader2, Plus, X, Eye, Image, HelpCircle } from '@teable/icons';
-import { llmProviderSchema, LLMProviderType, chatModelAbilityType } from '@teable/openapi';
+import {
+  getImageModelTagsFromAbility,
+  llmProviderSchema,
+  LLMProviderType,
+  chatModelAbilityType,
+} from '@teable/openapi';
 import type {
   ITestLLMVo,
   ITestLLMRo,
@@ -42,6 +47,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useForm } from 'react-hook-form';
 import { useIsCloud } from '@/features/app/hooks/useIsCloud';
 import { LLM_PROVIDERS } from './constant';
+import { testImageModelCapability, TEXT_MODEL_TIMEOUT_MS, withTimeout } from './model-test-utils';
 
 const CUSTOM_MODEL_DOC_URL = 'https://help.teable.ai/en/basic/ai/custom-model';
 
@@ -61,18 +67,8 @@ interface IModelTestStatus {
   isImageModel?: boolean;
 }
 
-const TEXT_MODEL_TIMEOUT_MS = 120000; // 2 minutes timeout for text models
-const IMAGE_MODEL_TIMEOUT_MS = 120000; // 2 minutes timeout for image models
 const CONCURRENCY = 3; // Concurrent test count
 
-// Helper to wrap promise with timeout
-const withTimeout = <T,>(promise: Promise<T>, ms: number, errorMessage: string): Promise<T> => {
-  return Promise.race([
-    promise,
-    new Promise<T>((_, reject) => setTimeout(() => reject(new Error(errorMessage)), ms)),
-  ]);
-};
-
 type ErrorPattern = {
   keywords: string[];
   suggestion: string;
@@ -565,72 +561,11 @@ export const LLMProviderForm = ({
       if (!onTest) {
         return { status: 'failed', error: 'Test function not provided', isImageModel: true };
       }
-      try {
-        const { type, name, apiKey, baseUrl, models } = provider;
-        const modelKey = `${type}@${model}@${name}`;
-
-        // Test image generation (text-to-image)
-        const generationResult = await withTimeout(
-          onTest({
-            type,
-            name,
-            apiKey,
-            baseUrl,
-            models,
-            modelKey,
-            testImageGeneration: true,
-          }),
-          IMAGE_MODEL_TIMEOUT_MS,
-          `Timeout after ${IMAGE_MODEL_TIMEOUT_MS / 1000}s`
-        );
-
-        // Test image-to-image if generation works
-        let imageToImage = false;
-        if (generationResult.success) {
-          try {
-            const i2iResult = await withTimeout(
-              onTest({
-                type,
-                name,
-                apiKey,
-                baseUrl,
-                models,
-                modelKey,
-                testImageGeneration: true,
-                testImageToImage: true,
-              }),
-              IMAGE_MODEL_TIMEOUT_MS,
-              `Timeout`
-            );
-            imageToImage = i2iResult.success;
-          } catch {
-            // Image-to-image not supported, that's ok
-          }
-        }
-
-        if (!generationResult.success) {
-          return {
-            status: 'failed',
-            error: generationResult.response || 'Image generation test failed',
-            isImageModel: true,
-          };
-        }
-
-        return {
-          status: 'success',
-          isImageModel: true,
-          imageAbility: {
-            generation: true,
-            imageToImage,
-          },
-        };
-      } catch (error) {
-        return {
-          status: 'failed',
-          isImageModel: true,
-          error: error instanceof Error ? error.message : 'Unknown error',
-        };
-      }
+      return testImageModelCapability({
+        modelKey: `${provider.type}@${model}@${provider.name}`,
+        provider,
+        onTest,
+      });
     },
     [onTest]
   );
@@ -723,12 +658,14 @@ export const LLMProviderForm = ({
         successCount++;
         // Save test result to form's modelConfigs so it persists on submit
         const currentConfigs = form.getValues('modelConfigs') ?? {};
+        const tags = getImageModelTagsFromAbility(result.imageAbility, currentConfigs[model]?.tags);
         form.setValue('modelConfigs', {
           ...currentConfigs,
           [model]: {
             ...currentConfigs[model],
             ability: result.ability,
             imageAbility: result.imageAbility,
+            ...(result.imageAbility ? { tags } : {}),
             testedAt: Date.now(),
           },
         });
diff --git a/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/constant.ts b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/constant.ts
index d5cb4f32cd..74b41926a6 100644
--- a/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/constant.ts
+++ b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/constant.ts
@@ -32,6 +32,8 @@ import {
   Morph,
   Inception,
   Stealth,
+  Prodia,
+  Recraft,
 } from '@teable/icons';
 import type { GatewayModelProvider } from '@teable/openapi';
 import { LLMProviderType } from '@teable/openapi';
@@ -199,6 +201,8 @@ export const GATEWAY_PROVIDER_ICONS: Record<
   openai: Openai,
   perplexity: Perplexity,
   'prime-intellect': PrimeIntellect,
+  prodia: Prodia,
+  recraft: Recraft,
   stealth: Stealth,
   vercel: Vercel,
   voyage: Voyage,
diff --git a/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/model-test-utils.ts b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/model-test-utils.ts
new file mode 100644
index 0000000000..37cf239f59
--- /dev/null
+++ b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/model-test-utils.ts
@@ -0,0 +1,109 @@
+import type { IImageModelAbility, ITestLLMRo, ITestLLMVo, LLMProvider } from '@teable/openapi';
+import { supportsKnownImageInputForImageModel } from '@teable/openapi';
+import { parseModelKey } from './utils';
+
+export const TEXT_MODEL_TIMEOUT_MS = 120000;
+export const IMAGE_MODEL_TIMEOUT_MS = 120000;
+
+export const withTimeout = async <T>(
+  promise: Promise<T>,
+  ms: number,
+  errorMessage: string
+): Promise<T> => {
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    timeoutId = setTimeout(() => reject(new Error(errorMessage)), ms);
+  });
+
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+
+interface IImageModelTestResult {
+  status: 'success' | 'failed';
+  error?: string;
+  isImageModel: true;
+  imageAbility?: IImageModelAbility;
+}
+
+interface ITestImageModelCapabilityParams {
+  modelKey: string;
+  provider: Required<LLMProvider>;
+  onTest: (data: ITestLLMRo) => Promise<ITestLLMVo>;
+}
+
+export const testImageModelCapability = async ({
+  modelKey,
+  provider,
+  onTest,
+}: ITestImageModelCapabilityParams): Promise<IImageModelTestResult> => {
+  try {
+    const { type, name, apiKey, baseUrl, models } = provider;
+    const { model } = parseModelKey(modelKey);
+
+    const generationResult = await withTimeout(
+      onTest({
+        type,
+        name,
+        apiKey,
+        baseUrl,
+        models,
+        modelKey,
+        testImageGeneration: true,
+      }),
+      IMAGE_MODEL_TIMEOUT_MS,
+      `Timeout after ${IMAGE_MODEL_TIMEOUT_MS / 1000}s`
+    );
+
+    if (!generationResult.success) {
+      return {
+        status: 'failed',
+        error: generationResult.response || 'Image generation test failed',
+        isImageModel: true,
+      };
+    }
+
+    let imageToImage = supportsKnownImageInputForImageModel(type, model);
+    if (!imageToImage) {
+      try {
+        const i2iResult = await withTimeout(
+          onTest({
+            type,
+            name,
+            apiKey,
+            baseUrl,
+            models,
+            modelKey,
+            testImageGeneration: true,
+            testImageToImage: true,
+          }),
+          IMAGE_MODEL_TIMEOUT_MS,
+          'Timeout'
+        );
+        imageToImage = i2iResult.success;
+      } catch {
+        // Image-to-image support remains optional for unknown image models.
+      }
+    }
+
+    return {
+      status: 'success',
+      isImageModel: true,
+      imageAbility: {
+        generation: true,
+        imageToImage,
+      },
+    };
+  } catch (error) {
+    return {
+      status: 'failed',
+      isImageModel: true,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    };
+  }
+};
diff --git a/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/utils.spec.tsx b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/utils.spec.tsx
new file mode 100644
index 0000000000..59f506ff4d
--- /dev/null
+++ b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/utils.spec.tsx
@@ -0,0 +1,129 @@
+import type { LLMProvider } from '@teable/openapi';
+import { LLMProviderType } from '@teable/openapi';
+import { describe, expect, it } from 'vitest';
+import { normalizeLLMProviderModelConfigs } from './utils';
+
+describe('normalizeLLMProviderModelConfigs', () => {
+  it('removes stale hidden configs and backfills known OpenAI image abilities', () => {
+    const provider: LLMProvider = {
+      type: LLMProviderType.OPENAI,
+      name: 'teable',
+      apiKey: 'test',
+      models: 'gpt-image-1,gpt-image-1.5,gpt-image-2',
+      modelConfigs: {
+        'gpt-5.4': {
+          ability: {
+            image: true,
+          },
+          testedAt: 1,
+        },
+        'gpt-image-1': {
+          isImageModel: true,
+          testedAt: 2,
+        },
+        'gpt-image-1.5': {
+          isImageModel: true,
+          testedAt: 3,
+        },
+        'gpt-image-2': {
+          isImageModel: true,
+          imageAbility: {
+            generation: true,
+            imageToImage: true,
+          },
+          tags: ['image-generation', 'vision'],
+          testedAt: 4,
+        },
+      },
+    };
+
+    const normalized = normalizeLLMProviderModelConfigs(provider);
+
+    expect(Object.keys(normalized.modelConfigs ?? {})).toEqual([
+      'gpt-image-1',
+      'gpt-image-1.5',
+      'gpt-image-2',
+    ]);
+    expect(normalized.modelConfigs?.['gpt-image-1']?.imageAbility).toEqual({
+      generation: true,
+      imageToImage: true,
+    });
+    expect(normalized.modelConfigs?.['gpt-image-1']?.modelType).toBe('image');
+    expect(normalized.modelConfigs?.['gpt-image-1']?.tags).toEqual(['image-generation', 'vision']);
+    expect(normalized.modelConfigs?.['gpt-image-1.5']?.imageAbility).toEqual({
+      generation: true,
+      imageToImage: true,
+    });
+  });
+
+  it('does not infer image ability for OpenAI-compatible custom providers', () => {
+    const provider: LLMProvider = {
+      type: LLMProviderType.OPENAI_COMPATIBLE,
+      name: 'custom',
+      apiKey: 'test',
+      models: 'gpt-image-2',
+      modelConfigs: {
+        'gpt-image-2': {
+          isImageModel: true,
+        },
+      },
+    };
+
+    const normalized = normalizeLLMProviderModelConfigs(provider);
+
+    expect(normalized.modelConfigs?.['gpt-image-2']?.imageAbility).toBeUndefined();
+    expect(normalized.modelConfigs?.['gpt-image-2']?.tags).toBeUndefined();
+  });
+
+  it('cleans image ability tags when a model is no longer marked as an image model', () => {
+    const provider: LLMProvider = {
+      type: LLMProviderType.OPENAI,
+      name: 'teable',
+      apiKey: 'test',
+      models: 'gpt-image-2',
+      modelConfigs: {
+        'gpt-image-2': {
+          isImageModel: false,
+          modelType: 'image',
+          imageAbility: {
+            generation: true,
+            imageToImage: true,
+          },
+          tags: ['image-generation', 'vision', 'tool-use'],
+        },
+      },
+    };
+
+    const normalized = normalizeLLMProviderModelConfigs(provider);
+
+    expect(normalized.modelConfigs?.['gpt-image-2']?.imageAbility).toBeUndefined();
+    expect(normalized.modelConfigs?.['gpt-image-2']?.modelType).toBeUndefined();
+    expect(normalized.modelConfigs?.['gpt-image-2']?.tags).toEqual(['vision', 'tool-use']);
+  });
+
+  it('backfills model type for known Google image-generation language models', () => {
+    const provider: LLMProvider = {
+      type: LLMProviderType.GOOGLE,
+      name: 'google',
+      apiKey: 'test',
+      models: 'gemini-3-pro-image',
+      modelConfigs: {
+        'gemini-3-pro-image': {
+          isImageModel: true,
+        },
+      },
+    };
+
+    const normalized = normalizeLLMProviderModelConfigs(provider);
+
+    expect(normalized.modelConfigs?.['gemini-3-pro-image']?.modelType).toBe('language');
+    expect(normalized.modelConfigs?.['gemini-3-pro-image']?.imageAbility).toEqual({
+      generation: true,
+      imageToImage: true,
+    });
+    expect(normalized.modelConfigs?.['gemini-3-pro-image']?.tags).toEqual([
+      'image-generation',
+      'vision',
+    ]);
+  });
+});
diff --git a/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/utils.tsx b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/utils.tsx
index 7c7ab905cf..c2e27e6257 100644
--- a/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/utils.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/admin/setting/components/ai-config/utils.tsx
@@ -2,11 +2,17 @@ import { DeepThinking, Eye, ImageGeneration, Audio } from '@teable/icons';
 import type {
   IGatewayModel,
   IImageModelDefination,
+  IModelConfig,
   ISimpleLLMProvider,
   ITextModelDefination,
   LLMProvider,
 } from '@teable/openapi';
-import { LLMProviderType } from '@teable/openapi';
+import {
+  getImageModelTagsFromAbility,
+  getImageModelConfig,
+  getKnownImageModelAbility,
+  LLMProviderType,
+} from '@teable/openapi';
 import type { TFunction } from 'next-i18next';
 import type { ReactNode } from 'react';
 import { Trans } from 'react-i18next';
@@ -14,12 +20,81 @@ import { Trans } from 'react-i18next';
 // Fixed name for AI Gateway provider in modelKey
 export const AI_GATEWAY_PROVIDER_NAME = 'teable';
 
+export const parseProviderModels = (models: string | undefined): string[] =>
+  models
+    ?.split(',')
+    .map((model) => model.trim())
+    .filter(Boolean) ?? [];
+
+const compactModelConfig = (config: IModelConfig): IModelConfig =>
+  Object.fromEntries(
+    Object.entries(config).filter(([, value]) => value !== undefined)
+  ) as IModelConfig;
+
+const hasModelConfigValue = (config: IModelConfig): boolean => Object.keys(config).length > 0;
+
+const clearImageGenerationTag = (
+  tags: IModelConfig['tags'] | undefined
+): IModelConfig['tags'] | undefined => {
+  const nextTags = tags?.filter((tag) => tag !== 'image-generation');
+  return nextTags?.length ? nextTags : undefined;
+};
+
+export const normalizeLLMProviderModelConfigs = (provider: LLMProvider): LLMProvider => {
+  const models = parseProviderModels(provider.models);
+  const currentConfigs = provider.modelConfigs ?? {};
+  const modelConfigs = models.reduce<Record<string, IModelConfig>>((acc, model) => {
+    const currentConfig = currentConfigs[model];
+    if (!currentConfig) return acc;
+
+    if (!currentConfig.isImageModel) {
+      const nextConfig = compactModelConfig({
+        ...currentConfig,
+        imageAbility: undefined,
+        modelType: undefined,
+        tags: clearImageGenerationTag(currentConfig.tags),
+      });
+
+      if (hasModelConfigValue(nextConfig)) {
+        acc[model] = nextConfig;
+      }
+
+      return acc;
+    }
+
+    const imageAbility =
+      currentConfig.imageAbility ?? getKnownImageModelAbility(provider.type, model);
+    const knownImageModelConfig = getImageModelConfig(provider.type, model);
+    const tags = imageAbility
+      ? getImageModelTagsFromAbility(imageAbility, currentConfig.tags)
+      : currentConfig.tags;
+    const nextConfig = compactModelConfig({
+      ...currentConfig,
+      ability: undefined,
+      imageAbility,
+      modelType: currentConfig.modelType ?? knownImageModelConfig?.modelType,
+      tags,
+    });
+
+    if (hasModelConfigValue(nextConfig)) {
+      acc[model] = nextConfig;
+    }
+
+    return acc;
+  }, {});
+
+  return {
+    ...provider,
+    modelConfigs: Object.keys(modelConfigs).length ? modelConfigs : undefined,
+  };
+};
+
 export const generateModelKeyList = (llmProviders: ISimpleLLMProvider[] | LLMProvider[]) => {
   return llmProviders
     .map((provider) => {
       const { models, type, name, isInstance } = provider;
       const modelConfigs = 'modelConfigs' in provider ? provider.modelConfigs : undefined;
-      return models.split(',').map((model) => {
+      return parseProviderModels(models).map((model) => {
         const config = modelConfigs?.[model];
         return {
           modelKey: `${type}@${model}@${name}`,
diff --git a/apps/nextjs-app/src/features/app/blocks/base/base-side-bar/BaseNodeTree.tsx b/apps/nextjs-app/src/features/app/blocks/base/base-side-bar/BaseNodeTree.tsx
index b3d681406e..1c794a9ea1 100644
--- a/apps/nextjs-app/src/features/app/blocks/base/base-side-bar/BaseNodeTree.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/base/base-side-bar/BaseNodeTree.tsx
@@ -186,6 +186,7 @@ export const BaseNodeTree = (props: IBaseNodeTreeProps) => {
   const draggedItemsRef = useRef<ItemInstance<TreeItemData>[]>([]);
   const treeItemsRef = useRef(treeItems);
   const viewportRef = useRef<HTMLDivElement>(null);
+  const focusedNodeIdRef = useRef<string | null>(null);
   const [selectedItems, setSelectedItems] = useState<string[]>([]);
   const [expandedItemsMap, setExpandedItemsMap] = useLocalStorage<Record<string, string[]>>(
     LocalStorageKeys.BaseNodeTreeExpandedItems,
@@ -328,6 +329,7 @@ export const BaseNodeTree = (props: IBaseNodeTreeProps) => {
     getItemName: (item) => getNodeName(item.getItemData()),
     isItemFolder: (item) => item.getItemData().resourceType === BaseNodeResourceType.Folder,
     canReorder: true,
+    canDrag: () => !editingNodeId,
     canDrop: (items, target) => {
       // Basic validation
       if (editingNodeId || !canMoveNode || items.length !== 1) return false;
@@ -344,13 +346,15 @@ export const BaseNodeTree = (props: IBaseNodeTreeProps) => {
       }
 
       // === Folder items ===
+      const subtreeDepth = getMaxFolderSubtreeDepth(items[0].getId(), treeItemsRef.current);
+
       if (isReordering) {
-        // Reorder at level 0, 1: ✅ | Reorder at level >= 2: ❌
-        return target.dragLineLevel < maxFolderDepth;
+        return target.dragLineLevel + subtreeDepth < maxFolderDepth;
       }
 
-      // Drop into level 0 folder: ✅ | Drop into level 1+ folder or non-folder: ❌
-      return target.item.isFolder() && getItemLevel(target.item) < maxFolderDepth - 1;
+      return (
+        target.item.isFolder() && getItemLevel(target.item) + subtreeDepth < maxFolderDepth - 1
+      );
     },
     onDrop: handleDrop,
     onPrimaryAction: handlePrimaryAction,
@@ -447,41 +451,55 @@ export const BaseNodeTree = (props: IBaseNodeTreeProps) => {
     }
   }, [baseResource]);
 
-  useEffect(() => {
-    if (Object.keys(treeItems).length === 0) return;
+  const currentRouteNodeId = useMemo(() => {
     const nodes = Object.values(treeItems);
     const { resourceType } = baseResource;
-    const node = nodes.find(
-      (node) => node.resourceType === resourceType && node.resourceId === currentResourceId
+    return (
+      nodes.find(
+        (node) => node.resourceType === resourceType && node.resourceId === currentResourceId
+      )?.id ?? null
     );
-    if (!node) {
+  }, [treeItems, baseResource, currentResourceId]);
+
+  useEffect(() => {
+    if (Object.keys(treeItems).length === 0) return;
+    if (!currentRouteNodeId) {
       setSelectedItems([]);
       return;
     }
 
-    const parentIds = getAllParentIds(node.id);
+    const parentIds = getAllParentIds(currentRouteNodeId);
     if (parentIds.length > 0) {
       setExpandedItems((prev) => [...new Set([...(prev ?? []), ...parentIds])]);
     }
-    setSelectedItems([node.id]);
-  }, [
-    treeItems,
-    baseResource,
-    currentResourceId,
-    getAllParentIds,
-    setExpandedItems,
-    setSelectedItems,
-  ]);
+    setSelectedItems([currentRouteNodeId]);
+  }, [treeItems, currentRouteNodeId, getAllParentIds, setExpandedItems, setSelectedItems]);
 
   useEffect(() => {
-    if (selectedItems.length === 0) return;
     if (Object.keys(treeItems).length === 0) return;
-    const focusItem = tree.getItemInstance(selectedItems[0]);
-    if (focusItem) {
-      focusItem.setFocused();
+    if (selectedItems.length === 0) {
+      focusedNodeIdRef.current = null;
+      return;
+    }
+    const currentId = selectedItems[0];
+    if (focusedNodeIdRef.current === currentId) return;
+    const focusItem = tree.getItemInstance(currentId);
+    if (!focusItem) return;
+
+    focusItem.setFocused();
+    focusedNodeIdRef.current = currentId;
+
+    const draggedNodeId = draggedItemsRef.current[0]?.getId();
+    if (!draggedNodeId) {
       focusItem.scrollTo({ block: 'nearest', inline: 'nearest' });
+      return;
     }
-  }, [selectedItems, tree, treeItems]);
+
+    const isCurrentRouteNode = currentId === currentRouteNodeId;
+    if (draggedNodeId !== currentId || isCurrentRouteNode) {
+      draggedItemsRef.current = [];
+    }
+  }, [currentRouteNodeId, selectedItems, tree, treeItems]);
 
   useEffect(() => {
     if (!highlightedTableId || Object.keys(treeItems).length === 0) return;
@@ -738,9 +756,8 @@ export const BaseNodeTree = (props: IBaseNodeTreeProps) => {
                         <Input
                           ref={inputRef}
                           type="text"
-                          placeholder="name"
                           defaultValue={item.getItemName()}
-                          className="size-full cursor-text rounded-none"
+                          className="size-full cursor-text select-text rounded-none"
                           onKeyDown={(e) => {
                             if (e.key === 'Enter') {
                               const newVal = e.currentTarget.value;
@@ -943,6 +960,19 @@ const getItemLevel = (item: ItemInstance<TreeItemData>) => {
   return meta.level;
 };
 
+const getMaxFolderSubtreeDepth = (
+  itemId: string,
+  treeItems: Record<string, TreeItemData>
+): number => {
+  const item = treeItems[itemId];
+  if (!item?.children?.length) return 0;
+  const folderChildren = item.children.filter(
+    (childId) => treeItems[childId]?.resourceType === BaseNodeResourceType.Folder
+  );
+  if (folderChildren.length === 0) return 0;
+  return 1 + Math.max(...folderChildren.map((id) => getMaxFolderSubtreeDepth(id, treeItems)));
+};
+
 const checkCanCreateFolder = (item: ItemInstance<TreeItemData>, maxFolderDepth: number) => {
   const level = getItemLevel(item);
   return level < maxFolderDepth - 1;
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 6583b06246..eb9c060ad4 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
@@ -1,11 +1,18 @@
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 import { hasPermission } from '@teable/core';
 import { ChevronsLeft, ChevronDown, Database, HelpCircle, Pencil, Share2 } from '@teable/icons';
-import { CollaboratorType, getBaseList, getSharedBase, updateBase } from '@teable/openapi';
+import {
+  CollaboratorType,
+  getBaseList,
+  getSharedBase,
+  type IBaseV2StatusVo,
+  updateBase,
+} from '@teable/openapi';
 import { ReactQueryKeys } from '@teable/sdk/config';
 import { useBase } from '@teable/sdk/hooks';
 import { useIsReadOnlyPreview } from '@teable/sdk/hooks/use-is-readonly-preview';
 import {
+  Badge,
   cn,
   DropdownMenu,
   DropdownMenuItem,
@@ -15,6 +22,10 @@ import {
   DropdownMenuSubContent,
   DropdownMenuSubTrigger,
   Input,
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger,
   DropdownMenuSeparator,
 } from '@teable/ui-lib';
 import { ArrowLeft, Send } from 'lucide-react';
@@ -40,6 +51,8 @@ const BaseDropdownMenu = ({
   collaboratorType,
   currentBaseId,
   baseName,
+  isCanary,
+  v2Status,
   isBaseShared,
   disabled,
 }: {
@@ -52,6 +65,8 @@ const BaseDropdownMenu = ({
   collaboratorType?: CollaboratorType;
   currentBaseId: string;
   baseName: string;
+  isCanary?: boolean;
+  v2Status?: IBaseV2StatusVo;
   isBaseShared: boolean;
   disabled?: boolean;
 }) => {
@@ -59,6 +74,11 @@ const BaseDropdownMenu = ({
   const isCloud = useIsCloud();
   const [open, setOpen] = useState(false);
   const [shareOpen, setShareOpen] = useState(false);
+  const useV2 = v2Status?.useV2 ?? Boolean(isCanary);
+  const versionLabel = useV2 ? 'v2' : 'v1';
+  const versionTitle = v2Status?.reason
+    ? `${versionLabel.toUpperCase()}: ${v2Status.reason}`
+    : versionLabel.toUpperCase();
 
   const isSpaceCollaborator = collaboratorType === CollaboratorType.Space;
   const { data: spaceBases } = useQuery({
@@ -82,14 +102,29 @@ const BaseDropdownMenu = ({
           {children}
         </DropdownMenuTrigger>
         <DropdownMenuContent
-          className="min-w-[260px]"
+          className="relative min-w-[260px]"
           align="start"
           alignOffset={0}
           sideOffset={4}
           onClick={(e) => e.stopPropagation()}
         >
+          <TooltipProvider>
+            <Tooltip>
+              <TooltipTrigger asChild>
+                <span className="absolute right-3 top-2.5 z-10 inline-flex h-5 items-center">
+                  <Badge
+                    variant="secondary"
+                    className="h-5 rounded-sm bg-surface px-1.5 text-[10px] font-semibold uppercase leading-none text-muted-foreground"
+                  >
+                    {versionLabel}
+                  </Badge>
+                </span>
+              </TooltipTrigger>
+              <TooltipContent>{versionTitle}</TooltipContent>
+            </Tooltip>
+          </TooltipProvider>
           <DropdownMenuItem onClick={backSpace}>
-            <div className="flex w-full cursor-pointer items-center gap-2">
+            <div className="flex w-full cursor-pointer items-center gap-2 pr-10">
               <ArrowLeft className="size-4" />
               {t('common:actions.backToSpace')}
             </div>
@@ -303,12 +338,14 @@ export const BaseSidebarHeaderLeft = ({ creditUsage }: { creditUsage?: React.Rea
             collaboratorType={base.collaboratorType}
             currentBaseId={base.id}
             baseName={base.name}
+            isCanary={base.isCanary}
+            v2Status={base.v2Status}
             isBaseShared={isBaseShared}
             disabled={isReadOnlyPreview}
           >
             <div
               className={cn(
-                'flex h-7 max-w-full overflow-hidden px-2 py-1 hover:bg-accent hover:cursor-pointer rounded-md items-center gap-2',
+                'flex h-7 max-w-full overflow-hidden px-2 py-1 hover:bg-accent hover:cursor-pointer rounded-md items-center gap-2 relative',
                 {
                   'cursor-default': isReadOnlyPreview,
                 }
diff --git a/apps/nextjs-app/src/features/app/blocks/base/base-side-bar/QuickAction.tsx b/apps/nextjs-app/src/features/app/blocks/base/base-side-bar/QuickAction.tsx
index 7dc81102ff..b0d0806ea0 100644
--- a/apps/nextjs-app/src/features/app/blocks/base/base-side-bar/QuickAction.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/base/base-side-bar/QuickAction.tsx
@@ -200,13 +200,13 @@ export const QuickAction = () => {
                   setOpen(false);
                   setting.setOpen(true);
                 }}
-                value={t('common:settings.personal.title')}
-                keywords={[t('common:settings.personal.title')]}
+                value={t('common:settings.allSetting')}
+                keywords={[t('common:settings.allSetting')]}
               >
                 <div className="flex size-4 shrink-0 items-center justify-center text-muted-foreground">
                   <Settings className="size-full" />
                 </div>
-                <span>{t('common:settings.personal.title')}</span>
+                <span>{t('common:settings.allSetting')}</span>
               </CommandItem>
             </CommandGroup>
           )}
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 18f517c5c9..f133229292 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
@@ -37,6 +37,7 @@ import {
   CheckCircle2,
   Clock,
   Columns3,
+  ExternalLink,
   Info,
   Loader2,
   RefreshCcw,
@@ -44,6 +45,7 @@ import {
   Wrench,
   XCircle,
 } from 'lucide-react';
+import Link from 'next/link';
 import { useTranslation } from 'next-i18next';
 import { useEffect, useMemo, useState, type ComponentType } from 'react';
 import {
@@ -54,6 +56,7 @@ import {
   getLocalizedRuleDescription,
   getGroupDisplayName,
   getGroupDisplayState,
+  hasExecutableRepairStatements,
   integrityFilterStatuses,
   getPhaseText,
   translateIntegrityMessage,
@@ -227,6 +230,14 @@ const inferFieldTypeFromGroup = (group: ResultGroup) => {
 type ManualRepairSchema = NonNullable<NonNullable<IntegrityResult['repair']>['manualRepairSchema']>;
 type ManualRepairProperty = ManualRepairSchema['properties'][string];
 type ManualRepairValues = Record<string, string | boolean>;
+type RepairRuleHandler = (
+  result: IntegrityResult,
+  manualRepairValues?: ManualRepairValues
+) => Promise<boolean>;
+type RepairRulePreviewHandler = (
+  result: IntegrityResult,
+  manualRepairValues?: ManualRepairValues
+) => Promise<IntegrityResult[]>;
 
 const getManualRepairDefaultValues = (manualRepairSchema?: ManualRepairSchema) => {
   return Object.fromEntries(
@@ -436,49 +447,335 @@ const ManualRepairDialog = ({
   );
 };
 
+const getPreviewResults = (results: IntegrityResult[]) =>
+  results.filter((result) => result.status !== 'running' && result.status !== 'pending');
+
+const canPreviewRepairResult = (result: IntegrityResult) =>
+  result.status === 'error' || result.status === 'warn' || result.status === 'skipped';
+
+const getRuleRepairTooltipText = (
+  t: Translate,
+  result: IntegrityResult,
+  canPreview: boolean,
+  reason?: string,
+  description?: string
+) =>
+  reason ||
+  description ||
+  (result.repair || canPreview
+    ? t('table:table.integrity.v2.repairPreviewTooltip')
+    : t('table:table.integrity.v2.repairUnavailable'));
+
+const getRepairPreviewDisabledReason = (
+  t: Translate,
+  result: IntegrityResult,
+  onPreviewRepairRule?: RepairRulePreviewHandler
+) => {
+  if (!canPreviewRepairResult(result)) {
+    return t('table:table.integrity.v2.repairPreviewUnavailableStatus');
+  }
+
+  if (!onPreviewRepairRule) {
+    return t('table:table.integrity.v2.repairUnavailable');
+  }
+
+  if (!result.tableId) {
+    return t('table:table.integrity.v2.repairPreviewMissingTable');
+  }
+
+  return undefined;
+};
+
+const formatRepairParameters = (parameters?: ReadonlyArray<unknown>) => {
+  if (!parameters?.length) {
+    return undefined;
+  }
+
+  return JSON.stringify(parameters, null, 2);
+};
+
+const RepairRulePreviewDialog = ({
+  result,
+  open,
+  dryRunResults,
+  isSubmitting,
+  canConfirm,
+  onOpenChange,
+  onConfirm,
+}: {
+  result: IntegrityResult;
+  open: boolean;
+  dryRunResults: IntegrityResult[];
+  isSubmitting: boolean;
+  canConfirm: boolean;
+  onOpenChange: (open: boolean) => void;
+  onConfirm: () => void;
+}) => {
+  const { t } = useTranslation(['table', 'common']);
+  const previewResults = getPreviewResults(dryRunResults);
+  const displayResults = previewResults.length ? previewResults : [result];
+  const statements = displayResults.flatMap(
+    (previewResult) => previewResult.details?.statements || []
+  );
+  const canExecute = canConfirm && statements.length > 0;
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="flex max-h-[82vh] max-w-3xl flex-col">
+        <DialogHeader>
+          <DialogTitle>{t('table:table.integrity.v2.repairPreviewTitle')}</DialogTitle>
+          <DialogDescription>
+            {t('table:table.integrity.v2.repairPreviewDescription')}
+          </DialogDescription>
+        </DialogHeader>
+
+        <div className="min-h-0 space-y-4 overflow-y-auto pr-1">
+          {displayResults.map((previewResult) => {
+            const localizedMessage = getLocalizedResultMessage(t as Translate, previewResult);
+            const localizedRuleName = getLocalizedRuleDescription(t as Translate, previewResult);
+            const repairReason = getLocalizedRepairReason(t as Translate, previewResult);
+            const repairDescription = getLocalizedRepairDescription(t as Translate, previewResult);
+            const localizedMissing = getLocalizedDetailItems(
+              t as Translate,
+              previewResult.details?.missingItems || previewResult.details?.missing
+            );
+            const localizedExtra = getLocalizedDetailItems(
+              t as Translate,
+              previewResult.details?.extraItems || previewResult.details?.extra
+            );
+
+            return (
+              <div
+                key={previewResult.id}
+                className="rounded-lg border border-border bg-muted/20 p-4 text-sm"
+              >
+                <div className="mb-3 flex flex-wrap items-center gap-2">
+                  <StatusIcon status={previewResult.status} />
+                  <span className="font-medium text-foreground">{localizedRuleName}</span>
+                  <StatusBadge status={previewResult.status} />
+                </div>
+
+                <div className="space-y-3">
+                  <div>
+                    <div className="text-xs font-medium uppercase text-muted-foreground">
+                      {t('table:table.integrity.v2.repairPreviewWhat')}
+                    </div>
+                    <div className="mt-1 text-foreground">
+                      {t('table:table.integrity.v2.repairPreviewTarget', {
+                        fieldName: previewResult.fieldName,
+                        ruleName: localizedRuleName,
+                      })}
+                    </div>
+                    {localizedMessage ? (
+                      <div className="mt-1 text-muted-foreground">{localizedMessage}</div>
+                    ) : null}
+                    {localizedMissing?.length ? (
+                      <div className="mt-1 text-muted-foreground">
+                        {t('table:table.integrity.v2.detailsMissing', {
+                          details: localizedMissing.join(', '),
+                        })}
+                      </div>
+                    ) : null}
+                    {localizedExtra?.length ? (
+                      <div className="mt-1 text-muted-foreground">
+                        {t('table:table.integrity.v2.detailsExtra', {
+                          details: localizedExtra.join(', '),
+                        })}
+                      </div>
+                    ) : null}
+                  </div>
+
+                  <div>
+                    <div className="text-xs font-medium uppercase text-muted-foreground">
+                      {t('table:table.integrity.v2.repairPreviewPrinciple')}
+                    </div>
+                    <div className="mt-1 text-foreground">
+                      {repairDescription ||
+                        repairReason ||
+                        t('table:table.integrity.v2.repairPreviewNoPrinciple')}
+                    </div>
+                  </div>
+                </div>
+              </div>
+            );
+          })}
+
+          <div className="rounded-lg border border-border bg-background p-4">
+            <div className="mb-3 text-sm font-medium text-foreground">
+              {t('table:table.integrity.v2.repairPreviewSql')}
+            </div>
+            {statements.length ? (
+              <div className="space-y-3">
+                {statements.map((statement, index) => {
+                  const parameters = formatRepairParameters(statement.parameters);
+
+                  return (
+                    <div key={`${statement.sql}:${index}`} className="space-y-2">
+                      <pre className="max-h-64 overflow-auto rounded-md bg-slate-950 p-3 text-xs leading-relaxed text-slate-50">
+                        <code>{statement.sql}</code>
+                      </pre>
+                      {parameters ? (
+                        <pre className="max-h-32 overflow-auto rounded-md bg-muted p-3 text-xs leading-relaxed text-muted-foreground">
+                          <code>
+                            {t('table:table.integrity.v2.repairPreviewParameters')}
+                            {': '}
+                            {parameters}
+                          </code>
+                        </pre>
+                      ) : null}
+                    </div>
+                  );
+                })}
+              </div>
+            ) : (
+              <div className="text-sm text-muted-foreground">
+                {t('table:table.integrity.v2.repairPreviewNoSql')}
+              </div>
+            )}
+          </div>
+
+          {!canExecute ? (
+            <Alert>
+              <AlertDescription>
+                {statements.length
+                  ? t('table:table.integrity.v2.repairPreviewCannotConfirm')
+                  : t('table:table.integrity.v2.repairPreviewNoSql')}
+              </AlertDescription>
+            </Alert>
+          ) : null}
+        </div>
+
+        <DialogFooter>
+          <Button type="button" variant="secondary" onClick={() => onOpenChange(false)}>
+            {t('common:actions.cancel')}
+          </Button>
+          <Button type="button" onClick={onConfirm} disabled={isSubmitting || !canExecute}>
+            {isSubmitting ? <Loader2 className="mr-2 size-4 animate-spin" /> : null}
+            {t('table:table.integrity.v2.repairPreviewConfirm')}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+};
+
+const ManualRuleRepairAction = ({
+  result,
+  reason,
+  description,
+  onRepairRule,
+}: {
+  result: IntegrityResult;
+  reason?: string;
+  description?: string;
+  onRepairRule: RepairRuleHandler;
+}) => {
+  const { t } = useTranslation(['table']);
+
+  return (
+    <TooltipProvider>
+      <Tooltip>
+        <TooltipTrigger asChild>
+          <span className="inline-flex">
+            <ManualRepairDialog
+              result={result}
+              triggerLabel={t('table:table.integrity.v2.manual')}
+              onSubmit={onRepairRule}
+            />
+          </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>
+  );
+};
+
 const RuleRepairAction = ({
   result,
   isRunning,
   isActive,
   onRepairRule,
+  onPreviewRepairRule,
 }: {
   result: IntegrityResult;
   isRunning: boolean;
   isActive: boolean;
-  onRepairRule?: (
-    result: IntegrityResult,
-    manualRepairValues?: ManualRepairValues
-  ) => Promise<boolean>;
+  onRepairRule?: RepairRuleHandler;
+  onPreviewRepairRule?: RepairRulePreviewHandler;
 }) => {
   const { t } = useTranslation(['table']);
-  const canRepair = Boolean(result.repair?.available && result.tableId && result.fieldId);
+  const previewDisabledReason = getRepairPreviewDisabledReason(
+    t as Translate,
+    result,
+    onPreviewRepairRule
+  );
+  const canRepair = Boolean(
+    result.repair?.available && result.tableId && result.fieldId && onRepairRule
+  );
   const reason = getLocalizedRepairReason(t as Translate, result);
   const description = getLocalizedRepairDescription(t as Translate, result);
+  const tooltipReason = getRuleRepairTooltipText(
+    t as Translate,
+    result,
+    canShowPreview,
+    reason,
+    description
+  );
+  const [previewOpen, setPreviewOpen] = useState(false);
+  const [dryRunResults, setDryRunResults] = useState<IntegrityResult[]>([]);
+  const [isPreviewLoading, setIsPreviewLoading] = useState(false);
+  const [isConfirming, setIsConfirming] = useState(false);
+  const canConfirmRepair = canRepair || hasExecutableRepairStatements(dryRunResults);
 
-  if (!result.repair) {
+  if (!canPreviewRepairResult(result) || (!onRepairRule && !onPreviewRepairRule)) {
     return null;
   }
 
+  const handlePreview = async () => {
+    if (!onPreviewRepairRule) {
+      void onRepairRule?.(result);
+      return;
+    }
+
+    setIsPreviewLoading(true);
+    setDryRunResults([]);
+    try {
+      const nextDryRunResults = await onPreviewRepairRule(result);
+      setDryRunResults(nextDryRunResults);
+      setPreviewOpen(true);
+    } finally {
+      setIsPreviewLoading(false);
+    }
+  };
+
+  const handleConfirm = async () => {
+    if (!canConfirmRepair || !onRepairRule) {
+      return;
+    }
+
+    setIsConfirming(true);
+    try {
+      const repaired = await onRepairRule(result);
+      if (repaired) {
+        setPreviewOpen(false);
+      }
+    } finally {
+      setIsConfirming(false);
+    }
+  };
+
   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')}
-                  onSubmit={onRepairRule}
-                />
-              </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>
+      {result.repair?.mode === 'manual' && onRepairRule ? (
+        <ManualRuleRepairAction
+          result={result}
+          reason={reason}
+          description={description}
+          onRepairRule={onRepairRule}
+        />
       ) : null}
       <TooltipProvider>
         <Tooltip>
@@ -488,10 +785,10 @@ const RuleRepairAction = ({
                 size="xs"
                 variant="outline"
                 className="h-7 px-2 text-xs"
-                disabled={!canRepair || isRunning}
-                onClick={() => void onRepairRule?.(result)}
+                disabled={Boolean(previewDisabledReason) || isPreviewLoading}
+                onClick={() => void handlePreview()}
               >
-                {isRunning && isActive ? (
+                {(isRunning && isActive) || isPreviewLoading ? (
                   <Loader2 className="mr-1 size-3.5 animate-spin" />
                 ) : (
                   <Wrench className="mr-1 size-3.5" />
@@ -500,14 +797,23 @@ const RuleRepairAction = ({
               </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}
+          <TooltipContent className="max-w-xs whitespace-normal">
+            <div>{previewDisabledReason || tooltipReason}</div>
+            {!previewDisabledReason && reason && description ? (
+              <div className="mt-1 opacity-80">{description}</div>
+            ) : null}
+          </TooltipContent>
         </Tooltip>
       </TooltipProvider>
+      <RepairRulePreviewDialog
+        result={result}
+        open={previewOpen}
+        dryRunResults={dryRunResults}
+        isSubmitting={isConfirming}
+        canConfirm={canConfirmRepair}
+        onOpenChange={setPreviewOpen}
+        onConfirm={() => void handleConfirm()}
+      />
     </div>
   );
 };
@@ -559,14 +865,13 @@ const RuleResultItem = ({
   isRunning,
   isActive,
   onRepairRule,
+  onPreviewRepairRule,
 }: {
   result: IntegrityResult;
   isRunning: boolean;
   isActive: boolean;
-  onRepairRule?: (
-    result: IntegrityResult,
-    manualRepairValues?: ManualRepairValues
-  ) => Promise<boolean>;
+  onRepairRule?: RepairRuleHandler;
+  onPreviewRepairRule?: RepairRulePreviewHandler;
 }) => {
   const { t } = useTranslation(['table']);
   const localizedMessage = getLocalizedResultMessage(t as Translate, result);
@@ -609,6 +914,7 @@ const RuleResultItem = ({
           isRunning={isRunning}
           isActive={isActive}
           onRepairRule={onRepairRule}
+          onPreviewRepairRule={onPreviewRepairRule}
         />
       </div>
       {shouldShowMessage ? (
@@ -885,15 +1191,14 @@ const IntegrityGroupCard = ({
   isRunning,
   activeRepairResultId,
   onRepairRule,
+  onPreviewRepairRule,
   nested = false,
 }: {
   group: ResultGroup;
   isRunning: boolean;
   activeRepairResultId?: string | null;
-  onRepairRule?: (
-    result: IntegrityResult,
-    manualRepairValues?: ManualRepairValues
-  ) => Promise<boolean>;
+  onRepairRule?: RepairRuleHandler;
+  onPreviewRepairRule?: RepairRulePreviewHandler;
   nested?: boolean;
 }) => {
   const { t } = useTranslation(['table']);
@@ -943,6 +1248,7 @@ const IntegrityGroupCard = ({
             isRunning={isRunning}
             isActive={activeRepairResultId === result.id}
             onRepairRule={onRepairRule}
+            onPreviewRepairRule={onPreviewRepairRule}
           />
         ))}
       </div>
@@ -952,19 +1258,25 @@ const IntegrityGroupCard = ({
 
 const IntegrityTableCard = ({
   group,
+  baseId,
   isRunning,
   activeRepairResultId,
   onRepairRule,
+  onPreviewRepairRule,
 }: {
   group: TableResultGroup;
+  baseId?: string;
   isRunning: boolean;
   activeRepairResultId?: string | null;
-  onRepairRule?: (
-    result: IntegrityResult,
-    manualRepairValues?: ManualRepairValues
-  ) => Promise<boolean>;
+  onRepairRule?: RepairRuleHandler;
+  onPreviewRepairRule?: RepairRulePreviewHandler;
 }) => {
   const displayState = getGroupDisplayState(group.results);
+  const tableHref =
+    (group.baseId || baseId) && group.tableId
+      ? `/base/${group.baseId || baseId}/table/${group.tableId}`
+      : undefined;
+  const tableLabel = group.tableName || group.tableId;
 
   return (
     <section className="rounded-xl border border-border bg-background">
@@ -972,9 +1284,17 @@ const IntegrityTableCard = ({
         <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>
+            {tableHref ? (
+              <Link
+                href={tableHref}
+                className="inline-flex max-w-full items-center gap-1.5 text-sm font-semibold text-slate-950 underline-offset-4 hover:text-primary hover:underline"
+              >
+                <span className="truncate">{tableLabel}</span>
+                <ExternalLink className="size-3.5 shrink-0 text-slate-500" />
+              </Link>
+            ) : (
+              <div className="truncate text-sm font-semibold text-slate-950">{tableLabel}</div>
+            )}
             {group.tableId ? (
               <div className="truncate font-mono text-xs text-slate-500">{group.tableId}</div>
             ) : null}
@@ -991,6 +1311,7 @@ const IntegrityTableCard = ({
             isRunning={isRunning}
             activeRepairResultId={activeRepairResultId}
             onRepairRule={onRepairRule}
+            onPreviewRepairRule={onPreviewRepairRule}
             nested
           />
         ))}
@@ -1001,6 +1322,7 @@ const IntegrityTableCard = ({
 
 export const IntegrityResultsPanel = ({
   scope,
+  baseId,
   tableGroups,
   groupedResults,
   hasRun,
@@ -1010,8 +1332,10 @@ export const IntegrityResultsPanel = ({
   hasFilteredOutAll,
   activeRepairResultId,
   onRepairRule,
+  onPreviewRepairRule,
 }: {
   scope: IntegrityScope;
+  baseId?: string;
   tableGroups: TableResultGroup[];
   groupedResults: ResultGroup[];
   hasRun: boolean;
@@ -1020,10 +1344,8 @@ export const IntegrityResultsPanel = ({
   hasTarget: boolean;
   hasFilteredOutAll: boolean;
   activeRepairResultId?: string | null;
-  onRepairRule?: (
-    result: IntegrityResult,
-    manualRepairValues?: ManualRepairValues
-  ) => Promise<boolean>;
+  onRepairRule?: RepairRuleHandler;
+  onPreviewRepairRule?: RepairRulePreviewHandler;
 }) => {
   const { t } = useTranslation(['table']);
   const runningText = getPhaseText(t as Translate, phase, 'running');
@@ -1074,9 +1396,11 @@ export const IntegrityResultsPanel = ({
           <IntegrityTableCard
             key={group.tableId || group.tableName}
             group={group}
+            baseId={baseId}
             isRunning={isRunning}
             activeRepairResultId={activeRepairResultId}
             onRepairRule={onRepairRule}
+            onPreviewRepairRule={onPreviewRepairRule}
           />
         ))}
       </div>
@@ -1095,6 +1419,7 @@ export const IntegrityResultsPanel = ({
               isRunning={isRunning}
               activeRepairResultId={activeRepairResultId}
               onRepairRule={onRepairRule}
+              onPreviewRepairRule={onPreviewRepairRule}
               nested
             />
           ))}
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 fed4e5c00b..d744d861e0 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
@@ -234,6 +234,58 @@ export const IntegrityV2Dialog = ({
     [stopStream, t]
   );
 
+  const runRuleRepairDryRun = useCallback(
+    async (result: IntegrityResult, manualRepairValues?: ManualRepairValues) => {
+      if (!result.tableId) {
+        return [];
+      }
+
+      stopStream();
+      const controller = new AbortController();
+      abortRef.current = controller;
+
+      setIsRunning(true);
+      setActiveRepairResultId(result.id);
+      setStreamError(null);
+
+      const dryRunResults: IntegrityResult[] = [];
+
+      try {
+        await streamV2TableSchemaIntegrityRepair(
+          result.tableId,
+          {
+            fieldId: result.fieldId || undefined,
+            ruleId: result.fieldId ? result.ruleId : undefined,
+            dryRun: true,
+            targetStatuses: ['warn', 'error'],
+            manualRepairValues,
+          },
+          {
+            signal: controller.signal,
+            onResult: (nextResult) => {
+              dryRunResults.push(nextResult);
+            },
+          }
+        );
+      } 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);
+        }
+      }
+
+      return dryRunResults;
+    },
+    [stopStream, t]
+  );
+
   useEffect(() => {
     if (!open) {
       stopStream();
@@ -337,6 +389,7 @@ export const IntegrityV2Dialog = ({
         <ScrollArea className="min-h-0 flex-1 px-6 py-4">
           <IntegrityResultsPanel
             scope={scope}
+            baseId={baseId}
             tableGroups={tableGroups}
             groupedResults={groupedResults}
             hasRun={hasRun}
@@ -346,6 +399,7 @@ export const IntegrityV2Dialog = ({
             hasFilteredOutAll={hasFilteredOutAll}
             activeRepairResultId={activeRepairResultId}
             onRepairRule={runRuleRepair}
+            onPreviewRepairRule={runRuleRepairDryRun}
           />
         </ScrollArea>
 
diff --git a/apps/nextjs-app/src/features/app/blocks/design/components/integrityV2Utils.spec.ts b/apps/nextjs-app/src/features/app/blocks/design/components/integrityV2Utils.spec.ts
new file mode 100644
index 0000000000..5a96e418b0
--- /dev/null
+++ b/apps/nextjs-app/src/features/app/blocks/design/components/integrityV2Utils.spec.ts
@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest';
+
+import { hasExecutableRepairStatements, type IntegrityResult } from './integrityV2Utils';
+
+const createResult = (
+  statements?: NonNullable<IntegrityResult['details']>['statements']
+): IntegrityResult => ({
+  id: 'tbl1:fld1:junction_unique:fld1',
+  baseId: 'bse1',
+  tableId: 'tbl1',
+  tableName: 'Table',
+  fieldId: 'fld1',
+  fieldName: 'Link',
+  ruleId: 'junction_unique:fld1',
+  ruleDescription: 'Junction table unique constraint',
+  status: 'success',
+  message: 'Dry run: 1 statements ready',
+  details: statements ? { statements } : undefined,
+  required: false,
+  timestamp: 1,
+});
+
+describe('hasExecutableRepairStatements', () => {
+  it('returns true when dry-run results include executable SQL', () => {
+    expect(
+      hasExecutableRepairStatements([
+        createResult([
+          {
+            sql: 'alter table "bse1"."junction" add constraint "uniq" unique ("a", "b")',
+            parameters: [],
+          },
+        ]),
+      ])
+    ).toBe(true);
+  });
+
+  it('returns false when dry-run results do not include executable SQL', () => {
+    expect(hasExecutableRepairStatements([createResult()])).toBe(false);
+  });
+});
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 37d7a16924..5a3c3f2946 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
@@ -30,6 +30,7 @@ export type ResultGroup = {
 };
 
 export type TableResultGroup = {
+  baseId: string;
   tableId: string;
   tableName: string;
   results: IntegrityResult[];
@@ -190,7 +191,7 @@ export const groupResultsByTable = (results: IntegrityResult[]): TableResultGrou
   const groups = new Map<string, IntegrityResult[]>();
 
   for (const result of results) {
-    const key = result.tableId || '__unknown_table__';
+    const key = `${result.baseId || '__unknown_base__'}:${result.tableId || '__unknown_table__'}`;
     const existing = groups.get(key);
 
     if (existing) {
@@ -201,8 +202,9 @@ export const groupResultsByTable = (results: IntegrityResult[]): TableResultGrou
     groups.set(key, [result]);
   }
 
-  return Array.from(groups.entries()).map(([tableId, tableResults]) => ({
-    tableId: tableId === '__unknown_table__' ? '' : tableId,
+  return Array.from(groups.values()).map((tableResults) => ({
+    baseId: tableResults[0]?.baseId || '',
+    tableId: tableResults[0]?.tableId || '',
     tableName: tableResults[0]?.tableName || '',
     results: tableResults,
     groups: groupResults(tableResults),
@@ -480,3 +482,7 @@ export const getLocalizedRepairReason = (t: Translate, result: IntegrityResult)
 export const getLocalizedRepairDescription = (t: Translate, result: IntegrityResult) => {
   return translateIntegrityMessage(t, result.repair?.description);
 };
+
+export const hasExecutableRepairStatements = (results: ReadonlyArray<IntegrityResult>) => {
+  return results.some((result) => Boolean(result.details?.statements?.length));
+};
diff --git a/apps/nextjs-app/src/features/app/blocks/setting/access-token/AccessTokenList.tsx b/apps/nextjs-app/src/features/app/blocks/setting/access-token/AccessTokenList.tsx
index 09a631b7c1..4405228bd7 100644
--- a/apps/nextjs-app/src/features/app/blocks/setting/access-token/AccessTokenList.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/setting/access-token/AccessTokenList.tsx
@@ -130,7 +130,7 @@ export const AccessTokenList = (props: IAccessTokenListProps) => {
                   <TableCell title={scopes.join('; ')}>
                     {scopes
                       .slice(0, 2)
-                      .map((action) => actionStaticMap[action as Action].description)
+                      .map((action) => actionStaticMap[action as Action]?.description ?? action)
                       .join('; ')}
                     {scopesMoreLen ? ` ${t('token:moreScopes', { len: scopesMoreLen })}` : ''}
                   </TableCell>
diff --git a/apps/nextjs-app/src/features/app/blocks/share/view/component/grid/GridViewBase.tsx b/apps/nextjs-app/src/features/app/blocks/share/view/component/grid/GridViewBase.tsx
index 966678c501..e740f3ba55 100644
--- a/apps/nextjs-app/src/features/app/blocks/share/view/component/grid/GridViewBase.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/share/view/component/grid/GridViewBase.tsx
@@ -88,7 +88,12 @@ export const GridViewBase = (props: IGridViewProps) => {
   const isTouchDevice = useIsTouchDevice();
   const { setSelection, openStatisticMenu, openGroupHeaderMenu, openHeaderMenu } =
     useGridViewStore();
-  const { columns: originalColumns, cellValue2GridDisplay } = useGridColumns();
+  const { setGridRef, searchCursor, highlightedFieldId } = useGridSearchStore();
+  const { columns: originalColumns, cellValue2GridDisplay } = useGridColumns(
+    undefined,
+    undefined,
+    highlightedFieldId
+  );
   const { columns, onColumnResize } = useGridColumnResize(originalColumns);
   const { columnStatistics } = useGridColumnStatistics(columns);
   const { onColumnOrdered } = useGridColumnOrder();
@@ -97,7 +102,6 @@ export const GridViewBase = (props: IGridViewProps) => {
   const allFields = useFields({ withHidden: true });
   const customIcons = useGridIcons();
   const { openTooltip, closeTooltip } = useGridTooltipStore();
-  const { setGridRef, searchCursor } = useGridSearchStore();
   const buttonClickStatusHook = useButtonClickStatus(tableId, shareId);
 
   const prepare = isHydrated && view && columns.length;
diff --git a/apps/nextjs-app/src/features/app/blocks/space-setting/SpaceInnerSettingModal.tsx b/apps/nextjs-app/src/features/app/blocks/space-setting/SpaceInnerSettingModal.tsx
index f609e72203..9099779632 100644
--- a/apps/nextjs-app/src/features/app/blocks/space-setting/SpaceInnerSettingModal.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/space-setting/SpaceInnerSettingModal.tsx
@@ -1,42 +1,28 @@
+import { Dialog, DialogContent, DialogTrigger } from '@teable/ui-lib/shadcn';
+import { useCallback, useEffect, useState } from 'react';
 import {
-  Dialog,
-  DialogContent,
-  DialogTrigger,
-  Tabs,
-  TabsContent,
-  TabsList,
-  TabsTrigger,
-} from '@teable/ui-lib/shadcn';
-import { Settings, Users } from 'lucide-react';
-import { useTranslation } from 'next-i18next';
-import { useCallback, useEffect, useMemo, useState } from 'react';
-import { spaceConfig } from '@/features/i18n/space.config';
-import { CollaboratorPage } from './collaborator';
-import { GeneralPage } from './general';
+  UnifiedSettingDialogContent,
+  type UnifiedSettingTab,
+} from '@/features/app/components/setting/UnifiedSettingDialogContent';
+import { SpaceSettingTab } from './types';
 
 interface ISpaceInnerSettingModalProps {
   open?: boolean;
   setOpen?: (open: boolean) => void;
-  defaultTab?: SettingTab;
+  defaultTab?: SpaceSettingTab;
   children: React.ReactNode;
 }
 
-export enum SettingTab {
-  General = 'general',
-  Collaborator = 'collaborator',
-  Plan = 'plan',
-}
+export { SpaceSettingTab as SettingTab };
 
 export const SpaceInnerSettingModal = (props: ISpaceInnerSettingModalProps) => {
   const {
     children,
     open: controlledOpen,
     setOpen: controlledSetOpen,
-    defaultTab = SettingTab.General,
+    defaultTab = SpaceSettingTab.General,
   } = props;
 
-  const { t } = useTranslation(spaceConfig.i18nNamespaces);
-
   const [internalOpen, setInternalOpen] = useState(false);
   const isControlled = controlledOpen !== undefined;
   const open = isControlled ? controlledOpen : internalOpen;
@@ -52,58 +38,14 @@ export const SpaceInnerSettingModal = (props: ISpaceInnerSettingModalProps) => {
     [controlledSetOpen, isControlled, setInternalOpen]
   );
 
-  const [tab, setTab] = useState(defaultTab);
+  const [tab, setTab] = useState<UnifiedSettingTab>(defaultTab);
+
   useEffect(() => {
     if (open) {
       setTab(defaultTab);
     }
   }, [open, defaultTab]);
 
-  const tabList = useMemo(() => {
-    return [
-      {
-        key: SettingTab.General,
-        name: t('space:spaceSetting.general'),
-        Icon: Settings,
-      },
-      {
-        key: SettingTab.Collaborator,
-        name: t('space:spaceSetting.collaborators'),
-        Icon: Users,
-      },
-    ];
-  }, [t]);
-
-  const content = (
-    <Tabs
-      defaultValue={SettingTab.General}
-      value={tab}
-      onValueChange={(value) => setTab(value as SettingTab)}
-      className="flex h-full gap-0 overflow-hidden"
-    >
-      <TabsList className="flex h-full w-72 flex-col items-start justify-start gap-1 rounded-none border-none bg-muted p-4">
-        {tabList.map(({ key, name, Icon }) => {
-          return (
-            <TabsTrigger
-              key={key}
-              value={key}
-              className="h-8 w-full cursor-pointer justify-start gap-2 rounded-md font-normal data-[state=active]:bg-surface data-[state=active]:font-medium data-[state=active]:shadow-none hover:bg-surface"
-            >
-              <Icon className="size-4 shrink-0" />
-              <span>{name}</span>
-            </TabsTrigger>
-          );
-        })}
-      </TabsList>
-      <TabsContent tabIndex={-1} value={SettingTab.General} className="mt-0 size-full">
-        <GeneralPage />
-      </TabsContent>
-      <TabsContent tabIndex={-1} value={SettingTab.Collaborator} className="mt-0 size-full">
-        <CollaboratorPage />
-      </TabsContent>
-    </Tabs>
-  );
-
   return (
     <Dialog open={open} onOpenChange={setOpen}>
       <DialogTrigger asChild>{children}</DialogTrigger>
@@ -111,7 +53,12 @@ export const SpaceInnerSettingModal = (props: ISpaceInnerSettingModalProps) => {
         className="flex h-[85%] max-h-[85%] max-w-[80%] flex-col gap-0 p-0 transition-[max-width] duration-300"
         onOpenAutoFocus={(e) => e.preventDefault()}
       >
-        {content}
+        <UnifiedSettingDialogContent
+          tab={tab}
+          onTabChange={setTab}
+          entry="space"
+          defaultTab={defaultTab}
+        />
       </DialogContent>
     </Dialog>
   );
diff --git a/apps/nextjs-app/src/features/app/blocks/space-setting/collaborator/CollaboratorPage.tsx b/apps/nextjs-app/src/features/app/blocks/space-setting/collaborator/CollaboratorPage.tsx
index 9d7bb8db31..f368f0396f 100644
--- a/apps/nextjs-app/src/features/app/blocks/space-setting/collaborator/CollaboratorPage.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/space-setting/collaborator/CollaboratorPage.tsx
@@ -11,21 +11,23 @@ import { Collaborators } from '@/features/app/components/collaborator-manage/spa
 import { SpaceSettingContainer } from '@/features/app/components/SpaceSettingContainer';
 import { spaceConfig } from '@/features/i18n/space.config';
 
-export const CollaboratorPage = () => {
+export const CollaboratorPage = ({ spaceId: spaceIdProp }: { spaceId?: string } = {}) => {
   const router = useRouter();
   const isHydrated = useIsHydrated();
   const { t } = useTranslation(spaceConfig.i18nNamespaces);
-  const spaceId = router.query.spaceId as string;
+  const spaceId = (spaceIdProp ?? router.query.spaceId) as string;
 
   const { data: space } = useQuery({
-    queryKey: ReactQueryKeys.space(spaceId),
+    queryKey: ReactQueryKeys.space(spaceId as string),
     queryFn: ({ queryKey }) => getSpaceById(queryKey[1]).then((res) => res.data),
+    enabled: Boolean(spaceId),
   });
 
   const { data: collaborators } = useQuery({
-    queryKey: ReactQueryKeys.spaceCollaboratorList(spaceId, { includeBase: true }),
+    queryKey: ReactQueryKeys.spaceCollaboratorList(spaceId as string, { includeBase: true }),
     queryFn: ({ queryKey }) =>
       getSpaceCollaboratorList(queryKey[1], { includeBase: true }).then((res) => res.data),
+    enabled: Boolean(spaceId),
   });
 
   return (
@@ -35,7 +37,7 @@ export const CollaboratorPage = () => {
         <Trans
           ns="common"
           i18nKey={'invite.dialog.desc'}
-          count={collaborators?.uniqTotal}
+          count={collaborators?.uniqTotal ?? 0}
           components={{ b: <b /> }}
         />
       }
@@ -44,7 +46,7 @@ export const CollaboratorPage = () => {
       {isHydrated && !!space && (
         <div className="size-full">
           <Collaborators
-            spaceId={spaceId}
+            spaceId={space.id}
             role={space.role}
             collaboratorQuery={{ includeBase: true }}
           >
diff --git a/apps/nextjs-app/src/features/app/blocks/space-setting/general/GeneralPage.tsx b/apps/nextjs-app/src/features/app/blocks/space-setting/general/GeneralPage.tsx
index 3731c19dc4..24749cee9b 100644
--- a/apps/nextjs-app/src/features/app/blocks/space-setting/general/GeneralPage.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/space-setting/general/GeneralPage.tsx
@@ -12,17 +12,18 @@ import { DeleteSpaceConfirm } from '@/features/app/components/space/DeleteSpaceC
 import { SpaceSettingContainer } from '@/features/app/components/SpaceSettingContainer';
 import { spaceConfig } from '@/features/i18n/space.config';
 
-export const GeneralPage = () => {
+export const GeneralPage = ({ spaceId: spaceIdProp }: { spaceId?: string } = {}) => {
   const router = useRouter();
   const queryClient = useQueryClient();
   const { t } = useTranslation(spaceConfig.i18nNamespaces);
-  const spaceId = router.query.spaceId as string;
+  const spaceId = (spaceIdProp ?? router.query.spaceId) as string;
   const [isEditing, setIsEditing] = useState(false);
   const [deleteConfirm, setDeleteConfirm] = useState(false);
 
   const { data: space } = useQuery({
     queryKey: ReactQueryKeys.space(spaceId),
     queryFn: ({ queryKey }) => getSpaceById(queryKey[1]).then((res) => res.data),
+    enabled: Boolean(spaceId),
   });
 
   const { mutateAsync: updateSpaceMutator } = useMutation({
@@ -88,7 +89,7 @@ export const GeneralPage = () => {
               </div>
 
               {/* Space name */}
-              <div className="flex max-w-sm flex-col gap-y-1 overflow-visible">
+              <div className="flex w-full flex-col gap-y-2 overflow-visible sm:max-w-sm">
                 <label className="text-sm font-medium">{t('space:spaceSetting.spaceName')}</label>
                 {isEditing ? (
                   <Input
@@ -96,7 +97,6 @@ export const GeneralPage = () => {
                     onBlur={onBlur}
                     onKeyDown={onKeydown}
                     autoFocus
-                    size="lg"
                     className="px-3"
                   />
                 ) : (
@@ -104,21 +104,19 @@ export const GeneralPage = () => {
                     value={space.name}
                     readOnly
                     onClick={() => hasPermission(space.role, 'space|update') && setIsEditing(true)}
-                    size="lg"
                     className={`px-3 ${hasPermission(space.role, 'space|update') ? 'cursor-pointer' : 'cursor-default'}`}
                   />
                 )}
               </div>
 
               {/* Space ID */}
-              <div className="flex max-w-sm flex-col gap-y-1">
+              <div className="flex w-full flex-col gap-y-2 sm:max-w-sm">
                 <label className="text-sm font-medium">{t('space:spaceSetting.spaceId')}</label>
                 <div className="relative">
                   <Input
                     value={spaceId}
                     readOnly
                     tabIndex={-1}
-                    size="lg"
                     className="cursor-default px-3 pr-10"
                   />
                   <CopyButton
@@ -136,6 +134,7 @@ export const GeneralPage = () => {
             {hasPermission(space.role, 'space|delete') && (
               <Button
                 variant="outline"
+                size="sm"
                 className="w-fit text-destructive hover:text-destructive/80"
                 onClick={() => setDeleteConfirm(true)}
               >
diff --git a/apps/nextjs-app/src/features/app/blocks/space-setting/integration/components/AiConfig.tsx b/apps/nextjs-app/src/features/app/blocks/space-setting/integration/components/AiConfig.tsx
index 8c9c7f7655..a5aa8ec7e5 100644
--- a/apps/nextjs-app/src/features/app/blocks/space-setting/integration/components/AiConfig.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/space-setting/integration/components/AiConfig.tsx
@@ -17,19 +17,23 @@ import { AIControlCard } from '../../../admin/setting/components/ai-config/AICon
 import { AIProviderCard } from '../../../admin/setting/components/ai-config/AIProviderCard';
 import { BatchTestModels } from '../../../admin/setting/components/ai-config/BatchTestModels';
 import type { IModelTestResult } from '../../../admin/setting/components/ai-config/LlmproviderManage';
-import { parseModelKey } from '../../../admin/setting/components/ai-config/utils';
+import {
+  normalizeLLMProviderModelConfigs,
+  parseModelKey,
+} from '../../../admin/setting/components/ai-config/utils';
 
 interface IAIConfigProps {
   config: IAIIntegrationConfig;
   onChange: (value: IAIIntegrationConfig) => void;
+  spaceId?: string;
 }
 
 const emptyArray: never[] = [];
 
 export const AIConfig = (props: IAIConfigProps) => {
-  const { config, onChange } = props;
+  const { config, onChange, spaceId: spaceIdProp } = props;
   const router = useRouter();
-  const spaceId = router.query.spaceId as string;
+  const spaceId = (spaceIdProp ?? router.query.spaceId) as string;
 
   const defaultValues = useMemo(
     () =>
@@ -69,20 +73,28 @@ export const AIConfig = (props: IAIConfigProps) => {
     reset(defaultValues);
   }, [defaultValues, reset]);
 
+  const normalizeAiConfig = useCallback((data: IAIIntegrationConfig): IAIIntegrationConfig => {
+    return {
+      ...data,
+      llmProviders: data.llmProviders?.map(normalizeLLMProviderModelConfigs) ?? [],
+    };
+  }, []);
+
   const onSubmit = useCallback(
     async (data: IAIIntegrationConfig) => {
-      onChange(data);
+      onChange(normalizeAiConfig(data));
       toast({
         title: t('admin.setting.ai.configUpdated'),
       });
     },
-    [onChange, t]
+    [normalizeAiConfig, onChange, t]
   );
 
   const onProvidersUpdate = (providers: LLMProvider[]) => {
-    form.setValue('llmProviders', providers);
+    const normalizedProviders = providers.map(normalizeLLMProviderModelConfigs);
+    form.setValue('llmProviders', normalizedProviders);
     form.trigger('llmProviders');
-    onSubmit(form.getValues());
+    onSubmit({ ...form.getValues(), llmProviders: normalizedProviders });
   };
 
   const onTest = async (data: ITestLLMRo) => testIntegrationLLM(spaceId, data);
@@ -104,7 +116,7 @@ export const AIConfig = (props: IAIConfigProps) => {
       if (providerIndex === -1) return;
 
       const provider = currentProviders[providerIndex];
-      const updatedProvider = {
+      const updatedProvider = normalizeLLMProviderModelConfigs({
         ...provider,
         modelConfigs: {
           ...provider.modelConfigs,
@@ -115,16 +127,16 @@ export const AIConfig = (props: IAIConfigProps) => {
             testedAt: Date.now(),
           },
         },
-      };
+      });
 
       const newProviders = [...currentProviders];
       newProviders[providerIndex] = updatedProvider;
 
       form.setValue('llmProviders', newProviders);
       // Silent save without toast
-      onChange(form.getValues());
+      onChange(normalizeAiConfig({ ...form.getValues(), llmProviders: newProviders }));
     },
-    [form, onChange]
+    [form, normalizeAiConfig, onChange]
   );
 
   // Toggle image model flag
@@ -140,7 +152,7 @@ export const AIConfig = (props: IAIConfigProps) => {
       if (providerIndex === -1) return;
 
       const provider = currentProviders[providerIndex];
-      const updatedProvider = {
+      const updatedProvider = normalizeLLMProviderModelConfigs({
         ...provider,
         modelConfigs: {
           ...provider.modelConfigs,
@@ -149,18 +161,17 @@ export const AIConfig = (props: IAIConfigProps) => {
             isImageModel,
             // Clear previous test results when toggling
             ability: isImageModel ? undefined : provider.modelConfigs?.[model]?.ability,
-            imageAbility: isImageModel ? provider.modelConfigs?.[model]?.imageAbility : undefined,
           },
         },
-      };
+      });
 
       const newProviders = [...currentProviders];
       newProviders[providerIndex] = updatedProvider;
 
       form.setValue('llmProviders', newProviders);
-      onChange(form.getValues());
+      onChange(normalizeAiConfig({ ...form.getValues(), llmProviders: newProviders }));
     },
-    [form, onChange]
+    [form, normalizeAiConfig, onChange]
   );
 
   const instanceAIDisableActions = setting?.aiConfig?.capabilities?.disableActions || [];
diff --git a/apps/nextjs-app/src/features/app/blocks/space-setting/types.ts b/apps/nextjs-app/src/features/app/blocks/space-setting/types.ts
new file mode 100644
index 0000000000..adec79e598
--- /dev/null
+++ b/apps/nextjs-app/src/features/app/blocks/space-setting/types.ts
@@ -0,0 +1,5 @@
+export enum SpaceSettingTab {
+  General = 'general',
+  Collaborator = 'collaborator',
+  Plan = 'plan',
+}
diff --git a/apps/nextjs-app/src/features/app/blocks/table/table-header/LockedViewTip.tsx b/apps/nextjs-app/src/features/app/blocks/table/table-header/LockedViewTip.tsx
index 0665090134..892be26f4b 100644
--- a/apps/nextjs-app/src/features/app/blocks/table/table-header/LockedViewTip.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/table/table-header/LockedViewTip.tsx
@@ -11,27 +11,29 @@ export const LockedViewTip = () => {
   const { openPersonalView } = usePersonalView();
 
   return (
-    <div className="relative flex w-full items-center justify-between py-1 text-xs text-gray-500 duration-500 animate-in fade-in dark:text-gray-400 sm:justify-center">
-      <div className="relative px-2">{t('table:view.locked.tip')}</div>
-      <div className="mr-2 flex sm:absolute sm:right-2 sm:top-1/2 sm:mr-0 sm:-translate-y-1/2">
-        <Button
-          size="xs"
-          className="flex h-5"
-          onClick={() => {
-            openPersonalView();
-            setVisible(false);
-          }}
-        >
-          {t('table:view.action.enable')}
-        </Button>
-        <Button
-          variant="ghost"
-          size="xs"
-          className="ml-2 flex size-5 p-[2px]"
-          onClick={() => setVisible(false)}
-        >
-          <X className="size-4 shrink-0" />
-        </Button>
+    <div className="w-full @container/locked-view-tip">
+      <div className="relative flex w-full items-center justify-between gap-4 px-4 py-1.5 text-xs text-gray-500 duration-500 animate-in fade-in @3xl/locked-view-tip:justify-center dark:text-gray-400">
+        <div className="relative">{t('table:view.locked.tip')}</div>
+        <div className="flex @3xl/locked-view-tip:absolute @3xl/locked-view-tip:right-2 @3xl/locked-view-tip:top-1/2 @3xl/locked-view-tip:mr-0 @3xl/locked-view-tip:-translate-y-1/2">
+          <Button
+            size="xs"
+            className="flex h-5"
+            onClick={() => {
+              openPersonalView();
+              setVisible(false);
+            }}
+          >
+            {t('table:view.action.enable')}
+          </Button>
+          <Button
+            variant="ghost"
+            size="xs"
+            className="ml-2 flex size-5 p-[2px]"
+            onClick={() => setVisible(false)}
+          >
+            <X className="size-4 shrink-0" />
+          </Button>
+        </div>
       </div>
     </div>
   );
diff --git a/apps/nextjs-app/src/features/app/blocks/view/calendar/components/CalendarConfig.tsx b/apps/nextjs-app/src/features/app/blocks/view/calendar/components/CalendarConfig.tsx
index 90086ef5a0..efae2d276d 100644
--- a/apps/nextjs-app/src/features/app/blocks/view/calendar/components/CalendarConfig.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/view/calendar/components/CalendarConfig.tsx
@@ -1,6 +1,7 @@
 import type { IColorConfig } from '@teable/core';
 import { CellValueType, ColorConfigType, Colors, FieldType } from '@teable/core';
-import { useFields, useFieldStaticGetter, useView } from '@teable/sdk/hooks';
+import { ReadOnlyTip } from '@teable/sdk';
+import { useFields, useFieldStaticGetter, usePersonalView, useView } from '@teable/sdk/hooks';
 import type { CalendarView } from '@teable/sdk/model';
 import {
   Popover,
@@ -28,6 +29,8 @@ export const CalendarConfig: FC<PropsWithChildren> = (props) => {
   const { t } = useTranslation(tableConfig.i18nNamespaces);
   const fields = useFields({ withHidden: true, withDenied: true });
   const fieldStaticGetter = useFieldStaticGetter();
+  const { isPersonalView } = usePersonalView();
+  const readOnly = Boolean(view?.isLocked && !isPersonalView);
 
   const { primaryField, filteredDateFields, filteredSelectFields } = useMemo(
     () => ({
@@ -43,10 +46,12 @@ export const CalendarConfig: FC<PropsWithChildren> = (props) => {
   );
 
   const onSelectChange = (key: string, value: string) => {
+    if (readOnly) return;
     view?.updateOption({ [key]: value });
   };
 
   const onColorTypeChange = (type: ColorConfigType) => {
+    if (readOnly) return;
     let config: IColorConfig = null;
 
     if (type === ColorConfigType.Field) {
@@ -62,10 +67,12 @@ export const CalendarConfig: FC<PropsWithChildren> = (props) => {
   };
 
   const onColorChange = (value: string) => {
+    if (readOnly) return;
     view?.updateOption({ colorConfig: { type: ColorConfigType.Custom, color: value as Colors } });
   };
 
   const onColorFieldIdChange = (value: string) => {
+    if (readOnly) return;
     view?.updateOption({
       colorConfig: { type: ColorConfigType.Field, color: null, fieldId: value },
     });
@@ -98,7 +105,12 @@ export const CalendarConfig: FC<PropsWithChildren> = (props) => {
   return (
     <Popover modal>
       <PopoverTrigger asChild>{children}</PopoverTrigger>
-      <PopoverContent side="bottom" align="start" className="flex w-[272px] flex-col gap-4 p-4">
+      <PopoverContent
+        side="bottom"
+        align="start"
+        className="relative flex w-[272px] flex-col gap-4 p-4"
+      >
+        {readOnly && <ReadOnlyTip />}
         {fields.length > 0 ? (
           <Fragment>
             {dateSelects.map(({ label, key, value }) => (
diff --git a/apps/nextjs-app/src/features/app/blocks/view/grid/GridViewBaseInner.tsx b/apps/nextjs-app/src/features/app/blocks/view/grid/GridViewBaseInner.tsx
index 6f7046f6e8..f9f8f1a4c5 100644
--- a/apps/nextjs-app/src/features/app/blocks/view/grid/GridViewBaseInner.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/view/grid/GridViewBaseInner.tsx
@@ -190,7 +190,13 @@ export const GridViewBaseInner: React.FC<IGridViewBaseInnerProps> = (
   const taskStatusCollection = useContext(TaskStatusCollectionContext);
   const { shareId } = useShareContext();
   const buttonClickStatusHook = useButtonClickStatus(tableId, shareId);
-  const { columns: originalColumns, cellValue2GridDisplay } = useGridColumns();
+  const { setGridRef, searchCursor, highlightedFieldId, setRecordMap, setFields } =
+    useGridSearchStore();
+  const { columns: originalColumns, cellValue2GridDisplay } = useGridColumns(
+    undefined,
+    undefined,
+    highlightedFieldId
+  );
   const { columns, onColumnResize } = useGridColumnResize(originalColumns);
   const { columnStatistics } = useGridColumnStatistics(columns);
   const { onColumnOrdered } = useGridColumnOrder();
@@ -232,7 +238,6 @@ export const GridViewBaseInner: React.FC<IGridViewBaseInnerProps> = (
   const realRowCount = rowCount ?? ssrRecords?.length ?? 0;
   const fieldEditable = permission['field|update'];
   const { undo, redo } = useUndoRedo();
-  const { setGridRef, searchCursor, setRecordMap, setFields } = useGridSearchStore();
   const [expandRecord, setExpandRecord] = useState<{ tableId: string; recordId: string }>();
   const [newRecords, setNewRecords] = useState<ICreateRecordsRo['records']>();
   const [cellErrors, setCellErrors] = useState<ICellError[]>([]);
diff --git a/apps/nextjs-app/src/features/app/blocks/view/grid/hooks/useSelectionOperation.ts b/apps/nextjs-app/src/features/app/blocks/view/grid/hooks/useSelectionOperation.ts
index d416c799e0..3ccbdf527a 100644
--- a/apps/nextjs-app/src/features/app/blocks/view/grid/hooks/useSelectionOperation.ts
+++ b/apps/nextjs-app/src/features/app/blocks/view/grid/hooks/useSelectionOperation.ts
@@ -372,9 +372,10 @@ export const useSelectionOperation = (props?: {
   }, []);
 
   const groupBy = view?.group;
+  const visibleFieldIds = useMemo(() => fields.map(({ id }) => id), [fields]);
   const selectionViewQuery = useMemo(
-    () => buildSelectionViewQuery({ personalViewCommonQuery }),
-    [personalViewCommonQuery]
+    () => buildSelectionViewQuery({ personalViewCommonQuery, visibleFieldIds }),
+    [personalViewCommonQuery, visibleFieldIds]
   );
 
   const buildSelectionRequest = useCallback(
diff --git a/apps/nextjs-app/src/features/app/blocks/view/grid/useGridSearchStore.ts b/apps/nextjs-app/src/features/app/blocks/view/grid/useGridSearchStore.ts
index 0fef8f931c..84ef8dda8c 100644
--- a/apps/nextjs-app/src/features/app/blocks/view/grid/useGridSearchStore.ts
+++ b/apps/nextjs-app/src/features/app/blocks/view/grid/useGridSearchStore.ts
@@ -33,6 +33,8 @@ interface IGridRefState {
   setGridRef: (ref: React.RefObject<IGridRef>) => void;
   searchCursor: [number, number] | null;
   setSearchCursor: (cell: [number, number] | null) => void;
+  highlightedFieldId: string | null;
+  setHighlightedFieldId: (fieldId: string | null) => void;
   resetSearchHandler: () => void;
   setResetSearchHandler: (fn: () => void) => void;
   recordMap: IRecordIndexMap | null;
@@ -48,6 +50,7 @@ interface IGridRefState {
 export const useGridSearchStore = create<IGridRefState>((set) => ({
   gridRef: null,
   searchCursor: null,
+  highlightedFieldId: null,
   recordMap: null,
   fields: null,
   highlightedTableId: null,
@@ -77,6 +80,14 @@ export const useGridSearchStore = create<IGridRefState>((set) => ({
       };
     });
   },
+  setHighlightedFieldId: (fieldId: string | null) => {
+    set((state) => {
+      return {
+        ...state,
+        highlightedFieldId: fieldId,
+      };
+    });
+  },
   setRecordMap: (recordMap: IRecordIndexMap | null) => {
     set((state) => {
       // Notify listeners when recordMap changes
diff --git a/apps/nextjs-app/src/features/app/blocks/view/grid/utils/selectionViewQuery.spec.ts b/apps/nextjs-app/src/features/app/blocks/view/grid/utils/selectionViewQuery.spec.ts
index 90f90da604..f1c2f80e18 100644
--- a/apps/nextjs-app/src/features/app/blocks/view/grid/utils/selectionViewQuery.spec.ts
+++ b/apps/nextjs-app/src/features/app/blocks/view/grid/utils/selectionViewQuery.spec.ts
@@ -7,6 +7,16 @@ describe('buildSelectionViewQuery', () => {
     expect(buildSelectionViewQuery({})).toBeUndefined();
   });
 
+  it('returns the current visible projection when there is no personal view query', () => {
+    expect(
+      buildSelectionViewQuery({
+        visibleFieldIds: ['fldVisibleA', 'fldVisibleB'],
+      })
+    ).toEqual({
+      projection: ['fldVisibleA', 'fldVisibleB'],
+    });
+  });
+
   it('returns the full personal view query to keep frontend/backend row order in sync', () => {
     const filter: NonNullable<IGetRecordsRo['filter']> = {
       conjunction: 'and',
@@ -26,6 +36,23 @@ describe('buildSelectionViewQuery', () => {
     expect(buildSelectionViewQuery({ personalViewCommonQuery })).toEqual(personalViewCommonQuery);
   });
 
+  it('uses the live visible projection to keep selection column indexes in sync', () => {
+    const personalViewCommonQuery = {
+      ignoreViewQuery: true,
+      projection: ['fldOldA', 'fldOldB'],
+    };
+
+    expect(
+      buildSelectionViewQuery({
+        personalViewCommonQuery,
+        visibleFieldIds: ['fldCurrentB', 'fldCurrentA'],
+      })
+    ).toEqual({
+      ignoreViewQuery: true,
+      projection: ['fldCurrentB', 'fldCurrentA'],
+    });
+  });
+
   it('returns full query when filter differs', () => {
     const personalViewCommonQuery = {
       ignoreViewQuery: true,
diff --git a/apps/nextjs-app/src/features/app/blocks/view/grid/utils/selectionViewQuery.ts b/apps/nextjs-app/src/features/app/blocks/view/grid/utils/selectionViewQuery.ts
index 89d4bfd641..f8831cd256 100644
--- a/apps/nextjs-app/src/features/app/blocks/view/grid/utils/selectionViewQuery.ts
+++ b/apps/nextjs-app/src/features/app/blocks/view/grid/utils/selectionViewQuery.ts
@@ -12,12 +12,24 @@ type ISelectionViewQuery = Pick<
  */
 export const buildSelectionViewQuery = ({
   personalViewCommonQuery,
+  visibleFieldIds,
 }: {
   personalViewCommonQuery?: ISelectionViewQuery;
+  visibleFieldIds?: string[];
 }): ISelectionViewQuery | undefined => {
+  const projection = visibleFieldIds?.length
+    ? visibleFieldIds
+    : personalViewCommonQuery?.projection;
+
   if (!personalViewCommonQuery) {
+    if (projection?.length) {
+      return { projection };
+    }
     return;
   }
 
-  return personalViewCommonQuery;
+  return {
+    ...personalViewCommonQuery,
+    projection,
+  };
 };
diff --git a/apps/nextjs-app/src/features/app/blocks/view/tool-bar/components/GridViewOperators.tsx b/apps/nextjs-app/src/features/app/blocks/view/tool-bar/components/GridViewOperators.tsx
index 92aaaf880d..a2f0f9a34f 100644
--- a/apps/nextjs-app/src/features/app/blocks/view/tool-bar/components/GridViewOperators.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/view/tool-bar/components/GridViewOperators.tsx
@@ -8,11 +8,14 @@ import {
   AlertTriangle,
 } from '@teable/icons';
 import { HideFields, RowHeight, Sort, Group, ViewFilter } from '@teable/sdk';
+import { useFields } from '@teable/sdk/hooks';
 import { useView } from '@teable/sdk/hooks/use-view';
 import { cn } from '@teable/ui-lib/shadcn';
+import { toast } from '@teable/ui-lib/shadcn/ui/sonner';
 import { useTranslation } from 'next-i18next';
 import { useEffect, useRef } from 'react';
 import { tableConfig } from '@/features/i18n/table.config';
+import { useGridSearchStore } from '../../grid/useGridSearchStore';
 import { useToolbarChange } from '../../hooks/useToolbarChange';
 import { ToolBarButton } from '../ToolBarButton';
 import { useToolBarStore } from './useToolBarStore';
@@ -20,6 +23,9 @@ import { useToolBarStore } from './useToolBarStore';
 export const GridViewOperators: React.FC<{ disabled?: boolean }> = (props) => {
   const { disabled } = props;
   const view = useView();
+  const fields = useFields();
+  const allFields = useFields({ withHidden: true, withDenied: true });
+  const { gridRef, setHighlightedFieldId } = useGridSearchStore();
   const {
     onFilterChange,
     onRowHeightChange,
@@ -32,6 +38,7 @@ export const GridViewOperators: React.FC<{ disabled?: boolean }> = (props) => {
   const filterRef = useRef<HTMLButtonElement>(null);
   const sortRef = useRef<HTMLButtonElement>(null);
   const groupRef = useRef<HTMLButtonElement>(null);
+  const highlightTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 
   useEffect(() => {
     setFilterRef(filterRef);
@@ -39,12 +46,39 @@ export const GridViewOperators: React.FC<{ disabled?: boolean }> = (props) => {
     setGroupRef(groupRef);
   }, [setFilterRef, setGroupRef, setSortRef]);
 
+  useEffect(() => {
+    return () => {
+      if (highlightTimeoutRef.current) {
+        clearTimeout(highlightTimeoutRef.current);
+      }
+      setHighlightedFieldId(null);
+    };
+  }, [setHighlightedFieldId]);
+
   if (!view) {
     return <div></div>;
   }
   return (
     <div className="flex min-w-0 flex-1 gap-1">
-      <HideFields>
+      <HideFields
+        onFieldClick={(field) => {
+          const columnIndex = fields.findIndex(({ id }) => id === field.id);
+          if (columnIndex === -1) {
+            const fieldName = allFields.find(({ id }) => id === field.id)?.name ?? field.name;
+            toast.warning(t('sdk:hidden.notInCurrentView', { fieldName }));
+            return;
+          }
+          gridRef?.current?.scrollToItem([columnIndex, 0]);
+          setHighlightedFieldId(field.id);
+          if (highlightTimeoutRef.current) {
+            clearTimeout(highlightTimeoutRef.current);
+          }
+          highlightTimeoutRef.current = setTimeout(() => {
+            setHighlightedFieldId(null);
+            highlightTimeoutRef.current = null;
+          }, 1000);
+        }}
+      >
         {(text, isActive) => (
           <ToolBarButton
             disabled={disabled}
@@ -125,38 +159,6 @@ export const GridViewOperators: React.FC<{ disabled?: boolean }> = (props) => {
           </ToolBarButton>
         )}
       </Group>
-      {/* <TooltipProvider>
-        <Tooltip>
-          <TooltipTrigger asChild>
-            {
-              // disabled doesn't trigger the tooltip, so wrap div
-            }
-            <div>
-              <Color>
-                {(text: string, isActive) => (
-                  <ToolBarButton
-                    disabled={true}
-                    isActive={isActive}
-                    text={text}
-                    className={cn(
-                      GUIDE_VIEW_GROUPING,
-                      'max-w-xs',
-                      isActive &&
-                        'bg-green-100 dark:bg-green-600/30 hover:bg-green-200 dark:hover:bg-green-500/30'
-                    )}
-                    textClassName="@2xl/toolbar:inline"
-                  >
-                    <PaintBucket className="size-4 text-sm" />
-                  </ToolBarButton>
-                )}
-              </Color>
-            </div>
-          </TooltipTrigger>
-          <TooltipContent>
-            <p>{t('table:toolbar.comingSoon')}</p>
-          </TooltipContent>
-        </Tooltip>
-      </TooltipProvider> */}
 
       <RowHeight
         rowHeight={(view?.options as IGridViewOptions)?.rowHeight}
diff --git a/apps/nextjs-app/src/features/app/blocks/view/tool-bar/components/KanbanViewOperators.tsx b/apps/nextjs-app/src/features/app/blocks/view/tool-bar/components/KanbanViewOperators.tsx
index bf7e206aff..045abaf010 100644
--- a/apps/nextjs-app/src/features/app/blocks/view/tool-bar/components/KanbanViewOperators.tsx
+++ b/apps/nextjs-app/src/features/app/blocks/view/tool-bar/components/KanbanViewOperators.tsx
@@ -20,6 +20,7 @@ import {
   useTablePermission,
   CreateRecordModal,
   useIsReadOnlyPreview,
+  usePersonalView,
 } from '@teable/sdk';
 import { useView } from '@teable/sdk/hooks/use-view';
 import { Button, Label, Switch, cn } from '@teable/ui-lib/shadcn';
@@ -42,10 +43,13 @@ export const KanbanViewOperators: React.FC<{ disabled?: boolean }> = (props) =>
   const { setCollapsedStackMap } = useKanbanStackCollapsedStore();
   const dialogRef = useRef<IFieldCreateOrSelectModalRef>(null);
   const isReadOnlyPreview = useIsReadOnlyPreview();
+  const { isPersonalView } = usePersonalView();
   const { stackFieldId, coverFieldId, isCoverFit, isEmptyStackHidden, isFieldNameHidden } =
     view?.options ?? {};
+  const readOnly = Boolean(view?.isLocked && !isPersonalView);
 
   const onFieldSelected = async (field: IFieldVo | IFieldInstance) => {
+    if (readOnly) return;
     if (field.id === stackFieldId) return;
     await view?.updateOption({ stackFieldId: field.id });
     const localId = generateLocalId(tableId, view?.id);
@@ -65,6 +69,7 @@ export const KanbanViewOperators: React.FC<{ disabled?: boolean }> = (props) =>
   };
 
   const onEmptyStackHiddenChange = (checked: boolean) => {
+    if (readOnly) return;
     view?.updateOption({ isEmptyStackHidden: checked });
   };
 
@@ -104,6 +109,7 @@ export const KanbanViewOperators: React.FC<{ disabled?: boolean }> = (props) =>
             <Switch
               id="hide-empty-stack"
               checked={isEmptyStackHidden}
+              disabled={readOnly}
               onCheckedChange={(checked) => onEmptyStackHiddenChange(checked)}
             />
             <Label htmlFor="hide-empty-stack" className="text-sm font-normal">
@@ -112,6 +118,7 @@ export const KanbanViewOperators: React.FC<{ disabled?: boolean }> = (props) =>
           </div>
         }
         isCreatable={permission['field|create']}
+        readOnly={readOnly}
         selectedFieldId={stackFieldId}
         onConfirm={onFieldSelected}
         getCreateBtnText={(fieldName) => (
diff --git a/apps/nextjs-app/src/features/app/blocks/view/tool-bar/hook/useViewConfigurable.ts b/apps/nextjs-app/src/features/app/blocks/view/tool-bar/hook/useViewConfigurable.ts
index c60bec5595..ee27da33e0 100644
--- a/apps/nextjs-app/src/features/app/blocks/view/tool-bar/hook/useViewConfigurable.ts
+++ b/apps/nextjs-app/src/features/app/blocks/view/tool-bar/hook/useViewConfigurable.ts
@@ -1,14 +1,16 @@
 import { ShareViewContext } from '@teable/sdk/context';
-import { usePersonalView, useTablePermission } from '@teable/sdk/hooks';
+import { usePersonalView, useTablePermission, useView } from '@teable/sdk/hooks';
 import { useContext } from 'react';
 
 export const useViewConfigurable = () => {
   const permission = useTablePermission();
   const { isPersonalView } = usePersonalView();
+  const view = useView();
   const { shareId } = useContext(ShareViewContext) ?? {};
   const isShareView = Boolean(shareId);
 
   return {
-    isViewConfigurable: permission['view|update'] || isPersonalView || isShareView,
+    isViewConfigurable:
+      permission['view|update'] || isPersonalView || isShareView || Boolean(view?.isLocked),
   };
 };
diff --git a/apps/nextjs-app/src/features/app/components/SideBarFooter.tsx b/apps/nextjs-app/src/features/app/components/SideBarFooter.tsx
index 699808153c..f41638f4d1 100644
--- a/apps/nextjs-app/src/features/app/components/SideBarFooter.tsx
+++ b/apps/nextjs-app/src/features/app/components/SideBarFooter.tsx
@@ -1,9 +1,10 @@
 import { useSession } from '@teable/sdk';
+import { BaseContext } from '@teable/sdk/context';
 import { useIsAnonymous, useIsReadOnlyPreview } from '@teable/sdk/hooks';
 import { Button } from '@teable/ui-lib/shadcn';
 import Link from 'next/link';
 import { Trans } from 'next-i18next';
-import React from 'react';
+import React, { useContext } from 'react';
 import { TeableLogo } from '@/components/TeableLogo';
 import { NotificationsManage } from '@/features/app/components/notifications/NotificationsManage';
 import { UserAvatar } from '@/features/app/components/user/UserAvatar';
@@ -17,6 +18,7 @@ import { UserNav } from './user/UserNav';
 
 export const SideBarFooter: React.FC = () => {
   const { user } = useSession();
+  const { base } = useContext(BaseContext);
   const isAnonymous = useIsAnonymous();
   const isReadOnlyPreview = useIsReadOnlyPreview();
   const { brandName } = useBrand();
@@ -61,7 +63,7 @@ export const SideBarFooter: React.FC = () => {
             </p>
           </Button>
         </UserNav>
-        <SettingDialog />
+        <SettingDialog spaceId={base?.spaceId} />
         <DuplicateBaseModal />
         <TemplateCreateBaseModal />
         <SpaceSubscriptionModal />
diff --git a/apps/nextjs-app/src/features/app/components/download-attachments/DownloadContent.tsx b/apps/nextjs-app/src/features/app/components/download-attachments/DownloadContent.tsx
index e9b21338f5..b09329277b 100644
--- a/apps/nextjs-app/src/features/app/components/download-attachments/DownloadContent.tsx
+++ b/apps/nextjs-app/src/features/app/components/download-attachments/DownloadContent.tsx
@@ -15,6 +15,7 @@ import {
   CommandInput,
   CommandItem,
   CommandList,
+  CommandSeparator,
   Label,
   Popover,
   PopoverContent,
@@ -64,7 +65,7 @@ export const DownloadContent = ({
   const [downloading, setDownloading] = useState(false);
   const abortControllerRef = useRef<AbortController | null>(null);
 
-  const { namingFieldId, setNamingFieldId, groupByRow, setGroupByRow } =
+  const { namingFieldId, setNamingFieldId, noPrefix, setNoPrefix, groupByRow, setGroupByRow } =
     useColumnDownloadDialogStore();
   const allFields = useFields({ withHidden: true, withDenied: true });
   const fieldStaticGetter = useFieldStaticGetter();
@@ -96,6 +97,12 @@ export const DownloadContent = ({
     [namingFieldId, setNamingFieldId]
   );
 
+  // Handle "no prefix" option - toggle on/off
+  const handleNoPrefixSelect = useCallback(() => {
+    setSelectorOpen(false);
+    setNoPrefix(!noPrefix);
+  }, [noPrefix, setNoPrefix]);
+
   // Load preview on mount
   useEffect(() => {
     const loadPreview = async () => {
@@ -184,6 +191,7 @@ export const DownloadContent = ({
         shareId,
         personalViewCommonQuery,
         namingField,
+        noPrefix,
         groupByRow,
         abortController,
         onProgress: updateProgress,
@@ -218,6 +226,7 @@ export const DownloadContent = ({
     viewId,
     shareId,
     namingField,
+    noPrefix,
     groupByRow,
     personalViewCommonQuery,
     onClose,
@@ -299,8 +308,15 @@ export const DownloadContent = ({
                     className="w-full justify-between dark:bg-[color-mix(in_oklab,white_10%,hsl(var(--background)))]"
                   >
                     <div className="flex items-center gap-2 truncate">
-                      {namingFieldId ? (
-                        (() => {
+                      {(() => {
+                        if (noPrefix) {
+                          return (
+                            <span className="truncate">
+                              {t('table:download.allAttachments.noPrefixOption')}
+                            </span>
+                          );
+                        }
+                        if (namingFieldId) {
                           const selectedField = namingFields.find((f) => f.id === namingFieldId);
                           if (!selectedField) return null;
                           const { Icon } = fieldStaticGetter(selectedField.type, {
@@ -315,12 +331,13 @@ export const DownloadContent = ({
                               <span className="truncate">{selectedField.name}</span>
                             </>
                           );
-                        })()
-                      ) : (
-                        <span className="text-muted-foreground">
-                          {t('table:download.allAttachments.selectField')}
-                        </span>
-                      )}
+                        }
+                        return (
+                          <span className="text-muted-foreground">
+                            {t('table:download.allAttachments.selectField')}
+                          </span>
+                        );
+                      })()}
                     </div>
                     <ChevronDown className="size-4 shrink-0 text-muted-foreground" />
                   </Button>
@@ -330,6 +347,32 @@ export const DownloadContent = ({
                     <CommandInput placeholder={t('common:actions.search')} />
                     <CommandList className="max-h-60">
                       <CommandEmpty>{t('common:noResult')}</CommandEmpty>
+                      <CommandGroup>
+                        <CommandItem
+                          value="__no_prefix__"
+                          keywords={[
+                            t('table:download.allAttachments.noPrefixOption'),
+                            t('table:download.allAttachments.noPrefixOptionDesc'),
+                          ]}
+                          onSelect={handleNoPrefixSelect}
+                        >
+                          <div className="flex min-w-0 flex-1 flex-col">
+                            <span className="truncate">
+                              {t('table:download.allAttachments.noPrefixOption')}
+                            </span>
+                            <span className="truncate text-xs text-muted-foreground">
+                              {t('table:download.allAttachments.noPrefixOptionDesc')}
+                            </span>
+                          </div>
+                          <Check
+                            className={cn(
+                              'ml-2 size-4 shrink-0',
+                              noPrefix ? 'opacity-100' : 'opacity-0'
+                            )}
+                          />
+                        </CommandItem>
+                      </CommandGroup>
+                      <CommandSeparator />
                       <CommandGroup>
                         {namingFields.map((field) => {
                           const { Icon } = fieldStaticGetter(field.type, {
diff --git a/apps/nextjs-app/src/features/app/components/download-attachments/useDownloadAttachmentsStore.ts b/apps/nextjs-app/src/features/app/components/download-attachments/useDownloadAttachmentsStore.ts
index e4a1d5561a..ab65ef8e1f 100644
--- a/apps/nextjs-app/src/features/app/components/download-attachments/useDownloadAttachmentsStore.ts
+++ b/apps/nextjs-app/src/features/app/components/download-attachments/useDownloadAttachmentsStore.ts
@@ -13,6 +13,7 @@ interface IColumnDownloadDialogState {
   shareId?: string;
   personalViewCommonQuery?: IGetRecordsRo;
   namingFieldId?: string;
+  noPrefix: boolean;
   groupByRow: boolean;
 
   openDialog: (params: {
@@ -25,17 +26,20 @@ interface IColumnDownloadDialogState {
   }) => void;
   closeDialog: () => void;
   setNamingFieldId: (namingFieldId?: string) => void;
+  setNoPrefix: (noPrefix: boolean) => void;
   setGroupByRow: (groupByRow: boolean) => void;
 }
 
 export const useColumnDownloadDialogStore = create<IColumnDownloadDialogState>((set) => ({
   open: false,
+  noPrefix: false,
   groupByRow: false,
 
   openDialog: (params) =>
     set({
       open: true,
       namingFieldId: undefined, // Reset naming field when opening dialog
+      noPrefix: false, // Reset no-prefix when opening dialog
       groupByRow: false, // Reset group by row when opening dialog
       ...params,
     }),
@@ -49,8 +53,10 @@ export const useColumnDownloadDialogStore = create<IColumnDownloadDialogState>((
       shareId: undefined,
       personalViewCommonQuery: undefined,
       namingFieldId: undefined,
+      noPrefix: false,
       groupByRow: false,
     }),
-  setNamingFieldId: (namingFieldId) => set({ namingFieldId }),
+  setNamingFieldId: (namingFieldId) => set({ namingFieldId, noPrefix: false }),
+  setNoPrefix: (noPrefix) => set({ noPrefix, namingFieldId: undefined }),
   setGroupByRow: (groupByRow) => set({ groupByRow }),
 }));
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/FieldSetting.spec.tsx b/apps/nextjs-app/src/features/app/components/field-setting/FieldSetting.spec.tsx
index 6e13791fb6..5915507285 100644
--- a/apps/nextjs-app/src/features/app/components/field-setting/FieldSetting.spec.tsx
+++ b/apps/nextjs-app/src/features/app/components/field-setting/FieldSetting.spec.tsx
@@ -18,6 +18,20 @@ vi.mock('./DynamicFieldEditor', () => ({
 }));
 
 describe('FieldSettingBase', () => {
+  it('disables save when editing target field is not available yet', () => {
+    render(
+      <FieldSettingBase
+        visible
+        field={undefined}
+        operator={FieldOperator.Edit}
+        onCancel={() => undefined}
+        onConfirm={() => undefined}
+      />
+    );
+
+    expect(screen.getByRole('button', { name: 'common:actions.save' })).toBeDisabled();
+  });
+
   it('hydrates local editor state when originField arrives after initial fallback render', () => {
     const lookupField = {
       id: 'fldLookup0000000001',
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/FieldSetting.tsx b/apps/nextjs-app/src/features/app/components/field-setting/FieldSetting.tsx
index 5469b277db..989e9b22b8 100644
--- a/apps/nextjs-app/src/features/app/components/field-setting/FieldSetting.tsx
+++ b/apps/nextjs-app/src/features/app/components/field-setting/FieldSetting.tsx
@@ -139,6 +139,18 @@ export const FieldSetting = (props: IFieldSetting) => {
   const autoFillModeRef = useRef<AiAutoFillMode | null>(null);
   const { t } = useTranslation(tableConfig.i18nNamespaces);
 
+  const getEditFieldId = () => {
+    if (operator !== FieldOperator.Edit) {
+      return undefined;
+    }
+
+    return props.field?.id;
+  };
+
+  const notifyMissingEditField = () => {
+    toast.error(t('table:field.editor.fieldUnavailable'));
+  };
+
   // Fetch field stats (empty/filled count) for AI field dialog
   const fetchFieldStats = async (fieldId: string) => {
     if (!tableId) return;
@@ -242,9 +254,12 @@ export const FieldSetting = (props: IFieldSetting) => {
       }
 
       if (operator === FieldOperator.Edit) {
-        const fieldId = props.field?.id;
+        const fieldId = getEditFieldId();
         if (tableId && fieldId) {
           result = await convertField({ tableId, fieldId, fieldRo: field });
+        } else {
+          notifyMissingEditField();
+          return;
         }
       }
 
@@ -264,7 +279,13 @@ export const FieldSetting = (props: IFieldSetting) => {
 
   const getPlan = async (fieldRo: IFieldRo) => {
     if (operator === FieldOperator.Edit) {
-      return await planFieldConvert({ tableId, fieldId: props.field?.id as string, fieldRo });
+      const fieldId = getEditFieldId();
+      if (!fieldId) {
+        notifyMissingEditField();
+        return;
+      }
+
+      return await planFieldConvert({ tableId, fieldId, fieldRo });
     }
     return await planFieldCreate({ tableId, fieldRo });
   };
@@ -298,6 +319,9 @@ export const FieldSetting = (props: IFieldSetting) => {
     }
 
     const plan = await getPlan(fieldRo);
+    if (!plan) {
+      return;
+    }
     setFieldRo(fieldRo);
     setPlan(plan);
     const estimateTime = plan?.estimateTime || 0;
@@ -314,6 +338,9 @@ export const FieldSetting = (props: IFieldSetting) => {
     autoFillModeRef.current = mode;
 
     const plan = await getPlan(fieldRo);
+    if (!plan) {
+      return;
+    }
     setPlan(plan);
     const estimateTime = plan?.estimateTime || 0;
     const linkFieldCount = plan?.linkFieldCount || 0;
@@ -392,6 +419,7 @@ export const FieldSettingBase = (props: IFieldSettingBase) => {
   const [alertVisible, setAlertVisible] = useState<boolean>(false);
   const [updateCount, setUpdateCount] = useState<number>(0);
   const [isSaving, setIsSaving] = useState<boolean>(false);
+  const isMissingEditField = operator === FieldOperator.Edit && !originField?.id;
 
   useEffect(() => {
     if (updateCount > 0) {
@@ -428,6 +456,11 @@ export const FieldSettingBase = (props: IFieldSettingBase) => {
   };
 
   const onSave = async () => {
+    if (isMissingEditField) {
+      toast.error(t('table:field.editor.fieldUnavailable'));
+      return;
+    }
+
     if (operator === FieldOperator.Edit && !updateCount) {
       onConfirm?.();
       return;
@@ -523,7 +556,7 @@ export const FieldSettingBase = (props: IFieldSettingBase) => {
               <Button size={'sm'} variant={'ghost'} onClick={onCancel} disabled={isSaving}>
                 {t('common:actions.cancel')}
               </Button>
-              <Button size={'sm'} onClick={onSave} disabled={isSaving}>
+              <Button size={'sm'} onClick={onSave} disabled={isSaving || isMissingEditField}>
                 {isSaving ? <Spin className="size-4" /> : t('common:actions.save')}
               </Button>
             </div>
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/AttachmentFieldAiConfig.tsx b/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/AttachmentFieldAiConfig.tsx
index 5cdf1e786c..a7922b99d9 100644
--- a/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/AttachmentFieldAiConfig.tsx
+++ b/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/AttachmentFieldAiConfig.tsx
@@ -3,247 +3,36 @@ import type {
   IAttachmentFieldAIConfig,
   IAttachmentFieldCustomizeAIConfig,
   IAttachmentFieldGenerateImageAIConfig,
-  IImageResolution,
 } from '@teable/core';
-import { FieldAIActionType, FieldType, ImageQuality } from '@teable/core';
-import { ChevronDown, ChevronRight, ImageGeneration, Pencil, Settings } from '@teable/icons';
-import {
-  getAIConfig,
-  LLMProviderType,
-  getImageModelConfigByGatewayId,
-  type IImageModelConfig,
-} from '@teable/openapi';
+import { FieldAIActionType, FieldType } from '@teable/core';
+import { ImageGeneration, Pencil } from '@teable/icons';
+import { getAIConfig } from '@teable/openapi';
 import { useBaseId } from '@teable/sdk/hooks';
 import { Selector } from '@teable/ui-lib/base';
-import {
-  Collapsible,
-  CollapsibleContent,
-  CollapsibleTrigger,
-  Slider,
-  Textarea,
-} from '@teable/ui-lib/shadcn';
+import { Textarea } from '@teable/ui-lib/shadcn';
 import { useTranslation } from 'next-i18next';
 import { Fragment, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { AIModelSelect } from '@/features/app/blocks/admin/setting/components/ai-config/AiModelSelect';
 import {
   generateModelKeyList,
   generateGatewayModelKeyList,
-  parseModelKey,
 } from '@/features/app/blocks/admin/setting/components/ai-config/utils';
 import { RequireCom } from '@/features/app/blocks/setting/components/RequireCom';
 import { tableConfig } from '@/features/i18n/table.config';
 import type { IFieldEditorRo } from '../type';
-import { FieldSelect, PromptEditorContainer } from './components';
-
-// Extended model capabilities for UI rendering
-interface IModelCapabilities {
-  supportsSize: boolean;
-  supportsQuality: boolean;
-  supportsCount: boolean;
-  supportsImageInput: boolean;
-  supportsSeed: boolean;
-  supportsStyle: boolean;
-  /** Supports aspect ratio selection (for multimodal LLMs that use prompt-based control) */
-  supportsAspectRatio?: boolean;
-  /** Supports resolution selection (for multimodal LLMs that use prompt-based control) */
-  supportsResolution?: boolean;
-  supportedSizes?: string[];
-  supportedAspectRatios?: string[];
-  /** Supported resolution presets (1K, 2K, 4K) */
-  supportedResolutions?: IImageResolution[];
-  defaultSize?: string;
-  defaultAspectRatio?: string;
-  /** Default resolution preset */
-  defaultResolution?: IImageResolution;
-  maxImagesPerCall?: number;
-  sizeType?: 'size' | 'aspectRatio' | 'both' | 'flexible';
-}
-
-const DEFAULT_CAPABILITIES: IModelCapabilities = {
-  supportsSize: true,
-  supportsQuality: true,
-  supportsCount: true,
-  supportsImageInput: false,
-  supportsSeed: false,
-  supportsStyle: false,
-  defaultSize: '1024x1024',
-};
-
-const MULTIMODAL_LLM_CAPABILITIES: IModelCapabilities = {
-  supportsSize: false,
-  supportsQuality: false,
-  supportsCount: true,
-  supportsImageInput: true,
-  supportsSeed: false,
-  supportsStyle: false,
-  sizeType: 'flexible',
-  // Multimodal LLMs support aspect ratio via prompt instructions (no default - let model decide)
-  supportsAspectRatio: true,
-  supportedAspectRatios: ['1:1', '16:9', '9:16', '4:3', '3:4', '21:9', '3:2', '2:3'],
-  // Multimodal LLMs support resolution via prompt instructions (no default - let model decide)
-  supportsResolution: true,
-  supportedResolutions: ['1K', '2K', '4K'],
-};
-
-/**
- * Get capabilities for legacy (non-gateway) models based on model name
- */
-const getLegacyModelCapabilities = (modelLower: string): IModelCapabilities | null => {
-  if (modelLower.includes('gemini')) return MULTIMODAL_LLM_CAPABILITIES;
-  if (modelLower.includes('gpt-image-1')) {
-    return {
-      ...DEFAULT_CAPABILITIES,
-      supportsStyle: true,
-      supportedSizes: ['1024x1024', '1536x1024', '1024x1536'],
-    };
-  }
-  if (modelLower.includes('dall-e-3')) {
-    return {
-      ...DEFAULT_CAPABILITIES,
-      supportsCount: false,
-      supportsSeed: true,
-      supportsStyle: true,
-      supportedSizes: ['1024x1024', '1792x1024', '1024x1792'],
-      maxImagesPerCall: 1,
-    };
-  }
-  if (modelLower.includes('dall-e-2')) {
-    return {
-      ...DEFAULT_CAPABILITIES,
-      supportsQuality: false,
-      supportedSizes: ['256x256', '512x512', '1024x1024'],
-    };
-  }
-  if (modelLower.includes('grok')) {
-    return { ...DEFAULT_CAPABILITIES, supportsSize: false, supportsQuality: false };
-  }
-  return null;
-};
-
-/**
- * Get model capabilities from the new unified config or fallback to legacy detection
- */
-const getModelCapabilities = (
-  modelKey?: string,
-  gatewayModels?: Array<{ id: string; type?: string; tags?: string[] }>
-): IModelCapabilities => {
-  if (!modelKey) return DEFAULT_CAPABILITIES;
-
-  const { type, model } = parseModelKey(modelKey);
-  const modelLower = model?.toLowerCase() ?? '';
-
-  // For AI Gateway models, try to get config from unified config
-  if (type === LLMProviderType.AI_GATEWAY && model) {
-    const imageConfig = getImageModelConfigByGatewayId(model);
-    if (imageConfig) return mapImageConfigToCapabilities(imageConfig);
-
-    // Fall back to gateway model metadata
-    const gatewayModel = gatewayModels?.find((m) => m.id === model);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const gatewayModelType = (gatewayModel as any)?.modelType || (gatewayModel as any)?.type;
-    const tags = gatewayModel?.tags ?? [];
-
-    if (gatewayModelType === 'language' && tags.includes('image-generation')) {
-      return MULTIMODAL_LLM_CAPABILITIES;
-    }
-    if (gatewayModelType === 'image') {
-      return DEFAULT_CAPABILITIES;
-    }
-  }
-
-  // Legacy detection for non-gateway models
-  if (type === LLMProviderType.GOOGLE) return MULTIMODAL_LLM_CAPABILITIES;
-  return getLegacyModelCapabilities(modelLower) ?? DEFAULT_CAPABILITIES;
-};
-
-/**
- * Map IImageModelConfig to IModelCapabilities
- */
-const mapImageConfigToCapabilities = (config: IImageModelConfig): IModelCapabilities => {
-  // Multimodal LLMs (language models with image-generation tag) support aspect ratio via prompt
-  const isMultimodalLLM =
-    config.modelType === 'language' && (config.tags?.includes('image-generation') ?? false);
-
-  return {
-    supportsSize: config.sizeType === 'size' || config.sizeType === 'both',
-    supportsQuality: config.supportsQuality ?? false,
-    supportsCount: config.maxImagesPerCall !== 1,
-    supportsImageInput: isMultimodalLLM,
-    supportsSeed: config.supportsSeed ?? false,
-    supportsStyle: config.supportsStyle ?? false,
-    // Multimodal LLMs support aspect ratio via prompt instructions (no default - let model decide)
-    supportsAspectRatio: isMultimodalLLM || config.sizeType === 'aspectRatio',
-    // Multimodal LLMs support resolution via prompt instructions (no default - let model decide)
-    supportsResolution: isMultimodalLLM,
-    supportedResolutions: isMultimodalLLM ? ['1K', '2K', '4K'] : undefined,
-    // For multimodal LLMs, don't set defaults - only use values if explicitly specified
-    supportedSizes: config.supportedSizes,
-    supportedAspectRatios: config.supportedAspectRatios,
-    defaultSize: isMultimodalLLM ? undefined : config.defaultSize,
-    defaultAspectRatio: isMultimodalLLM ? undefined : config.defaultAspectRatio,
-    maxImagesPerCall: config.maxImagesPerCall,
-    sizeType: config.sizeType,
-  };
-};
-
-/**
- * Get default settings based on model capabilities
- * For multimodal LLMs (Gemini, etc.), don't set defaults for prompt-based controls - let the model decide
- */
-const getModelDefaults = (
-  capabilities: IModelCapabilities
-): Partial<IAttachmentFieldGenerateImageAIConfig> => ({
-  size: capabilities.supportsSize ? capabilities.defaultSize || '1024x1024' : undefined,
-  quality: capabilities.supportsQuality ? ImageQuality.Medium : undefined,
-  n: capabilities.supportsCount ? 1 : undefined,
-  // Only set aspectRatio/resolution if there's an explicit default (not for multimodal LLMs)
-  aspectRatio: capabilities.supportsAspectRatio ? capabilities.defaultAspectRatio : undefined,
-  resolution: capabilities.supportsResolution ? capabilities.defaultResolution : undefined,
-});
-
-/**
- * Calculate settings updates for initial load (only fill missing values)
- * For multimodal LLMs, don't auto-fill prompt-based controls (aspectRatio, resolution)
- */
-const getInitialLoadUpdates = (
-  capabilities: IModelCapabilities,
-  currentConfig?: IAttachmentFieldGenerateImageAIConfig
-): Partial<IAttachmentFieldGenerateImageAIConfig> => {
-  const updates: Partial<IAttachmentFieldGenerateImageAIConfig> = {};
-
-  if (capabilities.supportsSize && !currentConfig?.size && capabilities.defaultSize) {
-    updates.size = capabilities.defaultSize;
-  }
-  if (capabilities.supportsQuality && currentConfig?.quality === undefined) {
-    updates.quality = ImageQuality.Medium;
-  }
-  if (capabilities.supportsCount && !currentConfig?.n) {
-    updates.n = 1;
-  }
-  // Only auto-fill aspectRatio/resolution if there's an explicit default (not for multimodal LLMs)
-  if (
-    capabilities.supportsAspectRatio &&
-    !currentConfig?.aspectRatio &&
-    capabilities.defaultAspectRatio
-  ) {
-    updates.aspectRatio = capabilities.defaultAspectRatio;
-  }
-  if (
-    capabilities.supportsResolution &&
-    !currentConfig?.resolution &&
-    capabilities.defaultResolution
-  ) {
-    updates.resolution = capabilities.defaultResolution;
-  }
-
-  return updates;
-};
+import { AdvancedImageSettings, FieldSelect, PromptEditorContainer } from './components';
+import { useImageModelUiState } from './hooks';
 
 interface IAttachmentFieldAiConfigProps {
   field: Partial<IFieldEditorRo>;
   onChange?: (partialField: Partial<IFieldEditorRo>) => void;
 }
 
+type IAttachmentAiConfigPatch = Partial<
+  Omit<IAttachmentFieldGenerateImageAIConfig, 'type'> &
+    Omit<IAttachmentFieldCustomizeAIConfig, 'type'>
+>;
+
 export const AttachmentFieldAiConfig = (props: IAttachmentFieldAiConfigProps) => {
   const { field, onChange } = props;
   const { id, aiConfig } = field;
@@ -273,23 +62,27 @@ export const AttachmentFieldAiConfig = (props: IAttachmentFieldAiConfigProps) =>
     ...generateGatewayModelKeyList(gatewayModels),
     ...generateModelKeyList(llmProviders),
   ];
-
-  // Get model capabilities based on the selected model
-  const modelCapabilities = useMemo(
-    () => getModelCapabilities(modelKey, gatewayModels),
-    [modelKey, gatewayModels]
-  );
-
-  // Check if there are any advanced options to show
-  const hasAdvancedOptions = useMemo(() => {
-    return (
-      modelCapabilities.supportsSize ||
-      modelCapabilities.supportsQuality ||
-      modelCapabilities.supportsCount ||
-      modelCapabilities.supportsAspectRatio ||
-      modelCapabilities.supportsResolution
-    );
-  }, [modelCapabilities]);
+  const generateImageAiConfig = aiConfig as IAttachmentFieldGenerateImageAIConfig | undefined;
+
+  const {
+    supportsSize,
+    supportsQuality,
+    supportsCount,
+    supportsAspectRatio,
+    supportsResolution,
+    supportsImageInput,
+    hasAdvancedOptions,
+    imageSizeValues,
+    aspectRatioValues,
+    currentSize,
+    currentQuality,
+    currentCount,
+    currentAspectRatio,
+    currentResolution,
+    maxCount,
+    maxImagesPerCall,
+    getSettingsUpdates,
+  } = useImageModelUiState(modelKey, gatewayModels ?? [], generateImageAiConfig);
 
   const candidates = useMemo(() => {
     return [
@@ -306,68 +99,16 @@ export const AttachmentFieldAiConfig = (props: IAttachmentFieldAiConfigProps) =>
     ];
   }, [t]);
 
-  const onConfigChange = useCallback(
-    (
-      key:
-        | keyof IAttachmentFieldGenerateImageAIConfig
-        | keyof IAttachmentFieldCustomizeAIConfig
-        | 'modelKey',
-      value: unknown
-    ) => {
-      switch (key) {
-        case 'type':
-          return onChange?.({ aiConfig: { type: value } as IAttachmentFieldAIConfig });
-        case 'modelKey':
-          return onChange?.({
-            aiConfig: { ...aiConfig, modelKey: value as string } as IAttachmentFieldAIConfig,
-          });
-        case 'sourceFieldId':
-          return onChange?.({
-            aiConfig: { ...aiConfig, sourceFieldId: value as string } as IAttachmentFieldAIConfig,
-          });
-        case 'size':
-          return onChange?.({
-            aiConfig: { ...aiConfig, size: value as string } as IAttachmentFieldAIConfig,
-          });
-        case 'attachPrompt':
-          return onChange?.({
-            aiConfig: {
-              ...aiConfig,
-              attachPrompt: value as string,
-            } as IAttachmentFieldGenerateImageAIConfig,
-          });
-        case 'n':
-          return onChange?.({
-            aiConfig: { ...aiConfig, n: value as number } as IAttachmentFieldGenerateImageAIConfig,
-          });
-        case 'quality':
-          return onChange?.({
-            aiConfig: {
-              ...aiConfig,
-              quality: value as ImageQuality,
-            } as IAttachmentFieldGenerateImageAIConfig,
-          });
-        case 'aspectRatio':
-          return onChange?.({
-            aiConfig: {
-              ...aiConfig,
-              aspectRatio: value as string,
-            } as IAttachmentFieldGenerateImageAIConfig,
-          });
-        case 'resolution':
-          return onChange?.({
-            aiConfig: {
-              ...aiConfig,
-              resolution: value as IImageResolution,
-            } as IAttachmentFieldGenerateImageAIConfig,
-          });
-        case 'prompt':
-          return onChange?.({
-            aiConfig: { ...aiConfig, prompt: value as string } as IAttachmentFieldCustomizeAIConfig,
-          });
-        default:
-          throw new Error(`Unsupported key: ${key}`);
-      }
+  const setAiConfigType = useCallback(
+    (nextType: FieldAIActionType) => {
+      onChange?.({ aiConfig: { type: nextType } as IAttachmentFieldAIConfig });
+    },
+    [onChange]
+  );
+
+  const patchAiConfig = useCallback(
+    (patch: IAttachmentAiConfigPatch) => {
+      onChange?.({ aiConfig: { ...(aiConfig ?? {}), ...patch } as IAttachmentFieldAIConfig });
     },
     [aiConfig, onChange]
   );
@@ -388,99 +129,17 @@ export const AttachmentFieldAiConfig = (props: IAttachmentFieldAiConfigProps) =>
 
     // When model changes: reset ALL settings to new model's defaults
     // On initial load: only fill in missing values
-    const updates = isModelChanged
-      ? getModelDefaults(modelCapabilities)
-      : getInitialLoadUpdates(
-          modelCapabilities,
-          currentAiConfig as IAttachmentFieldGenerateImageAIConfig
-        );
+    const updates = getSettingsUpdates(
+      isModelChanged,
+      currentAiConfig as IAttachmentFieldGenerateImageAIConfig
+    );
 
     if (Object.keys(updates).length > 0) {
       currentOnChange?.({
         aiConfig: { ...currentAiConfig, ...updates } as IAttachmentFieldAIConfig,
       });
     }
-  }, [modelKey, type, modelCapabilities]);
-
-  const imageSizeCandidates = useMemo(() => {
-    // Use model-specific sizes if available
-    if (modelCapabilities.supportedSizes?.length) {
-      return modelCapabilities.supportedSizes.map((size) => ({ id: size, name: size }));
-    }
-
-    // Default sizes
-    return [
-      { id: '256x256', name: '256x256' },
-      { id: '512x512', name: '512x512' },
-      { id: '1024x1024', name: '1024x1024' },
-      { id: '1536x1024', name: '1536x1024' },
-      { id: '1024x1536', name: '1024x1536' },
-      { id: '1792x1024', name: '1792x1024' },
-      { id: '1024x1792', name: '1024x1792' },
-    ];
-  }, [modelCapabilities.supportedSizes]);
-
-  const qualityCandidates = useMemo(
-    () => [
-      { id: ImageQuality.Low, name: t('table:field.aiConfig.imageQuality.low') },
-      { id: ImageQuality.Medium, name: t('table:field.aiConfig.imageQuality.medium') },
-      { id: ImageQuality.High, name: t('table:field.aiConfig.imageQuality.high') },
-    ],
-    [t]
-  );
-
-  const aspectRatioCandidates = useMemo(() => {
-    const autoOption = { id: '', name: t('table:field.aiConfig.auto') };
-    // Use model-specific aspect ratios if available
-    if (modelCapabilities.supportedAspectRatios?.length) {
-      return [
-        autoOption,
-        ...modelCapabilities.supportedAspectRatios.map((ratio) => ({
-          id: ratio,
-          name: ratio,
-        })),
-      ];
-    }
-    // Default aspect ratios for multimodal LLMs
-    return [
-      autoOption,
-      { id: '1:1', name: '1:1' },
-      { id: '16:9', name: '16:9' },
-      { id: '9:16', name: '9:16' },
-      { id: '4:3', name: '4:3' },
-      { id: '3:4', name: '3:4' },
-      { id: '21:9', name: '21:9' },
-      { id: '3:2', name: '3:2' },
-      { id: '2:3', name: '2:3' },
-    ];
-  }, [modelCapabilities.supportedAspectRatios, t]);
-
-  const resolutionCandidates = useMemo(
-    () => [
-      { id: '', name: t('table:field.aiConfig.auto') },
-      { id: '1K', name: t('table:field.aiConfig.resolution.1K') },
-      { id: '2K', name: t('table:field.aiConfig.resolution.2K') },
-      { id: '4K', name: t('table:field.aiConfig.resolution.4K') },
-    ],
-    [t]
-  );
-
-  // Get current values with defaults
-  const currentSize =
-    (aiConfig as IAttachmentFieldGenerateImageAIConfig)?.size ||
-    modelCapabilities.defaultSize ||
-    '1024x1024';
-  const currentQuality =
-    (aiConfig as IAttachmentFieldGenerateImageAIConfig)?.quality ?? ImageQuality.Medium;
-  const currentCount = (aiConfig as IAttachmentFieldGenerateImageAIConfig)?.n || 1;
-  const maxCount = modelCapabilities.maxImagesPerCall || 10;
-  // For multimodal LLMs, aspectRatio/resolution can be undefined (let model decide)
-  const currentAspectRatio =
-    (aiConfig as IAttachmentFieldGenerateImageAIConfig)?.aspectRatio ||
-    modelCapabilities.defaultAspectRatio;
-  const currentResolution =
-    (aiConfig as IAttachmentFieldGenerateImageAIConfig)?.resolution ||
-    modelCapabilities.defaultResolution;
+  }, [getSettingsUpdates, modelKey, type]);
 
   return (
     <Fragment>
@@ -491,7 +150,7 @@ export const AttachmentFieldAiConfig = (props: IAttachmentFieldAiConfigProps) =>
           placeholder={t('table:field.aiConfig.placeholder.type')}
           selectedId={type}
           onChange={(id) => {
-            onConfigChange('type', id);
+            setAiConfigType(id as FieldAIActionType);
           }}
           candidates={candidates}
           searchTip={t('sdk:common.search.placeholder')}
@@ -510,7 +169,7 @@ export const AttachmentFieldAiConfig = (props: IAttachmentFieldAiConfigProps) =>
             <AIModelSelect
               value={modelKey || ''}
               onValueChange={(newValue) => {
-                onConfigChange('modelKey', newValue);
+                patchAiConfig({ modelKey: newValue });
               }}
               options={models}
               className="w-full px-2"
@@ -525,15 +184,15 @@ export const AttachmentFieldAiConfig = (props: IAttachmentFieldAiConfigProps) =>
               <PromptEditorContainer
                 excludedFieldId={id}
                 value={(aiConfig as IAttachmentFieldCustomizeAIConfig)?.prompt || ''}
-                onChange={(value) => onConfigChange('prompt', value)}
+                onChange={(value) => patchAiConfig({ prompt: value })}
                 label={t('table:field.aiConfig.label.prompt')}
                 placeholder={t('table:field.aiConfig.placeholder.prompt')}
                 required={true}
                 isOptionDisabled={(field) =>
-                  !modelCapabilities.supportsImageInput && field.type === FieldType.Attachment
+                  !supportsImageInput && field.type === FieldType.Attachment
                 }
                 getDisabledReason={(field) =>
-                  !modelCapabilities.supportsImageInput && field.type === FieldType.Attachment
+                  !supportsImageInput && field.type === FieldType.Attachment
                     ? t('table:field.aiConfig.hint.attachmentNotSupported')
                     : undefined
                 }
@@ -549,12 +208,12 @@ export const AttachmentFieldAiConfig = (props: IAttachmentFieldAiConfigProps) =>
                 </span>
                 <FieldSelect
                   excludedIds={id ? [id] : []}
-                  disabledTypes={modelCapabilities.supportsImageInput ? [] : [FieldType.Attachment]}
+                  disabledTypes={supportsImageInput ? [] : [FieldType.Attachment]}
                   disabledReason={t('table:field.aiConfig.hint.attachmentNotSupported')}
                   selectedId={(aiConfig as IAttachmentFieldGenerateImageAIConfig)?.sourceFieldId}
-                  onChange={(fieldId) => onConfigChange('sourceFieldId', fieldId)}
+                  onChange={(fieldId) => patchAiConfig({ sourceFieldId: fieldId })}
                 />
-                {modelCapabilities.supportsImageInput && (
+                {supportsImageInput && (
                   <p className="text-xs text-muted-foreground">
                     {t('table:field.aiConfig.hint.imageInputSupported')}
                   </p>
@@ -569,7 +228,7 @@ export const AttachmentFieldAiConfig = (props: IAttachmentFieldAiConfigProps) =>
                   className="w-full"
                   value={(aiConfig as IAttachmentFieldGenerateImageAIConfig)?.attachPrompt || ''}
                   onChange={(e) => {
-                    onConfigChange('attachPrompt', e.target.value);
+                    patchAiConfig({ attachPrompt: e.target.value });
                   }}
                 />
               </div>
@@ -578,107 +237,25 @@ export const AttachmentFieldAiConfig = (props: IAttachmentFieldAiConfigProps) =>
 
           {/* Advanced Settings - Collapsible (shared by both modes) */}
           {hasAdvancedOptions && (
-            <Collapsible open={advancedOpen} onOpenChange={setAdvancedOpen}>
-              <CollapsibleTrigger className="flex w-full items-center gap-2 rounded-md border px-3 py-2 text-sm hover:bg-muted/50">
-                <Settings className="size-4" />
-                <span className="flex-1 text-left">
-                  {t('table:field.aiConfig.label.advancedSettings')}
-                </span>
-                {advancedOpen ? (
-                  <ChevronDown className="size-4" />
-                ) : (
-                  <ChevronRight className="size-4" />
-                )}
-              </CollapsibleTrigger>
-              <CollapsibleContent className="mt-2 space-y-4 rounded-md border p-3">
-                {/* Image size */}
-                {modelCapabilities.supportsSize && (
-                  <div className="flex flex-col gap-y-2">
-                    <span className="text-sm">{t('table:field.aiConfig.label.imageSize')}</span>
-                    <Selector
-                      className="w-full"
-                      placeholder={t('table:field.aiConfig.placeholder.imageSize')}
-                      selectedId={currentSize}
-                      onChange={(id) => onConfigChange('size', id)}
-                      candidates={imageSizeCandidates}
-                      searchTip={t('sdk:common.search.placeholder')}
-                      emptyTip={t('sdk:common.search.empty')}
-                    />
-                  </div>
-                )}
-
-                {/* Image quality */}
-                {modelCapabilities.supportsQuality && (
-                  <div className="flex flex-col gap-y-2">
-                    <span className="text-sm">{t('table:field.aiConfig.label.imageQuality')}</span>
-                    <Selector
-                      className="w-full"
-                      placeholder={t('table:field.aiConfig.placeholder.imageQuality')}
-                      selectedId={currentQuality}
-                      onChange={(id) => onConfigChange('quality', id)}
-                      candidates={qualityCandidates}
-                      searchTip={t('sdk:common.search.placeholder')}
-                      emptyTip={t('sdk:common.search.empty')}
-                    />
-                  </div>
-                )}
-
-                {/* Aspect ratio (for multimodal LLMs like Gemini) */}
-                {modelCapabilities.supportsAspectRatio && (
-                  <div className="flex flex-col gap-y-2">
-                    <span className="text-sm">{t('table:field.aiConfig.label.aspectRatio')}</span>
-                    <Selector
-                      className="w-full"
-                      placeholder={t('table:field.aiConfig.placeholder.aspectRatio')}
-                      selectedId={currentAspectRatio ?? ''}
-                      onChange={(id) => onConfigChange('aspectRatio', id || undefined)}
-                      candidates={aspectRatioCandidates}
-                      searchTip={t('sdk:common.search.placeholder')}
-                      emptyTip={t('sdk:common.search.empty')}
-                    />
-                  </div>
-                )}
-
-                {/* Resolution (for multimodal LLMs like Gemini) */}
-                {modelCapabilities.supportsResolution && (
-                  <div className="flex flex-col gap-y-2">
-                    <span className="text-sm">{t('table:field.aiConfig.label.resolution')}</span>
-                    <Selector
-                      className="w-full"
-                      placeholder={t('table:field.aiConfig.placeholder.resolution')}
-                      selectedId={currentResolution ?? ''}
-                      onChange={(id) => onConfigChange('resolution', id || undefined)}
-                      candidates={resolutionCandidates}
-                      searchTip={t('sdk:common.search.placeholder')}
-                      emptyTip={t('sdk:common.search.empty')}
-                    />
-                  </div>
-                )}
-
-                {/* Image count */}
-                {modelCapabilities.supportsCount && (
-                  <div className="flex flex-col gap-y-2">
-                    <span className="text-sm">{t('table:field.aiConfig.label.imageCount')}</span>
-                    <div className="flex w-full cursor-pointer justify-between gap-x-4 rounded-md border px-3 py-2">
-                      <Slider
-                        value={[currentCount]}
-                        min={1}
-                        max={maxCount}
-                        step={1}
-                        className="grow"
-                        onValueChange={(value) => onConfigChange('n', Number(value[0]))}
-                      />
-                      <span className="min-w-[24px] text-center">{currentCount}</span>
-                    </div>
-                    {modelCapabilities.maxImagesPerCall === 1 && (
-                      <p className="text-xs text-muted-foreground">
-                        {t('table:field.aiConfig.hint.singleImageOnly')}
-                      </p>
-                    )}
-                  </div>
-                )}
-              </CollapsibleContent>
-            </Collapsible>
+            <AdvancedImageSettings
+              open={advancedOpen}
+              onOpenChange={setAdvancedOpen}
+              supportsSize={supportsSize}
+              supportsQuality={supportsQuality}
+              supportsAspectRatio={supportsAspectRatio}
+              supportsResolution={supportsResolution}
+              supportsCount={supportsCount}
+              imageSizeValues={imageSizeValues}
+              aspectRatioValues={aspectRatioValues}
+              currentSize={currentSize}
+              currentQuality={currentQuality}
+              currentAspectRatio={currentAspectRatio}
+              currentResolution={currentResolution}
+              currentCount={currentCount}
+              maxCount={maxCount}
+              maxImagesPerCall={maxImagesPerCall}
+              onChange={patchAiConfig}
+            />
           )}
         </Fragment>
       )}
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/components/advanced-image-settings/AdvancedImageSettings.tsx b/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/components/advanced-image-settings/AdvancedImageSettings.tsx
new file mode 100644
index 0000000000..50aa667506
--- /dev/null
+++ b/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/components/advanced-image-settings/AdvancedImageSettings.tsx
@@ -0,0 +1,197 @@
+import type { IAttachmentFieldGenerateImageAIConfig } from '@teable/core';
+import { IMAGE_RESOLUTIONS, ImageQuality } from '@teable/core';
+import { ChevronDown, ChevronRight, Settings } from '@teable/icons';
+import { DEFAULT_ASPECT_RATIO_CANDIDATES } from '@teable/openapi';
+import type { IAspectRatio, IImageSize } from '@teable/openapi';
+import { Selector } from '@teable/ui-lib/base';
+import { Collapsible, CollapsibleContent, CollapsibleTrigger, Slider } from '@teable/ui-lib/shadcn';
+import { useTranslation } from 'next-i18next';
+import { useMemo } from 'react';
+import { tableConfig } from '@/features/i18n/table.config';
+
+type IGenerateImageConfigPatch = Partial<Omit<IAttachmentFieldGenerateImageAIConfig, 'type'>>;
+
+interface IAdvancedImageSettingsProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  supportsSize: boolean;
+  supportsQuality: boolean;
+  supportsAspectRatio: boolean;
+  supportsResolution: boolean;
+  supportsCount: boolean;
+  imageSizeValues: IImageSize[];
+  aspectRatioValues: IAspectRatio[];
+  currentSize: string;
+  currentQuality: ImageQuality;
+  currentAspectRatio?: string;
+  currentResolution?: IAttachmentFieldGenerateImageAIConfig['resolution'];
+  currentCount: number;
+  maxCount: number;
+  maxImagesPerCall?: number;
+  onChange: (patch: IGenerateImageConfigPatch) => void;
+}
+
+export const AdvancedImageSettings = (props: IAdvancedImageSettingsProps) => {
+  const {
+    open,
+    onOpenChange,
+    supportsSize,
+    supportsQuality,
+    supportsAspectRatio,
+    supportsResolution,
+    supportsCount,
+    imageSizeValues,
+    aspectRatioValues,
+    currentSize,
+    currentQuality,
+    currentAspectRatio,
+    currentResolution,
+    currentCount,
+    maxCount,
+    maxImagesPerCall,
+    onChange,
+  } = props;
+  const { t } = useTranslation(tableConfig.i18nNamespaces);
+
+  const imageSizeCandidates = useMemo(() => {
+    return imageSizeValues.map((size) => ({ id: size, name: size }));
+  }, [imageSizeValues]);
+
+  const qualityCandidates = useMemo(
+    () => [
+      { id: ImageQuality.Low, name: t('table:field.aiConfig.imageQuality.low') },
+      { id: ImageQuality.Medium, name: t('table:field.aiConfig.imageQuality.medium') },
+      { id: ImageQuality.High, name: t('table:field.aiConfig.imageQuality.high') },
+    ],
+    [t]
+  );
+
+  const aspectRatioCandidates = useMemo(() => {
+    const autoOption = { id: '', name: t('table:field.aiConfig.auto') };
+    const ratios = aspectRatioValues.length ? aspectRatioValues : DEFAULT_ASPECT_RATIO_CANDIDATES;
+
+    return [
+      autoOption,
+      ...ratios.map((ratio) => ({
+        id: ratio,
+        name: ratio,
+      })),
+    ];
+  }, [aspectRatioValues, t]);
+
+  const resolutionCandidates = useMemo(
+    () => [
+      { id: '', name: t('table:field.aiConfig.auto') },
+      ...IMAGE_RESOLUTIONS.map((resolution) => ({
+        id: resolution,
+        name: t(`table:field.aiConfig.resolution.${resolution}`),
+      })),
+    ],
+    [t]
+  );
+
+  return (
+    <Collapsible open={open} onOpenChange={onOpenChange}>
+      <CollapsibleTrigger className="flex w-full items-center gap-2 rounded-md border px-3 py-2 text-sm hover:bg-muted/50">
+        <Settings className="size-4" />
+        <span className="flex-1 text-left">{t('table:field.aiConfig.label.advancedSettings')}</span>
+        {open ? <ChevronDown className="size-4" /> : <ChevronRight className="size-4" />}
+      </CollapsibleTrigger>
+      <CollapsibleContent className="mt-2 space-y-4 rounded-md border p-3">
+        {supportsSize && (
+          <div className="flex flex-col gap-y-2">
+            <span className="text-sm">{t('table:field.aiConfig.label.imageSize')}</span>
+            <Selector
+              className="w-full"
+              placeholder={t('table:field.aiConfig.placeholder.imageSize')}
+              selectedId={currentSize}
+              onChange={(id) =>
+                onChange({ size: id as IAttachmentFieldGenerateImageAIConfig['size'] })
+              }
+              candidates={imageSizeCandidates}
+              searchTip={t('sdk:common.search.placeholder')}
+              emptyTip={t('sdk:common.search.empty')}
+            />
+          </div>
+        )}
+
+        {supportsQuality && (
+          <div className="flex flex-col gap-y-2">
+            <span className="text-sm">{t('table:field.aiConfig.label.imageQuality')}</span>
+            <Selector
+              className="w-full"
+              placeholder={t('table:field.aiConfig.placeholder.imageQuality')}
+              selectedId={currentQuality}
+              onChange={(id) => onChange({ quality: id as ImageQuality })}
+              candidates={qualityCandidates}
+              searchTip={t('sdk:common.search.placeholder')}
+              emptyTip={t('sdk:common.search.empty')}
+            />
+          </div>
+        )}
+
+        {supportsAspectRatio && (
+          <div className="flex flex-col gap-y-2">
+            <span className="text-sm">{t('table:field.aiConfig.label.aspectRatio')}</span>
+            <Selector
+              className="w-full"
+              placeholder={t('table:field.aiConfig.placeholder.aspectRatio')}
+              selectedId={currentAspectRatio ?? ''}
+              onChange={(id) =>
+                onChange({
+                  aspectRatio: (id ||
+                    undefined) as IAttachmentFieldGenerateImageAIConfig['aspectRatio'],
+                })
+              }
+              candidates={aspectRatioCandidates}
+              searchTip={t('sdk:common.search.placeholder')}
+              emptyTip={t('sdk:common.search.empty')}
+            />
+          </div>
+        )}
+
+        {supportsResolution && (
+          <div className="flex flex-col gap-y-2">
+            <span className="text-sm">{t('table:field.aiConfig.label.resolution')}</span>
+            <Selector
+              className="w-full"
+              placeholder={t('table:field.aiConfig.placeholder.resolution')}
+              selectedId={currentResolution ?? ''}
+              onChange={(id) =>
+                onChange({
+                  resolution: (id ||
+                    undefined) as IAttachmentFieldGenerateImageAIConfig['resolution'],
+                })
+              }
+              candidates={resolutionCandidates}
+              searchTip={t('sdk:common.search.placeholder')}
+              emptyTip={t('sdk:common.search.empty')}
+            />
+          </div>
+        )}
+
+        {supportsCount && (
+          <div className="flex flex-col gap-y-2">
+            <span className="text-sm">{t('table:field.aiConfig.label.imageCount')}</span>
+            <div className="flex w-full cursor-pointer justify-between gap-x-4 rounded-md border px-3 py-2">
+              <Slider
+                value={[currentCount]}
+                min={1}
+                max={maxCount}
+                step={1}
+                className="grow"
+                onValueChange={(value) => onChange({ n: Number(value[0]) })}
+              />
+              <span className="min-w-[24px] text-center">{currentCount}</span>
+            </div>
+            {maxImagesPerCall === 1 && (
+              <p className="text-xs text-muted-foreground">
+                {t('table:field.aiConfig.hint.singleImageOnly')}
+              </p>
+            )}
+          </div>
+        )}
+      </CollapsibleContent>
+    </Collapsible>
+  );
+};
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/components/advanced-image-settings/index.ts b/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/components/advanced-image-settings/index.ts
new file mode 100644
index 0000000000..5e21c75822
--- /dev/null
+++ b/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/components/advanced-image-settings/index.ts
@@ -0,0 +1 @@
+export * from './AdvancedImageSettings';
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/components/index.ts b/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/components/index.ts
index 6e694ec24a..cc4ae3d048 100644
--- a/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/components/index.ts
+++ b/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/components/index.ts
@@ -1,2 +1,3 @@
+export * from './advanced-image-settings';
 export * from './field-select';
 export * from './prompt-editor';
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/hooks/index.ts b/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/hooks/index.ts
new file mode 100644
index 0000000000..00a50850f4
--- /dev/null
+++ b/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/hooks/index.ts
@@ -0,0 +1 @@
+export * from './useImageModelUiState';
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/hooks/useImageModelUiState.ts b/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/hooks/useImageModelUiState.ts
new file mode 100644
index 0000000000..de0a3fdcd8
--- /dev/null
+++ b/apps/nextjs-app/src/features/app/components/field-setting/field-ai-config/hooks/useImageModelUiState.ts
@@ -0,0 +1,139 @@
+import type { IAttachmentFieldGenerateImageAIConfig } from '@teable/core';
+import { ImageQuality } from '@teable/core';
+import {
+  getImageAspectRatioCandidates,
+  getImageModelConfigByModelKey,
+  getImageSizeCandidates,
+  isPromptControlledImageGenerationModel,
+  supportsImageAspectRatioSelection,
+  supportsImageCountSelection,
+  supportsImageInputForImageModel,
+  supportsImageSizeSelection,
+} from '@teable/openapi';
+import type { IImageModelMetadata, IResolvedImageModelConfig } from '@teable/openapi';
+import { useCallback, useMemo } from 'react';
+
+const getModelDefaults = (
+  resolvedModel?: IResolvedImageModelConfig
+): Partial<IAttachmentFieldGenerateImageAIConfig> => {
+  const config = resolvedModel?.config;
+  if (!config) return {};
+
+  const isPromptControlledModel = isPromptControlledImageGenerationModel(config);
+  const sizeCandidates = getImageSizeCandidates(config);
+
+  return {
+    size: supportsImageSizeSelection(config) ? config.defaultSize ?? sizeCandidates[0] : undefined,
+    quality: config.supportsQuality ? ImageQuality.Medium : undefined,
+    n: supportsImageCountSelection(config) ? 1 : undefined,
+    aspectRatio:
+      supportsImageAspectRatioSelection(config) && !isPromptControlledModel
+        ? config.defaultAspectRatio
+        : undefined,
+  };
+};
+
+const getInitialLoadUpdates = (
+  resolvedModel?: IResolvedImageModelConfig,
+  currentConfig?: IAttachmentFieldGenerateImageAIConfig
+): Partial<IAttachmentFieldGenerateImageAIConfig> => {
+  const config = resolvedModel?.config;
+  if (!config) return {};
+
+  const updates: Partial<IAttachmentFieldGenerateImageAIConfig> = {};
+  const isPromptControlledModel = isPromptControlledImageGenerationModel(config);
+  const sizeCandidates = getImageSizeCandidates(config);
+  const defaultSize = config.defaultSize ?? sizeCandidates[0];
+
+  if (supportsImageSizeSelection(config) && !currentConfig?.size && defaultSize) {
+    updates.size = defaultSize;
+  }
+  if (config.supportsQuality && currentConfig?.quality === undefined) {
+    updates.quality = ImageQuality.Medium;
+  }
+  if (supportsImageCountSelection(config) && !currentConfig?.n) {
+    updates.n = 1;
+  }
+  if (
+    supportsImageAspectRatioSelection(config) &&
+    !isPromptControlledModel &&
+    !currentConfig?.aspectRatio &&
+    config.defaultAspectRatio
+  ) {
+    updates.aspectRatio = config.defaultAspectRatio;
+  }
+
+  return updates;
+};
+
+export const useImageModelUiState = (
+  modelKey?: string,
+  gatewayModels: readonly IImageModelMetadata[] = [],
+  aiConfig?: IAttachmentFieldGenerateImageAIConfig
+) => {
+  const resolvedImageModel = useMemo(
+    () => getImageModelConfigByModelKey(modelKey, gatewayModels),
+    [modelKey, gatewayModels]
+  );
+  const imageModelConfig = resolvedImageModel?.config;
+  const isPromptControlledModel = imageModelConfig
+    ? isPromptControlledImageGenerationModel(imageModelConfig)
+    : false;
+
+  const supportsSize = imageModelConfig ? supportsImageSizeSelection(imageModelConfig) : false;
+  const supportsQuality = imageModelConfig?.supportsQuality ?? false;
+  const supportsCount = imageModelConfig ? supportsImageCountSelection(imageModelConfig) : false;
+  const supportsAspectRatio = imageModelConfig
+    ? supportsImageAspectRatioSelection(imageModelConfig)
+    : false;
+  const supportsResolution = isPromptControlledModel;
+  const supportsImageInput = resolvedImageModel
+    ? supportsImageInputForImageModel(
+        resolvedImageModel.config,
+        resolvedImageModel.modelId,
+        resolvedImageModel.tags
+      )
+    : false;
+  const hasAdvancedOptions =
+    supportsSize || supportsQuality || supportsCount || supportsAspectRatio || supportsResolution;
+
+  const imageSizeValues = useMemo(
+    () => (imageModelConfig ? getImageSizeCandidates(imageModelConfig) : []),
+    [imageModelConfig]
+  );
+  const aspectRatioValues = useMemo(
+    () => (imageModelConfig ? getImageAspectRatioCandidates(imageModelConfig) : []),
+    [imageModelConfig]
+  );
+
+  const getSettingsUpdates = useCallback(
+    (isModelChanged: boolean, currentConfig?: IAttachmentFieldGenerateImageAIConfig) => {
+      return isModelChanged
+        ? getModelDefaults(resolvedImageModel)
+        : getInitialLoadUpdates(resolvedImageModel, currentConfig);
+    },
+    [resolvedImageModel]
+  );
+
+  return {
+    imageModelConfig,
+    supportsSize,
+    supportsQuality,
+    supportsCount,
+    supportsAspectRatio,
+    supportsResolution,
+    supportsImageInput,
+    hasAdvancedOptions,
+    imageSizeValues,
+    aspectRatioValues,
+    currentSize:
+      aiConfig?.size || imageModelConfig?.defaultSize || imageSizeValues[0] || '1024x1024',
+    currentQuality: aiConfig?.quality ?? ImageQuality.Medium,
+    currentCount: aiConfig?.n || 1,
+    currentAspectRatio: aiConfig?.aspectRatio || imageModelConfig?.defaultAspectRatio,
+    currentResolution: aiConfig?.resolution,
+    maxCount: imageModelConfig?.maxImagesPerCall || 10,
+    maxImagesPerCall: imageModelConfig?.maxImagesPerCall,
+    getSettingsUpdates,
+  };
+};
diff --git a/apps/nextjs-app/src/features/app/components/oauth/OAuthScope.tsx b/apps/nextjs-app/src/features/app/components/oauth/OAuthScope.tsx
index c0706380d5..d07a754cf3 100644
--- a/apps/nextjs-app/src/features/app/components/oauth/OAuthScope.tsx
+++ b/apps/nextjs-app/src/features/app/components/oauth/OAuthScope.tsx
@@ -34,8 +34,10 @@ export const OAuthScope = (props: {
           if (!actionStaticMap) {
             return acc;
           }
+          const entry = actionStaticMap[scope as Action];
+          if (!entry) return acc;
           const prefix = scope.split('|')[0] as ActionPrefix;
-          const scopeDesc = actionStaticMap[scope as Action].description;
+          const scopeDesc = entry.description;
           if (acc[prefix]) {
             acc[prefix].push(scopeDesc);
           } else {
diff --git a/apps/nextjs-app/src/features/app/components/setting/Account.tsx b/apps/nextjs-app/src/features/app/components/setting/Account.tsx
index 46880bb6b7..c971d48a97 100644
--- a/apps/nextjs-app/src/features/app/components/setting/Account.tsx
+++ b/apps/nextjs-app/src/features/app/components/setting/Account.tsx
@@ -104,9 +104,9 @@ export const Account: React.FC = () => {
                 </Tooltip>
               </TooltipProvider>
             )}
-            <div className="flex-1 pt-4">
+            <div className="flex flex-1 flex-col gap-2 pt-4">
               <Input
-                className="max-w-[320px]"
+                className="w-full px-3 sm:max-w-sm"
                 defaultValue={sessionUser.name}
                 onBlur={(e) => toggleRenameUser(e)}
               />
diff --git a/apps/nextjs-app/src/features/app/components/setting/SettingDialog.tsx b/apps/nextjs-app/src/features/app/components/setting/SettingDialog.tsx
index 522980060f..804cf91cfe 100644
--- a/apps/nextjs-app/src/features/app/components/setting/SettingDialog.tsx
+++ b/apps/nextjs-app/src/features/app/components/setting/SettingDialog.tsx
@@ -1,131 +1,17 @@
-import { Bell, Key, Link, Lock, Settings, User } from '@teable/icons';
 import { useIsTouchDevice } from '@teable/sdk/hooks';
-import {
-  Dialog,
-  DialogContent,
-  Sheet,
-  SheetContent,
-  Tabs,
-  TabsContent,
-  TabsList,
-  TabsTrigger,
-} from '@teable/ui-lib/shadcn';
-import { useTranslation } from 'next-i18next';
-import { useMemo } from 'react';
-import { System } from '@/features/app/components/setting/System';
-import { settingConfig } from '@/features/i18n/setting.config';
-import { Account } from './Account';
-import { Integration } from './integration/Integration';
-import { Notifications } from './Notifications';
-import { OAuthAppSection } from './oauth-app';
-import { PersonalAccessTokenSection } from './personal-access-token';
+import { Dialog, DialogContent, Sheet, SheetContent } from '@teable/ui-lib/shadcn';
+import { UnifiedSettingDialogContent } from './UnifiedSettingDialogContent';
 import { SettingTab, useSettingStore } from './useSettingStore';
 
-export const SettingDialog = () => {
-  const { t } = useTranslation(settingConfig.i18nNamespaces);
+export interface ISettingDialogProps {
+  spaceId?: string;
+  includeSpaceSettings?: boolean;
+}
+
+export const SettingDialog = ({ spaceId, includeSpaceSettings = true }: ISettingDialogProps) => {
   const isTouchDevice = useIsTouchDevice();
   const { open, setOpen, tab, setTab } = useSettingStore();
-
-  const tabList = useMemo(() => {
-    return [
-      {
-        key: SettingTab.Profile,
-        name: t('settings.account.tab'),
-        Icon: User,
-      },
-      {
-        key: SettingTab.System,
-        name: t('settings.setting.title'),
-        Icon: Settings,
-      },
-      {
-        key: SettingTab.Notifications,
-        name: t('settings.notify.title'),
-        Icon: Bell,
-      },
-      {
-        key: SettingTab.Integration,
-        name: t('settings.integration.title'),
-        Icon: Link,
-      },
-      {
-        key: SettingTab.PersonalAccessToken,
-        name: t('setting:personalAccessToken'),
-        Icon: Key,
-      },
-      {
-        key: SettingTab.OAuthApp,
-        name: t('setting:oauthApps'),
-        Icon: Lock,
-      },
-    ];
-  }, [t]);
-
-  const content = (
-    <Tabs
-      defaultValue={SettingTab.Profile}
-      value={tab}
-      onValueChange={(value) => setTab(value as SettingTab)}
-      className="flex h-full gap-0 overflow-hidden"
-    >
-      <TabsList className="flex h-full w-fit max-w-72 flex-col items-start justify-start gap-1 rounded-none border-none bg-muted p-4">
-        {tabList.map(({ key, name, Icon }) => {
-          return (
-            <TabsTrigger
-              key={key}
-              value={key}
-              className="h-8 w-full cursor-pointer justify-start gap-2 rounded-md font-normal data-[state=active]:bg-surface data-[state=active]:font-medium data-[state=active]:shadow-none hover:bg-surface"
-            >
-              <Icon className="size-5 shrink-0 sm:size-4" />
-              <span className="hidden sm:inline">{name}</span>
-            </TabsTrigger>
-          );
-        })}
-      </TabsList>
-      <TabsContent
-        tabIndex={-1}
-        value={SettingTab.Profile}
-        className="mt-0 size-full overflow-y-auto overflow-x-hidden"
-      >
-        <Account />
-      </TabsContent>
-      <TabsContent
-        tabIndex={-1}
-        value={SettingTab.System}
-        className="mt-0 size-full overflow-y-auto overflow-x-hidden"
-      >
-        <System />
-      </TabsContent>
-      <TabsContent
-        tabIndex={-1}
-        value={SettingTab.Notifications}
-        className="mt-0 size-full overflow-y-auto overflow-x-hidden"
-      >
-        <Notifications />
-      </TabsContent>
-      <TabsContent
-        tabIndex={-1}
-        value={SettingTab.Integration}
-        className="mt-0 size-full overflow-y-auto overflow-x-hidden"
-      >
-        <Integration />
-      </TabsContent>
-      <TabsContent
-        tabIndex={-1}
-        value={SettingTab.PersonalAccessToken}
-        className="mt-0 size-full overflow-y-auto overflow-x-hidden"
-      >
-        <PersonalAccessTokenSection />
-      </TabsContent>
-      <TabsContent
-        tabIndex={-1}
-        value={SettingTab.OAuthApp}
-        className="mt-0 size-full overflow-y-auto overflow-x-hidden"
-      >
-        <OAuthAppSection />
-      </TabsContent>
-    </Tabs>
-  );
+  const activeTab = tab ?? SettingTab.Profile;
 
   return (
     <>
@@ -135,7 +21,14 @@ export const SettingDialog = () => {
             className="h-5/6 rounded-t-lg px-1 pb-0 pt-4 [&>button]:right-4 [&>button]:top-4 "
             side="bottom"
           >
-            {content}
+            <UnifiedSettingDialogContent
+              tab={activeTab}
+              onTabChange={setTab}
+              entry="personal"
+              defaultTab={SettingTab.Profile}
+              spaceId={spaceId}
+              includeSpaceSettings={includeSpaceSettings}
+            />
           </SheetContent>
         </Sheet>
       ) : (
@@ -144,7 +37,14 @@ export const SettingDialog = () => {
             className="h-4/5 max-h-[80vh] max-w-6xl overflow-hidden p-0 [&>button]:right-4 [&>button]:top-4 "
             onOpenAutoFocus={(e) => e.preventDefault()}
           >
-            {content}
+            <UnifiedSettingDialogContent
+              tab={activeTab}
+              onTabChange={setTab}
+              entry="personal"
+              defaultTab={SettingTab.Profile}
+              spaceId={spaceId}
+              includeSpaceSettings={includeSpaceSettings}
+            />
           </DialogContent>
         </Dialog>
       )}
diff --git a/apps/nextjs-app/src/features/app/components/setting/SettingTabShell.tsx b/apps/nextjs-app/src/features/app/components/setting/SettingTabShell.tsx
index 8ecabe5457..4f26b2d2b7 100644
--- a/apps/nextjs-app/src/features/app/components/setting/SettingTabShell.tsx
+++ b/apps/nextjs-app/src/features/app/components/setting/SettingTabShell.tsx
@@ -34,17 +34,17 @@ export const SettingTabHeader = ({
   return (
     <div
       className={cn(
-        'flex w-full justify-between gap-4',
+        'flex w-full justify-between gap-6',
         hasDescription ? 'items-start' : 'items-center',
         className
       )}
     >
-      <div className={cn('flex flex-1 gap-2', hasDescription ? 'items-start' : 'items-center')}>
+      <div className={cn('flex flex-1 gap-3', hasDescription ? 'items-start' : 'items-center')}>
         {leading}
-        <div className="flex flex-col gap-1">
-          <div className={cn('text-base font-semibold leading-6', titleClassName)}>{title}</div>
+        <div className="flex flex-col gap-1.5">
+          <div className={cn('text-lg font-semibold leading-7', titleClassName)}>{title}</div>
           {description && (
-            <div className={cn('line-clamp-2 text-sm text-muted-foreground', descriptionClassName)}>
+            <div className={cn('text-sm text-muted-foreground', descriptionClassName)}>
               {description}
             </div>
           )}
@@ -67,16 +67,11 @@ export const SettingTabShell = ({
   footerClassName,
 }: SettingTabShellProps) => {
   return (
-    <div
-      className={cn(
-        'teable-setting-tab-shell flex h-full flex-col border-l bg-background',
-        className
-      )}
-    >
+    <div className={cn('teable-setting-tab-shell flex h-full flex-col bg-background', className)}>
       {header && (
         <div
           className={cn(
-            'teable-setting-tab-shell__header flex items-start justify-between gap-3 border-b pl-6 py-3 pr-10',
+            'teable-setting-tab-shell__header flex items-start justify-between gap-3 px-4 pb-4 pt-4 pr-16 sm:px-6 sm:pb-6 sm:pt-6 sm:pr-12',
             headerClassName
           )}
         >
@@ -85,13 +80,15 @@ export const SettingTabShell = ({
       )}
       <div
         className={cn(
-          'teable-setting-tab-shell__content flex-1 overflow-y-auto px-6 py-4',
+          'teable-setting-tab-shell__content flex-1 overflow-y-auto px-4 sm:px-6',
           contentClassName
         )}
       >
         {children}
       </div>
-      {footer && <div className={cn('px-8 py-4', footerClassName)}>{footer}</div>}
+      {footer && (
+        <div className={cn('px-4 pb-4 pt-4 sm:px-6 sm:pb-6', footerClassName)}>{footer}</div>
+      )}
     </div>
   );
 };
diff --git a/apps/nextjs-app/src/features/app/components/setting/System.tsx b/apps/nextjs-app/src/features/app/components/setting/System.tsx
index 257faf8c88..038bec451c 100644
--- a/apps/nextjs-app/src/features/app/components/setting/System.tsx
+++ b/apps/nextjs-app/src/features/app/components/setting/System.tsx
@@ -37,57 +37,57 @@ export const System: React.FC = () => {
               setTheme(value);
             }}
           >
-            <div className="w-[206px]">
+            <div className="max-w-[256px]">
               <RadioGroupItem value="light" id="light" className="peer sr-only" />
               <Label
                 htmlFor="light"
                 className="flex cursor-pointer flex-col rounded-lg border-2 border-transparent bg-popover p-1 peer-data-[state=checked]:border-primary peer-data-[state=checked]:shadow-[0_4px_12px_rgba(0,0,0,0.08),0_2px_2px_rgba(0,0,0,0.06)] hover:bg-accent hover:text-accent-foreground [&:has([data-state=checked])]:border-primary"
               >
                 <Image
-                  className="overflow-hidden rounded-md border"
+                  className="w-full overflow-hidden rounded-md border"
                   src={'/images/theme/theme-light.png'}
                   alt=""
                   width={198}
                   height={132}
                 />
               </Label>
-              <span className="mt-1 block w-full text-center text-sm font-normal">
+              <span className="mt-2 block w-full text-center text-sm font-normal">
                 {t('settings.setting.light')}
               </span>
             </div>
-            <div className="w-[206px]">
+            <div className="max-w-[256px]">
               <RadioGroupItem value="dark" id="dark" className="peer sr-only" />
               <Label
                 htmlFor="dark"
                 className="flex cursor-pointer flex-col rounded-lg border-2 border-transparent bg-popover p-1 peer-data-[state=checked]:border-primary peer-data-[state=checked]:shadow-[0_4px_12px_rgba(0,0,0,0.08),0_2px_2px_rgba(0,0,0,0.06)] hover:bg-accent hover:text-accent-foreground [&:has([data-state=checked])]:border-primary"
               >
                 <Image
-                  className="overflow-hidden rounded-md border"
+                  className="w-full overflow-hidden rounded-md border"
                   src={'/images/theme/theme-dark.png'}
                   alt=""
                   width={198}
                   height={132}
                 />
               </Label>
-              <span className="mt-1 block w-full text-center text-sm font-normal">
+              <span className="mt-2 block w-full text-center text-sm font-normal">
                 {t('settings.setting.dark')}
               </span>
             </div>
-            <div className="w-[206px]">
+            <div className="max-w-[256px]">
               <RadioGroupItem value="system" id="system" className="peer sr-only" />
               <Label
                 htmlFor="system"
                 className="flex cursor-pointer flex-col rounded-lg border-2 border-transparent bg-popover p-1 peer-data-[state=checked]:border-primary peer-data-[state=checked]:shadow-[0_4px_12px_rgba(0,0,0,0.08),0_2px_2px_rgba(0,0,0,0.06)] hover:bg-accent hover:text-accent-foreground [&:has([data-state=checked])]:border-primary"
               >
                 <Image
-                  className="overflow-hidden rounded-md border"
+                  className="w-full overflow-hidden rounded-md border"
                   src={'/images/theme/theme-system.png'}
                   alt=""
                   width={198}
                   height={132}
                 />
               </Label>
-              <span className="mt-1 block w-full text-center text-sm font-normal">
+              <span className="mt-2 block w-full text-center text-sm font-normal">
                 {t('settings.setting.system')}
               </span>
             </div>
diff --git a/apps/nextjs-app/src/features/app/components/setting/UnifiedSettingDialogContent.tsx b/apps/nextjs-app/src/features/app/components/setting/UnifiedSettingDialogContent.tsx
new file mode 100644
index 0000000000..e448183fb3
--- /dev/null
+++ b/apps/nextjs-app/src/features/app/components/setting/UnifiedSettingDialogContent.tsx
@@ -0,0 +1,314 @@
+import { useQuery } from '@tanstack/react-query';
+import { Role } from '@teable/core';
+import { Bell, Key, Link, Lock, Settings, User } from '@teable/icons';
+import { getSpaceById } from '@teable/openapi';
+import { ReactQueryKeys } from '@teable/sdk/config';
+import { useBase, useSession } from '@teable/sdk/hooks';
+import { Tabs, TabsContent, TabsList, TabsTrigger, cn } from '@teable/ui-lib/shadcn';
+import { uniq } from 'lodash';
+import { Settings2, Users } from 'lucide-react';
+import { useParams } from 'next/navigation';
+import { useTranslation } from 'next-i18next';
+import type { ElementType, ReactElement, ReactNode } from 'react';
+import { useEffect, useMemo } from 'react';
+import { CollaboratorPage } from '@/features/app/blocks/space-setting/collaborator';
+import { GeneralPage } from '@/features/app/blocks/space-setting/general';
+import { SpaceSettingTab } from '@/features/app/blocks/space-setting/types';
+import { Account } from '@/features/app/components/setting/Account';
+import { Integration } from '@/features/app/components/setting/integration/Integration';
+import { Notifications } from '@/features/app/components/setting/Notifications';
+import { OAuthAppSection } from '@/features/app/components/setting/oauth-app';
+import { PersonalAccessTokenSection } from '@/features/app/components/setting/personal-access-token';
+import { System } from '@/features/app/components/setting/System';
+import { SettingTab as PersonalSettingTab } from '@/features/app/components/setting/useSettingStore';
+import { SpaceAvatar } from '@/features/app/components/space/SpaceAvatar';
+import { UserAvatar } from '@/features/app/components/user/UserAvatar';
+import { settingConfig } from '@/features/i18n/setting.config';
+import { spaceConfig } from '@/features/i18n/space.config';
+
+export type UnifiedSettingKnownTab = PersonalSettingTab | SpaceSettingTab;
+export type UnifiedSettingTab = string;
+
+export interface IUnifiedSettingListItem {
+  key: UnifiedSettingTab;
+  name: string;
+  Icon: ElementType;
+  badge?: ReactNode;
+  disabled?: boolean;
+  content: ReactNode | ((ctx: IUnifiedSettingRenderContext) => ReactNode);
+  contentClassName?: string;
+}
+
+export interface IUnifiedSettingRenderContext {
+  onTabChange: (tab: UnifiedSettingTab) => void;
+  resolvedSpaceId?: string;
+  showSidebar: boolean;
+}
+
+export interface IUnifiedSettingTriggerOverrides {
+  badge?: ReactNode;
+  disabled?: boolean;
+}
+
+interface IUnifiedSettingGroup {
+  key: 'personal' | 'space';
+  title: string;
+  entity: ReactNode;
+  tabs: IUnifiedSettingListItem[];
+}
+
+export interface IUnifiedSettingDialogContentProps {
+  tab: UnifiedSettingTab;
+  onTabChange: (tab: UnifiedSettingTab) => void;
+  entry: 'personal' | 'space';
+  defaultTab: UnifiedSettingTab;
+  contentOnly?: boolean;
+  spaceId?: string;
+  includeSpaceSettings?: boolean;
+  extraPersonalTabs?: IUnifiedSettingListItem[];
+  extraSpaceTabs?: IUnifiedSettingListItem[];
+  renderTabTrigger?: (
+    item: IUnifiedSettingListItem,
+    ctx: IUnifiedSettingRenderContext,
+    renderDefaultTrigger: (overrides?: IUnifiedSettingTriggerOverrides) => ReactElement
+  ) => ReactElement;
+}
+
+export const UnifiedSettingDialogContent = ({
+  tab,
+  onTabChange,
+  entry,
+  defaultTab,
+  contentOnly = false,
+  spaceId: spaceIdProp,
+  includeSpaceSettings = true,
+  extraPersonalTabs,
+  extraSpaceTabs,
+  renderTabTrigger,
+}: IUnifiedSettingDialogContentProps) => {
+  const { t } = useTranslation(
+    uniq([...settingConfig.i18nNamespaces, ...spaceConfig.i18nNamespaces])
+  );
+  const { user } = useSession();
+  const routeParams = useParams<{ spaceId?: string }>();
+  const base = useBase() as { spaceId?: string } | undefined;
+  const resolvedSpaceId = includeSpaceSettings
+    ? spaceIdProp ?? routeParams?.spaceId ?? base?.spaceId
+    : undefined;
+
+  const { data: space } = useQuery({
+    queryKey: ReactQueryKeys.space(resolvedSpaceId as string),
+    queryFn: ({ queryKey }) => getSpaceById(queryKey[1] as string).then((res) => res.data),
+    enabled: Boolean(resolvedSpaceId),
+  });
+
+  const canAccessSpaceSettings = includeSpaceSettings && space?.role === Role.Owner;
+  const isSpaceEntry = entry === 'space' && Boolean(resolvedSpaceId);
+  const shouldKeepSpaceEntry = isSpaceEntry && !canAccessSpaceSettings;
+
+  const personalTabs = useMemo<IUnifiedSettingListItem[]>(
+    () => [
+      {
+        key: PersonalSettingTab.Profile,
+        name: t('settings.account.tab'),
+        Icon: User,
+        content: <Account />,
+      },
+      {
+        key: PersonalSettingTab.System,
+        name: t('settings.setting.title'),
+        Icon: Settings,
+        content: <System />,
+      },
+      {
+        key: PersonalSettingTab.Notifications,
+        name: t('settings.notify.title'),
+        Icon: Bell,
+        content: <Notifications />,
+      },
+      {
+        key: PersonalSettingTab.Integration,
+        name: t('settings.integration.title'),
+        Icon: Link,
+        content: <Integration />,
+      },
+      {
+        key: PersonalSettingTab.PersonalAccessToken,
+        name: t('setting:personalAccessToken'),
+        Icon: Key,
+        content: <PersonalAccessTokenSection />,
+      },
+      {
+        key: PersonalSettingTab.OAuthApp,
+        name: t('setting:oauthApps'),
+        Icon: Lock,
+        content: <OAuthAppSection />,
+      },
+      ...(extraPersonalTabs ?? []),
+    ],
+    [extraPersonalTabs, t]
+  );
+
+  const spaceTabs = useMemo<IUnifiedSettingListItem[]>(() => {
+    if (!resolvedSpaceId || !canAccessSpaceSettings) {
+      return [];
+    }
+
+    return [
+      {
+        key: SpaceSettingTab.General,
+        name: t('space:spaceSetting.general'),
+        Icon: Settings2,
+        content: ({ resolvedSpaceId }) => <GeneralPage spaceId={resolvedSpaceId} />,
+      },
+      {
+        key: SpaceSettingTab.Collaborator,
+        name: t('space:spaceSetting.collaborators'),
+        Icon: Users,
+        content: ({ resolvedSpaceId }) => <CollaboratorPage spaceId={resolvedSpaceId} />,
+      },
+      ...(extraSpaceTabs ?? []),
+    ];
+  }, [canAccessSpaceSettings, extraSpaceTabs, resolvedSpaceId, t]);
+
+  const orderedGroups = useMemo<IUnifiedSettingGroup[]>(() => {
+    const groups: IUnifiedSettingGroup[] = [
+      {
+        key: 'personal' as const,
+        title: t('common:settings.personal.title'),
+        entity: user ? (
+          <div className="flex items-center justify-center gap-2 px-1 sm:justify-start">
+            <UserAvatar className="size-8 rounded-full border" user={user} />
+            <span className="hidden truncate text-sm font-medium text-foreground sm:block">
+              {user.name}
+            </span>
+          </div>
+        ) : null,
+        tabs: personalTabs,
+      },
+      {
+        key: 'space' as const,
+        title: t('common:noun.space'),
+        entity:
+          resolvedSpaceId && space ? (
+            <div className="flex items-center justify-center gap-2 px-1 sm:justify-start">
+              <SpaceAvatar name={space.name} className="size-8 rounded-sm border" />
+              <span className="hidden truncate text-sm font-medium text-foreground sm:block">
+                {space.name}
+              </span>
+            </div>
+          ) : null,
+        tabs: spaceTabs,
+      },
+    ].filter((group) => group.tabs.length > 0);
+
+    if (entry === 'space') {
+      return groups.sort((a, b) => (a.key === 'space' ? -1 : b.key === 'space' ? 1 : 0));
+    }
+
+    return groups.sort((a, b) => (a.key === 'personal' ? -1 : b.key === 'personal' ? 1 : 0));
+  }, [entry, personalTabs, resolvedSpaceId, space, spaceTabs, t, user]);
+
+  const showSidebar = !contentOnly && orderedGroups.length > 0;
+  const availableTabs = useMemo(
+    () => orderedGroups.flatMap((group) => group.tabs.map(({ key }) => key)),
+    [orderedGroups]
+  );
+
+  useEffect(() => {
+    if (availableTabs.includes(tab)) {
+      return;
+    }
+
+    if (shouldKeepSpaceEntry) {
+      return;
+    }
+
+    const fallbackTab = availableTabs.includes(defaultTab) ? defaultTab : availableTabs[0];
+
+    if (fallbackTab && fallbackTab !== tab) {
+      onTabChange(fallbackTab);
+    }
+  }, [availableTabs, defaultTab, onTabChange, shouldKeepSpaceEntry, tab]);
+
+  const renderContext = useMemo<IUnifiedSettingRenderContext>(
+    () => ({ onTabChange, resolvedSpaceId, showSidebar }),
+    [onTabChange, resolvedSpaceId, showSidebar]
+  );
+
+  const allTabs = useMemo(() => orderedGroups.flatMap((group) => group.tabs), [orderedGroups]);
+
+  if (shouldKeepSpaceEntry) {
+    return <div className="h-full" />;
+  }
+
+  return (
+    <Tabs
+      defaultValue={defaultTab}
+      value={tab}
+      onValueChange={onTabChange}
+      className="flex h-full gap-0 overflow-hidden"
+    >
+      {showSidebar && (
+        <TabsList className="flex h-full w-14 shrink-0 flex-col items-stretch justify-start gap-5 overflow-y-auto rounded-none border-r bg-muted p-2 shadow-none sm:w-60 sm:gap-8 sm:p-4">
+          {orderedGroups.map((group) => (
+            <div key={group.key} className="flex flex-col gap-2">
+              <div className="space-y-2 sm:space-y-3">
+                <p className="hidden pl-2 text-sm font-semibold text-muted-foreground sm:block">
+                  {group.title}
+                </p>
+                {group.entity}
+              </div>
+              <div className="flex flex-col">
+                {group.tabs.map((item) => {
+                  const renderDefaultTrigger = (
+                    overrides?: IUnifiedSettingTriggerOverrides
+                  ): ReactElement => (
+                    <TabsTrigger
+                      key={item.key}
+                      value={item.key}
+                      className="h-8 w-full cursor-pointer justify-center gap-2 rounded-md px-0 font-normal data-[state=active]:bg-surface data-[state=active]:font-medium data-[state=active]:shadow-none hover:bg-primary/5 sm:justify-start sm:px-2"
+                      disabled={overrides?.disabled ?? item.disabled}
+                    >
+                      <div className="flex items-center justify-center gap-2 sm:w-full sm:justify-between">
+                        <div className="flex min-w-0 items-center justify-center gap-2 sm:justify-start">
+                          <item.Icon className="size-4 shrink-0" />
+                          <span className="hidden truncate sm:block">{item.name}</span>
+                        </div>
+                        <span className="hidden sm:inline-flex">
+                          {overrides?.badge ?? item.badge}
+                        </span>
+                      </div>
+                    </TabsTrigger>
+                  );
+
+                  return renderTabTrigger
+                    ? renderTabTrigger(item, renderContext, renderDefaultTrigger)
+                    : renderDefaultTrigger();
+                })}
+              </div>
+            </div>
+          ))}
+        </TabsList>
+      )}
+
+      {allTabs.map((item) => (
+        <TabsContent
+          key={item.key}
+          tabIndex={-1}
+          value={item.key}
+          className={
+            item.contentClassName ??
+            (spaceTabs.some((spaceTab) => spaceTab.key === item.key)
+              ? cn('mt-0 min-w-0 flex-1 focus-visible:outline-none', {
+                  'overflow-y-auto overflow-x-hidden': showSidebar,
+                })
+              : 'mt-0 size-full overflow-y-auto overflow-x-hidden')
+          }
+        >
+          {typeof item.content === 'function' ? item.content(renderContext) : item.content}
+        </TabsContent>
+      ))}
+    </Tabs>
+  );
+};
diff --git a/apps/nextjs-app/src/features/app/components/setting/integration/Integration.tsx b/apps/nextjs-app/src/features/app/components/setting/integration/Integration.tsx
index b80a5c9381..7e371445fb 100644
--- a/apps/nextjs-app/src/features/app/components/setting/integration/Integration.tsx
+++ b/apps/nextjs-app/src/features/app/components/setting/integration/Integration.tsx
@@ -36,7 +36,7 @@ export const Integration = () => {
       contentClassName="px-0 py-0"
     >
       <Tabs
-        className="flex h-full flex-1 flex-col gap-4 overflow-hidden px-8 py-4"
+        className="flex h-full flex-1 flex-col gap-4 overflow-hidden pb-6"
         value={tab}
         onValueChange={(value) => setTab(value as 'user' | 'third-party')}
       >
diff --git a/apps/nextjs-app/src/features/app/components/setting/useSettingStore.ts b/apps/nextjs-app/src/features/app/components/setting/useSettingStore.ts
index b51e40439e..9994b09fcb 100644
--- a/apps/nextjs-app/src/features/app/components/setting/useSettingStore.ts
+++ b/apps/nextjs-app/src/features/app/components/setting/useSettingStore.ts
@@ -11,16 +11,18 @@ export enum SettingTab {
   LicensePlan = 'license-plan',
 }
 
+export type SettingDialogTab = string;
+
 interface ISettingState {
-  tab?: SettingTab;
-  setTab: (tab: SettingTab) => void;
+  tab?: SettingDialogTab;
+  setTab: (tab: SettingDialogTab) => void;
   open: boolean;
-  setOpen: (open: boolean, tab?: SettingTab) => void;
+  setOpen: (open: boolean, tab?: SettingDialogTab) => void;
 }
 
 export const useSettingStore = create<ISettingState>((set) => ({
   open: false,
-  setOpen: (open: boolean, tab?: SettingTab) => {
+  setOpen: (open: boolean, tab?: SettingDialogTab) => {
     set((state) => {
       return {
         ...state,
@@ -29,7 +31,7 @@ export const useSettingStore = create<ISettingState>((set) => ({
       };
     });
   },
-  setTab: (tab: SettingTab) => {
+  setTab: (tab: SettingDialogTab) => {
     set((state) => {
       return {
         ...state,
diff --git a/apps/nextjs-app/src/features/app/hooks/useBaseResource.ts b/apps/nextjs-app/src/features/app/hooks/useBaseResource.ts
index d678622545..dd7726e109 100644
--- a/apps/nextjs-app/src/features/app/hooks/useBaseResource.ts
+++ b/apps/nextjs-app/src/features/app/hooks/useBaseResource.ts
@@ -103,3 +103,14 @@ export function useBaseResource(): IBaseResource {
     };
   }, [baseId, slug]);
 }
+
+export function useBaseNodeId(): string | undefined {
+  const router = useRouter();
+  const { slug } = router.query;
+  return useMemo(() => {
+    if (!slug || slug.length === 0) {
+      return;
+    }
+    return slug?.[1];
+  }, [slug]);
+}
diff --git a/apps/nextjs-app/src/features/app/utils/download-all-attachments.ts b/apps/nextjs-app/src/features/app/utils/download-all-attachments.ts
index bb539019f7..69e76496ba 100644
--- a/apps/nextjs-app/src/features/app/utils/download-all-attachments.ts
+++ b/apps/nextjs-app/src/features/app/utils/download-all-attachments.ts
@@ -40,6 +40,8 @@ export interface IDownloadAllAttachmentsOptions {
   shareId?: string;
   personalViewCommonQuery?: IGetRecordsRo;
   namingField?: IFieldInstance;
+  /** When true, keep the original filename without any prefix (collisions resolved via _N suffix) */
+  noPrefix?: boolean;
   groupByRow?: boolean;
   onProgress?: (progress: IDownloadProgress) => void;
   abortController?: AbortController;
@@ -333,10 +335,20 @@ function generateZipFileName(
   rowAttachmentCount: number,
   namingValue?: string,
   isNamingValueDuplicated?: boolean,
-  groupByRow?: boolean
+  groupByRow?: boolean,
+  noPrefix?: boolean
 ): string {
   const hasMultipleInRow = rowAttachmentCount > 1;
 
+  // No-prefix mode: keep original filename. groupByRow still wraps multi-attachment rows
+  // in a row-numbered folder so files within the same row stay together.
+  if (noPrefix) {
+    if (groupByRow && hasMultipleInRow) {
+      return `${getPaddedRowNumber(rowIndex, totalRows)}/${fileName}`;
+    }
+    return fileName;
+  }
+
   // When groupByRow is enabled and row has multiple attachments, use folder structure
   if (groupByRow && hasMultipleInRow) {
     const folderName = generateFolderName(
@@ -385,6 +397,7 @@ export async function downloadAllAttachments(
     shareId,
     personalViewCommonQuery,
     namingField,
+    noPrefix,
     groupByRow,
     onProgress,
     abortController,
@@ -451,6 +464,9 @@ export async function downloadAllAttachments(
     let downloadedBytes = 0;
     let processedFiles = 0;
 
+    // Track final zip entry names for noPrefix mode to dedupe cross-row collisions.
+    const usedZipPaths = new Map<string, number>();
+
     // 6. Create zip stream
     const zip = new Zip((err, chunk, final) => {
       if (err) {
@@ -477,7 +493,7 @@ export async function downloadAllAttachments(
       }
 
       const isNamingValueDuplicated = namingValue ? duplicatedNamingValues.has(namingValue) : false;
-      const fileName = generateZipFileName(
+      let fileName = generateZipFileName(
         rowIndex,
         attachmentIndex,
         attachment.name,
@@ -485,8 +501,12 @@ export async function downloadAllAttachments(
         attachmentCountInRow,
         namingValue,
         isNamingValueDuplicated,
-        groupByRow
+        groupByRow,
+        noPrefix
       );
+      if (noPrefix) {
+        fileName = generateUniqueFileName(fileName, usedZipPaths);
+      }
 
       // Skip attachments without valid presignedUrl
       if (!attachment.presignedUrl) {
diff --git a/apps/nextjs-app/src/styles/global.css b/apps/nextjs-app/src/styles/global.css
index ad205d5e7a..5f66617d7b 100644
--- a/apps/nextjs-app/src/styles/global.css
+++ b/apps/nextjs-app/src/styles/global.css
@@ -40,11 +40,11 @@ body {
   background-color: hsl(var(--muted-foreground)) !important;
 }
 
-.fc-scrollgrid-section > td {
+.fc-scrollgrid-section>td {
   border-radius: 0px 0px 8px 8px !important;
 }
 
-.fc-scrollgrid-section > th {
+.fc-scrollgrid-section>th {
   border-radius: 0px 8px 0px 0px !important;
 }
 
@@ -167,3 +167,21 @@ body {
 .react-flow__controls-button svg {
   fill: currentColor !important;
 }
+
+@keyframes ui-attention-pulse {
+  0% {
+    box-shadow: inset 0 0 0 0 hsl(var(--primary) / 0);
+  }
+
+  35% {
+    box-shadow: inset 0 0 0 5px hsl(var(--primary)/ 0.15);
+  }
+
+  100% {
+    box-shadow: inset 0 0 0 0 hsl(var(--primary) / 0);
+  }
+}
+
+.ui-attention-pulse {
+  animation: ui-attention-pulse 700ms ease-in-out 2;
+}
\ No newline at end of file
diff --git a/packages/common-i18n/src/locales/de/common.json b/packages/common-i18n/src/locales/de/common.json
index 18edf2518e..852e674c84 100644
--- a/packages/common-i18n/src/locales/de/common.json
+++ b/packages/common-i18n/src/locales/de/common.json
@@ -164,8 +164,9 @@
   },
   "settings": {
     "title": "Instanzeinstellungen",
+    "allSetting": "Space- & persönliche Einstellungen",
     "personal": {
-      "title": "Persönliche Einstellungen"
+      "title": "Persönlich"
     },
     "back": "Zurück zum Start",
     "account": {
@@ -885,6 +886,10 @@
           "runQuotaExceeded": {
             "title": "Automatisierung {{name}} hat die maximale monatliche Ausführungsanzahl erreicht",
             "message": "Die monatlichen Ausführungen für Automatisierung {{name}} sind aufgebraucht. Die Ausführung ist vorübergehend nicht möglich. Bitte upgraden Sie Ihr Abonnement oder kaufen Sie zusätzliche Ausführungen."
+          },
+          "failedSummary": {
+            "title": "Automatisierung {{name}} ist {{failCount}} Mal fehlgeschlagen",
+            "message": "Ihre Automatisierung {{name}} hat {{failCount}} aufeinanderfolgende Fehler angesammelt. Öffnen Sie den Ausführungsverlauf, um Details anzuzeigen."
           }
         },
         "billing": {
@@ -1100,9 +1105,9 @@
     }
   },
   "changelog": {
-    "newUpdate": "17. APR UPDATE",
-    "title": "Claude Opus 4.7 ist jetzt in Teable verfügbar",
-    "url": "https://help.teable.ai/en/changelog#apr-17-2026",
-    "id": "changelog-2026-04-17-claude-opus-4-7-is-now-in-teable"
+    "newUpdate": "28. APR UPDATE",
+    "title": "Neuer Trigger: Beim E-Mail-Empfang (IMAP)",
+    "url": "https://help.teable.ai/en/changelog#apr-28-2026",
+    "id": "changelog-2026-04-28-new-trigger-when-email-receive-imap"
   }
 }
diff --git a/packages/common-i18n/src/locales/de/sdk.json b/packages/common-i18n/src/locales/de/sdk.json
index 54dd297b79..23ed1f747a 100644
--- a/packages/common-i18n/src/locales/de/sdk.json
+++ b/packages/common-i18n/src/locales/de/sdk.json
@@ -158,6 +158,7 @@
     },
     "invalidateSelected": "Unzulässiger Wert",
     "invalidateSelectedTips": "Der ausgewählte Wert wurde gelöscht, bitte wählen Sie erneut",
+    "invalidConditionTip": "Diese Filterbedingung ist ungültig und wird ignoriert. Bitte passen Sie den Wert an.",
     "default": {
       "empty": "Es werden keine Filterbedingungen angewendet",
       "placeholder": "Einen Wert eingeben"
@@ -264,7 +265,8 @@
     "configLabel_other_visible": "{{count}} sichtbare Felder",
     "showAll": "Alle zeigen",
     "hideAll": "Alle verstecken",
-    "primaryKey": "Primäres Feld: Identifiziert Datensätze\nKann nicht ausgeblendet oder gelöscht werden, sichtbar in verknüpften Datensätzen."
+    "primaryKey": "Primäres Feld: Identifiziert Datensätze\nKann nicht ausgeblendet oder gelöscht werden, sichtbar in verknüpften Datensätzen.",
+    "notInCurrentView": "Feld „{{fieldName}}“ ist in der aktuellen Ansicht nicht sichtbar und kann nicht angesteuert werden"
   },
   "expandRecord": {
     "copy": "In die Zwischenablage kopieren",
@@ -1121,7 +1123,8 @@
       "notAllowedToExecuteSqlWithKeyword": "Ausführung von SQL mit Schlüsselwort {{keyword}} nicht erlaubt",
       "whiteListCheckError": "Fehler beim Überprüfen des Tabellenzugriffs: {{message}}",
       "databaseConnectionFailed": "Datenbankverbindung fehlgeschlagen: {{message}}",
-      "executeQuerySqlFailed": "Ausführung der Abfrage-SQL fehlgeschlagen: {{message}}"
+      "executeQuerySqlFailed": "Ausführung der Abfrage-SQL fehlgeschlagen: {{message}}",
+      "sqlSyntaxError": "SQL-Syntaxfehler, bitte überprüfen Sie Ihre Abfrage"
     },
     "permission": {
       "createRecordWithDeniedFields": "Sie haben keine Berechtigung, Datensätze mit Feldern({{fields}}) zu erstellen",
@@ -1223,7 +1226,9 @@
       "button": {
         "clickCountReachedMaxCount": "Anzahl der Schaltflächenklicks hat das Maximum erreicht",
         "notSupportReset": "Schaltflächenfeld unterstützt kein Zurücksetzen"
-      }
+      },
+      "primaryCannotBeLookup": "Primärfeld kann nicht als Lookup-Feld konfiguriert werden",
+      "primaryFieldAlreadyExists": "Tabelle hat bereits ein Primärfeld"
     },
     "view": {
       "notFound": "Ansicht nicht gefunden",
@@ -1438,7 +1443,8 @@
       "linkedInPostNotFound": "LinkedIn-Beitrag nicht gefunden: {{postId}}",
       "linkedInAuthorNotFound": "LinkedIn-Autor nicht gefunden: {{postId}}",
       "fetchLinkedInUserFailed": "Abrufen des LinkedIn-Benutzers fehlgeschlagen: {{error}}",
-      "domainAlreadyInUse": "Diese Domain ist bereits an eine andere App gebunden"
+      "domainAlreadyInUse": "Diese Domain ist bereits an eine andere App gebunden",
+      "domainReserved": "Subdomain ist reserviert"
     }
   }
 }
diff --git a/packages/common-i18n/src/locales/de/table.json b/packages/common-i18n/src/locales/de/table.json
index e04c635a26..43055e456a 100644
--- a/packages/common-i18n/src/locales/de/table.json
+++ b/packages/common-i18n/src/locales/de/table.json
@@ -641,6 +641,11 @@
             }
           }
         }
+      },
+      "errorType": {
+        "InvalidPrimaryLookup": "Primärfeld fälschlich als Lookup konfiguriert",
+        "InvalidPrimaryType": "Primärfeld hat einen nicht unterstützten Typ",
+        "MissingPrimary": "Tabelle hat kein Primärfeld"
       }
     },
     "index": {
@@ -978,6 +983,7 @@
     "expand": "Erweitern",
     "history": "Verlauf",
     "close": "Einklappen",
+    "noModel": "Keine verfügbaren Modelle",
     "addAttachment": "Anhang hinzufügen",
     "noHistory": "Keine Chat-Verlauf",
     "noFoundHistory": "Keine passenden Chat-Verlauf gefunden, starten Sie einen neuen Chat",
@@ -995,7 +1001,14 @@
       "emptyContext": "Kein Kontext zum Hinzufügen",
       "selectionRows": "Zeilen {{start}}-{{end}}"
     },
-    "inputPlaceholder": "Nachricht senden...",
+    "mention": {
+      "tables": "Tabellen",
+      "apps": "Apps",
+      "workflows": "Workflows",
+      "folders": "Ordner"
+    },
+    "inputPlaceholder": "@ tippen, um Kontext hinzuzufügen",
+    "inputPlaceholderFiles": "Dateien hier einfügen oder ablegen",
     "thought": "Denken",
     "meta": {
       "input": "Eingabe",
@@ -1054,6 +1067,8 @@
       "advancedOptions": "Erweiterte Optionen",
       "namingFieldLabel": "Präfix für Anhangsname",
       "selectField": "Standard: Anhangsindex",
+      "noPrefixOption": "Kein Präfix",
+      "noPrefixOptionDesc": "Originaldateiname beibehalten",
       "groupByRow": "In Ordner archivieren",
       "groupByRowTip": "Wenn eine Zeile mehrere Anhänge hat, werden sie im selben Ordner abgelegt; Zeilen mit nur einem Anhang erstellen keinen Ordner."
     }
diff --git a/packages/common-i18n/src/locales/en/common.json b/packages/common-i18n/src/locales/en/common.json
index 0ad5a3be4d..dd58dfb182 100644
--- a/packages/common-i18n/src/locales/en/common.json
+++ b/packages/common-i18n/src/locales/en/common.json
@@ -170,8 +170,9 @@
   },
   "settings": {
     "title": "Instance settings",
+    "allSetting": "Space & personal settings",
     "personal": {
-      "title": "Personal settings"
+      "title": "Personal"
     },
     "templateAdmin": {
       "title": "Template admin",
@@ -1204,6 +1205,10 @@
           "runQuotaExceeded": {
             "title": "Automation {{name}} run failed due to run quota limit",
             "message": "Your automation {{name}} reached the monthly automation run quota. Please upgrade your plan or purchase additional automation runs."
+          },
+          "failedSummary": {
+            "title": "Automation {{name}} has failed {{failCount}} times",
+            "message": "Your automation {{name}} has accumulated {{failCount}} consecutive failures. Open run history to view details."
           }
         },
         "billing": {
@@ -1452,9 +1457,9 @@
     }
   },
   "changelog": {
-    "newUpdate": "APR 17 UPDATE",
-    "title": "Claude Opus 4.7 is now in Teable",
-    "url": "https://help.teable.ai/en/changelog#apr-17-2026",
-    "id": "changelog-2026-04-17-claude-opus-4-7-is-now-in-teable"
+    "newUpdate": "APR 28 UPDATE",
+    "title": "New Trigger: When Email Receive (IMAP)",
+    "url": "https://help.teable.ai/en/changelog#apr-28-2026",
+    "id": "changelog-2026-04-28-new-trigger-when-email-receive-imap"
   }
 }
diff --git a/packages/common-i18n/src/locales/en/sdk.json b/packages/common-i18n/src/locales/en/sdk.json
index d9d4cca364..3791e7ed90 100644
--- a/packages/common-i18n/src/locales/en/sdk.json
+++ b/packages/common-i18n/src/locales/en/sdk.json
@@ -174,6 +174,7 @@
     },
     "invalidateSelected": "Invalid value",
     "invalidateSelectedTips": "The selected value has been deleted, please select again",
+    "invalidConditionTip": "This filter condition is invalid and will be ignored. Please adjust the value.",
     "default": {
       "empty": "No filter conditions are applied",
       "placeholder": "Enter a value"
@@ -281,7 +282,8 @@
     "configLabel_other_visible": "{{count}} visible fields",
     "showAll": "Show all",
     "hideAll": "Hide all",
-    "primaryKey": "Primary field: Identifies records\nCannot be hidden or deleted, visible in linked records."
+    "primaryKey": "Primary field: Identifies records\nCannot be hidden or deleted, visible in linked records.",
+    "notInCurrentView": "Field \"{{fieldName}}\" is not visible in the current view and can't be jumped to"
   },
   "expandRecord": {
     "copy": "Copy to clipboard",
@@ -1147,7 +1149,8 @@
       "whiteListCheckError": "An error occurred while checking table access: {{message}}",
       "databaseConnectionFailed": "Database connection failed: {{message}}",
       "executeQuerySqlFailed": "Execute query sql failed: {{message}}",
-      "readOnlyCheckFailed": "Read only check failed: {{message}}"
+      "readOnlyCheckFailed": "Read only check failed: {{message}}",
+      "sqlSyntaxError": "SQL syntax error, please check your query"
     },
     "permission": {
       "createRecordWithDeniedFields": "You don't have permission to create record with fields({{fields}})",
@@ -1249,7 +1252,9 @@
       "button": {
         "clickCountReachedMaxCount": "Button click count has reached the maximum limit",
         "notSupportReset": "Button field does not support reset"
-      }
+      },
+      "primaryCannotBeLookup": "Primary field cannot be configured as a lookup field",
+      "primaryFieldAlreadyExists": "Table already has a primary field"
     },
     "view": {
       "notFound": "View not found",
@@ -1447,7 +1452,8 @@
       "noFilesInZip": "No files found in ZIP",
       "zipFileTooLarge": "ZIP file size exceeds 5MB limit",
       "invalidZip": "Invalid ZIP file",
-      "domainAlreadyInUse": "This domain is already bound to another app"
+      "domainAlreadyInUse": "This domain is already bound to another app",
+      "domainReserved": "Subdomain is reserved"
     },
     "reward": {
       "notFound": "Reward not found",
diff --git a/packages/common-i18n/src/locales/en/table.json b/packages/common-i18n/src/locales/en/table.json
index d7fef7adf3..6bab2419d1 100644
--- a/packages/common-i18n/src/locales/en/table.json
+++ b/packages/common-i18n/src/locales/en/table.json
@@ -256,6 +256,7 @@
       "reset": "Reset",
       "fieldUpdated": "Field has been updated",
       "fieldCreated": "Field has been created",
+      "fieldUnavailable": "This field is unavailable. Refresh the table and try again.",
       "confirmFieldChange": "Confirm Field Change",
       "areYouSurePerformIt": "Are you sure you want to perform it?",
       "addDescription": "Add description",
@@ -661,6 +662,20 @@
         "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.",
+        "repairPreviewTitle": "Confirm repair details",
+        "repairPreviewDescription": "These details come from the repair dry run. The repair will only execute after you confirm.",
+        "repairPreviewTooltip": "Open the dry-run repair plan. The dialog will show the returned SQL, or clearly say when no SQL is available.",
+        "repairPreviewMissingTable": "This check result does not include a table, so the dry-run repair target cannot be resolved.",
+        "repairPreviewUnavailableStatus": "This status does not need repair, so a dry-run repair plan cannot be generated.",
+        "repairPreviewWhat": "What will be repaired",
+        "repairPreviewTarget": "The \"{{ruleName}}\" rule for field \"{{fieldName}}\"",
+        "repairPreviewPrinciple": "How the repair works",
+        "repairPreviewNoPrinciple": "This rule did not return additional repair guidance.",
+        "repairPreviewSql": "SQL to execute",
+        "repairPreviewNoSql": "The dry run did not return executable SQL, so automatic repair cannot be run directly.",
+        "repairPreviewCannotConfirm": "The dry run returned SQL, but this rule cannot be confirmed for automatic repair right now. You can still review the repair plan.",
+        "repairPreviewParameters": "Parameters",
+        "repairPreviewConfirm": "Run repair",
         "checking": "Checking schema...",
         "repairing": "Repairing schema...",
         "streamError": "Failed to stream schema integrity results.",
@@ -770,6 +785,7 @@
             "junctionForeignKeyOrphanRows": "Automatic repair is unavailable because invalid junction rows still exist"
           },
           "description": {
+            "autoRule": "The repair will execute the schema statements generated by this rule, then re-check the rule to confirm the schema is valid.",
             "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.",
             "foreignKeyOrphanRows": "Clean up the invalid linked rows for \"{{fieldName}}\" before adding the foreign key constraint again.",
@@ -831,7 +847,10 @@
         "ReferenceFieldNotFound": "ReferenceFieldNotFound",
         "UniqueIndexNotFound": "UniqueIndexNotFound",
         "EmptyString": "EmptyString",
-        "InvalidFilterOperator": "InvalidFilterOperator"
+        "InvalidFilterOperator": "InvalidFilterOperator",
+        "InvalidPrimaryLookup": "Primary field misconfigured as lookup",
+        "InvalidPrimaryType": "Primary field has unsupported type",
+        "MissingPrimary": "Table has no primary field"
       }
     },
     "index": {
@@ -945,6 +964,8 @@
       "advancedOptions": "Advanced options",
       "namingFieldLabel": "Attachment name prefix",
       "selectField": "Default: attachment index",
+      "noPrefixOption": "No prefix",
+      "noPrefixOptionDesc": "Keep the original filename",
       "groupByRow": "Archive into folders",
       "groupByRowTip": "When a row has multiple attachments, they will be placed in the same folder; rows with only one attachment will not create a folder."
     }
@@ -1260,9 +1281,12 @@
     "expand": "Expand",
     "history": "History",
     "close": "Collapse",
+    "noModel": "No models available",
     "clearChatConfirmTitle": "Confirm Clear Chat",
     "clearChatConfirmDesc": "Current chat content will not be saved. Are you sure you want to clear it?",
     "dontShowAgain": "Don't show again",
+    "modelSwitchTitle": "Switch model",
+    "modelSwitchHint": "Currently running on {{previous}}. On next send, the new model takes over and only sees the last 3 turns.",
     "sandboxExpiry": {
       "expiresIn": "Agent Computer expires in {{time}}",
       "reset": "Renew",
@@ -1277,7 +1301,7 @@
       "expiresSoon": "Agent Computer expiring soon",
       "resetFailed": "Failed to renew Agent Computer"
     },
-    "addAttachment": "Add Attachment",
+    "addAttachment": "Add attachment",
     "noHistory": "No chat history",
     "noFoundHistory": "No chat history found, please start a new conversation",
     "timeGroup": {
@@ -1294,7 +1318,14 @@
       "emptyContext": "No context to add",
       "selectionRows": "Rows {{start}}-{{end}}"
     },
-    "inputPlaceholder": "Describe what you want to do",
+    "mention": {
+      "tables": "Tables",
+      "apps": "Apps",
+      "workflows": "Workflows",
+      "folders": "Folders"
+    },
+    "inputPlaceholder": "Type @ to add context",
+    "inputPlaceholderFiles": "Paste or drop files here",
     "thought": "Thinking",
     "meta": {
       "input": "Input",
@@ -1359,7 +1390,10 @@
     },
     "retry": {
       "interrupted": "Response interrupted",
-      "button": "Retry"
+      "button": "Retry",
+      "offline": "You're offline. We'll retry once your connection is back.",
+      "pausedHidden": "Retry paused — open this tab to reconnect.",
+      "maxAttemptsReached": "Couldn't reconnect automatically. Please refresh the page manually."
     },
     "guide": {
       "goToScenario": "Go to scenario {{index}}"
diff --git a/packages/common-i18n/src/locales/es/common.json b/packages/common-i18n/src/locales/es/common.json
index cb3bb6d93f..f84527c8ce 100644
--- a/packages/common-i18n/src/locales/es/common.json
+++ b/packages/common-i18n/src/locales/es/common.json
@@ -164,8 +164,9 @@
   },
   "settings": {
     "title": "Configuración de instancia",
+    "allSetting": "Configuración del espacio y personal",
     "personal": {
-      "title": "Configuración personal"
+      "title": "Personal"
     },
     "back": "Volver al inicio",
     "account": {
@@ -888,6 +889,10 @@
           "runQuotaExceeded": {
             "title": "La automatización {{name}} alcanzó el máximo mensual de ejecuciones",
             "message": "Las ejecuciones mensuales de la automatización {{name}} se han agotado y no puede ejecutarse temporalmente. Actualiza tu suscripción o compra ejecuciones adicionales."
+          },
+          "failedSummary": {
+            "title": "La automatización {{name}} ha fallado {{failCount}} veces",
+            "message": "Tu automatización {{name}} ha acumulado {{failCount}} fallos consecutivos. Abre el historial de ejecuciones para ver los detalles."
           }
         },
         "billing": {
@@ -1103,9 +1108,9 @@
     }
   },
   "changelog": {
-    "newUpdate": "ACTUALIZACIÓN 17 ABR",
-    "title": "Claude Opus 4.7 ya está disponible en Teable",
-    "url": "https://help.teable.ai/en/changelog#apr-17-2026",
-    "id": "changelog-2026-04-17-claude-opus-4-7-is-now-in-teable"
+    "newUpdate": "ACTUALIZACIÓN 28 ABR",
+    "title": "Nuevo disparador: Al recibir un correo electrónico (IMAP)",
+    "url": "https://help.teable.ai/en/changelog#apr-28-2026",
+    "id": "changelog-2026-04-28-new-trigger-when-email-receive-imap"
   }
 }
diff --git a/packages/common-i18n/src/locales/es/sdk.json b/packages/common-i18n/src/locales/es/sdk.json
index 38952db515..b10e363d39 100644
--- a/packages/common-i18n/src/locales/es/sdk.json
+++ b/packages/common-i18n/src/locales/es/sdk.json
@@ -158,6 +158,7 @@
     },
     "invalidateSelected": "Valor no válido",
     "invalidateSelectedTips": "Se ha eliminado el valor seleccionado, seleccione nuevamente",
+    "invalidConditionTip": "Esta condición de filtro no es válida y se ignorará. Ajuste el valor.",
     "default": {
       "empty": "No se aplican condiciones de filtro",
       "placeholder": "Ingrese un valor"
@@ -264,7 +265,8 @@
     "configLabel_other_visible": "{{count}} visible fields",
     "showAll": "Mostrar todo",
     "hideAll": "Esconderse",
-    "primaryKey": "Campo primario: identifica registros\n"
+    "primaryKey": "Campo primario: identifica registros\n",
+    "notInCurrentView": "El campo \"{{fieldName}}\" no está visible en la vista actual y no se puede localizar"
   },
   "expandRecord": {
     "copy": "Copiar al portapapeles",
@@ -1121,7 +1123,8 @@
       "notAllowedToExecuteSqlWithKeyword": "No se permite ejecutar SQL con la palabra clave {{keyword}}",
       "whiteListCheckError": "Ocurrió un error al verificar el acceso a la tabla: {{message}}",
       "databaseConnectionFailed": "Conexión a la base de datos fallida: {{message}}",
-      "executeQuerySqlFailed": "Error al ejecutar la consulta SQL: {{message}}"
+      "executeQuerySqlFailed": "Error al ejecutar la consulta SQL: {{message}}",
+      "sqlSyntaxError": "Error de sintaxis SQL, por favor verifique su consulta"
     },
     "permission": {
       "createRecordWithDeniedFields": "No tienes permiso para crear registros con campos({{fields}})",
@@ -1221,7 +1224,9 @@
       "button": {
         "clickCountReachedMaxCount": "El conteo de clics del botón ha alcanzado el límite máximo",
         "notSupportReset": "El campo de botón no admite restablecimiento"
-      }
+      },
+      "primaryCannotBeLookup": "El campo principal no puede configurarse como un campo Lookup",
+      "primaryFieldAlreadyExists": "La tabla ya tiene un campo principal"
     },
     "view": {
       "notFound": "Vista no encontrada",
@@ -1432,7 +1437,8 @@
       "linkedInPostNotFound": "Publicación de LinkedIn no encontrada: {{postId}}",
       "linkedInAuthorNotFound": "Autor de LinkedIn no encontrado: {{postId}}",
       "fetchLinkedInUserFailed": "Error al obtener el usuario de LinkedIn: {{error}}",
-      "domainAlreadyInUse": "Este dominio ya está vinculado a otra aplicación"
+      "domainAlreadyInUse": "Este dominio ya está vinculado a otra aplicación",
+      "domainReserved": "Subdominio reservado"
     }
   }
 }
diff --git a/packages/common-i18n/src/locales/es/table.json b/packages/common-i18n/src/locales/es/table.json
index 81ef28ee15..0c712698c2 100644
--- a/packages/common-i18n/src/locales/es/table.json
+++ b/packages/common-i18n/src/locales/es/table.json
@@ -638,6 +638,11 @@
             }
           }
         }
+      },
+      "errorType": {
+        "InvalidPrimaryLookup": "Campo principal mal configurado como Lookup",
+        "InvalidPrimaryType": "El campo principal tiene un tipo no admitido",
+        "MissingPrimary": "La tabla no tiene campo principal"
       }
     },
     "index": {
@@ -971,6 +976,7 @@
     "expand": "Expandir",
     "history": "Historial",
     "close": "Contraer",
+    "noModel": "No hay modelos disponibles",
     "addAttachment": "Añadir archivo adjunto",
     "noHistory": "No hay historial de chat",
     "noFoundHistory": "No se encontró historial de chat coincidente, comience una nueva conversación",
@@ -988,7 +994,14 @@
       "emptyContext": "No hay contexto para agregar",
       "selectionRows": "Filas {{start}}-{{end}}"
     },
-    "inputPlaceholder": "Enviar mensaje...",
+    "mention": {
+      "tables": "Tablas",
+      "apps": "Aplicaciones",
+      "workflows": "Flujos de trabajo",
+      "folders": "Carpetas"
+    },
+    "inputPlaceholder": "Escribe @ para añadir contexto",
+    "inputPlaceholderFiles": "Pega o suelta archivos aquí",
     "thought": "Pensando",
     "meta": {
       "input": "Entrada",
@@ -1047,6 +1060,8 @@
       "advancedOptions": "Opciones avanzadas",
       "namingFieldLabel": "Prefijo del nombre del adjunto",
       "selectField": "Por defecto: índice de adjunto",
+      "noPrefixOption": "Sin prefijo",
+      "noPrefixOptionDesc": "Mantener el nombre original",
       "groupByRow": "Archivar en carpetas",
       "groupByRowTip": "Cuando una fila tiene múltiples adjuntos, se colocarán en la misma carpeta; las filas con solo un adjunto no crearán una carpeta."
     }
diff --git a/packages/common-i18n/src/locales/fr/common.json b/packages/common-i18n/src/locales/fr/common.json
index 2b0f19db09..26ad147ba4 100644
--- a/packages/common-i18n/src/locales/fr/common.json
+++ b/packages/common-i18n/src/locales/fr/common.json
@@ -164,8 +164,9 @@
   },
   "settings": {
     "title": "Paramètres d'instance",
+    "allSetting": "Paramètres de l'espace et personnels",
     "personal": {
-      "title": "Paramètres personnels"
+      "title": "Personnel"
     },
     "back": "Retour à l'accueil",
     "account": {
@@ -890,6 +891,10 @@
           "runQuotaExceeded": {
             "title": "L'automatisation {{name}} a atteint le nombre maximal d'exécutions mensuelles",
             "message": "Le quota mensuel d'exécutions de l'automatisation {{name}} est épuisé. L'exécution est temporairement indisponible. Veuillez mettre à niveau votre abonnement ou acheter des exécutions supplémentaires."
+          },
+          "failedSummary": {
+            "title": "L'automatisation {{name}} a échoué {{failCount}} fois",
+            "message": "Votre automatisation {{name}} a cumulé {{failCount}} échecs consécutifs. Ouvrez l'historique des exécutions pour voir les détails."
           }
         },
         "billing": {
@@ -1105,9 +1110,9 @@
     }
   },
   "changelog": {
-    "newUpdate": "MISE À JOUR DU 17 AVR",
-    "title": "Claude Opus 4.7 est désormais disponible dans Teable",
-    "url": "https://help.teable.ai/en/changelog#apr-17-2026",
-    "id": "changelog-2026-04-17-claude-opus-4-7-is-now-in-teable"
+    "newUpdate": "MISE À JOUR DU 28 AVR",
+    "title": "Nouveau déclencheur : À la réception d’un e-mail (IMAP)",
+    "url": "https://help.teable.ai/en/changelog#apr-28-2026",
+    "id": "changelog-2026-04-28-new-trigger-when-email-receive-imap"
   }
 }
diff --git a/packages/common-i18n/src/locales/fr/sdk.json b/packages/common-i18n/src/locales/fr/sdk.json
index a78b3ae227..5a73bb25cc 100644
--- a/packages/common-i18n/src/locales/fr/sdk.json
+++ b/packages/common-i18n/src/locales/fr/sdk.json
@@ -158,6 +158,7 @@
     },
     "invalidateSelected": "Invalid value",
     "invalidateSelectedTips": "The selected value has been deleted, please select again",
+    "invalidConditionTip": "Cette condition de filtre est invalide et sera ignorée. Veuillez ajuster la valeur.",
     "default": {
       "empty": "Aucune condition de filtrage appliquée",
       "placeholder": "Entrez une valeur"
@@ -264,7 +265,8 @@
     "configLabel_other_visible": "{{count}} champs visibles",
     "showAll": "Tout afficher",
     "hideAll": "Tout masquer",
-    "primaryKey": "Champ principal : utilisé pour identifier les enregistrements, ne peut pas être caché ou supprimé"
+    "primaryKey": "Champ principal : utilisé pour identifier les enregistrements, ne peut pas être caché ou supprimé",
+    "notInCurrentView": "Le champ « {{fieldName}} » n'est pas visible dans la vue actuelle et ne peut pas être atteint"
   },
   "expandRecord": {
     "copy": "Copier dans le presse-papiers",
@@ -1121,7 +1123,8 @@
       "notAllowedToExecuteSqlWithKeyword": "Non autorisé à exécuter SQL avec le mot-clé {{keyword}}",
       "whiteListCheckError": "Une erreur s'est produite lors de la vérification de l'accès à la table : {{message}}",
       "databaseConnectionFailed": "La connexion à la base de données a échoué : {{message}}",
-      "executeQuerySqlFailed": "L'exécution de la requête SQL a échoué : {{message}}"
+      "executeQuerySqlFailed": "L'exécution de la requête SQL a échoué : {{message}}",
+      "sqlSyntaxError": "Erreur de syntaxe SQL, veuillez vérifier votre requête"
     },
     "permission": {
       "createRecordWithDeniedFields": "Vous n'avez pas la permission de créer des enregistrements avec les champs({{fields}})",
@@ -1221,7 +1224,9 @@
       "button": {
         "clickCountReachedMaxCount": "Le nombre de clics sur le bouton a atteint la limite maximale",
         "notSupportReset": "Le champ de bouton ne prend pas en charge la réinitialisation"
-      }
+      },
+      "primaryCannotBeLookup": "Le champ principal ne peut pas être configuré comme un champ Lookup",
+      "primaryFieldAlreadyExists": "La table a déjà un champ principal"
     },
     "view": {
       "notFound": "Vue introuvable",
@@ -1432,7 +1437,8 @@
       "linkedInPostNotFound": "Publication LinkedIn non trouvée : {{postId}}",
       "linkedInAuthorNotFound": "Auteur LinkedIn non trouvé : {{postId}}",
       "fetchLinkedInUserFailed": "Échec de la récupération de l'utilisateur LinkedIn : {{error}}",
-      "domainAlreadyInUse": "Ce domaine est déjà lié à une autre application"
+      "domainAlreadyInUse": "Ce domaine est déjà lié à une autre application",
+      "domainReserved": "Sous-domaine réservé"
     }
   }
 }
diff --git a/packages/common-i18n/src/locales/fr/table.json b/packages/common-i18n/src/locales/fr/table.json
index 6bea471b1c..58b46320b4 100644
--- a/packages/common-i18n/src/locales/fr/table.json
+++ b/packages/common-i18n/src/locales/fr/table.json
@@ -632,6 +632,11 @@
             }
           }
         }
+      },
+      "errorType": {
+        "InvalidPrimaryLookup": "Champ principal mal configuré comme Lookup",
+        "InvalidPrimaryType": "Le champ principal a un type non pris en charge",
+        "MissingPrimary": "La table n'a pas de champ principal"
       }
     },
     "index": {
@@ -957,6 +962,7 @@
     "expand": "Développer",
     "history": "Historique",
     "close": "Réduire",
+    "noModel": "Aucun modèle disponible",
     "addAttachment": "Ajouter une pièce jointe",
     "noHistory": "Aucun historique de chat",
     "noFoundHistory": "Aucun historique de chat trouvé, veuillez commencer une nouvelle conversation",
@@ -974,7 +980,14 @@
       "emptyContext": "Aucun contexte à ajouter",
       "selectionRows": "Lignes {{start}}-{{end}}"
     },
-    "inputPlaceholder": "Envoyer un message...",
+    "mention": {
+      "tables": "Tables",
+      "apps": "Applications",
+      "workflows": "Workflows",
+      "folders": "Dossiers"
+    },
+    "inputPlaceholder": "Tapez @ pour ajouter du contexte",
+    "inputPlaceholderFiles": "Collez ou déposez des fichiers ici",
     "thought": "En train de penser",
     "meta": {
       "input": "Entrée",
@@ -1033,6 +1046,8 @@
       "advancedOptions": "Options avancées",
       "namingFieldLabel": "Préfixe du nom de pièce jointe",
       "selectField": "Par défaut: index de pièce jointe",
+      "noPrefixOption": "Sans préfixe",
+      "noPrefixOptionDesc": "Conserver le nom de fichier original",
       "groupByRow": "Archiver dans des dossiers",
       "groupByRowTip": "Lorsqu'une ligne contient plusieurs pièces jointes, elles seront placées dans le même dossier ; les lignes avec une seule pièce jointe ne créeront pas de dossier."
     }
diff --git a/packages/common-i18n/src/locales/it/common.json b/packages/common-i18n/src/locales/it/common.json
index 0a1cbf8dd5..cd96ec63e7 100644
--- a/packages/common-i18n/src/locales/it/common.json
+++ b/packages/common-i18n/src/locales/it/common.json
@@ -164,8 +164,9 @@
   },
   "settings": {
     "title": "Impostazioni dell'istanza",
+    "allSetting": "Impostazioni dello spazio e personali",
     "personal": {
-      "title": "Impostazioni personali"
+      "title": "Personale"
     },
     "templateAdmin": {
       "title": "Gestione modelli",
@@ -890,6 +891,10 @@
           "runQuotaExceeded": {
             "title": "L'automazione {{name}} ha raggiunto il numero massimo mensile di esecuzioni",
             "message": "Le esecuzioni mensili dell'automazione {{name}} sono esaurite e l'esecuzione è temporaneamente non disponibile. Aggiorna l'abbonamento o acquista esecuzioni aggiuntive."
+          },
+          "failedSummary": {
+            "title": "L'automazione {{name}} ha fallito {{failCount}} volte",
+            "message": "La tua automazione {{name}} ha accumulato {{failCount}} errori consecutivi. Apri la cronologia delle esecuzioni per visualizzare i dettagli."
           }
         },
         "billing": {
@@ -1105,9 +1110,9 @@
     }
   },
   "changelog": {
-    "newUpdate": "AGGIORNAMENTO 17 APR",
-    "title": "Claude Opus 4.7 è ora disponibile in Teable",
-    "url": "https://help.teable.ai/en/changelog#apr-17-2026",
-    "id": "changelog-2026-04-17-claude-opus-4-7-is-now-in-teable"
+    "newUpdate": "AGGIORNAMENTO 28 APR",
+    "title": "Nuovo trigger: Quando si riceve un'email (IMAP)",
+    "url": "https://help.teable.ai/en/changelog#apr-28-2026",
+    "id": "changelog-2026-04-28-new-trigger-when-email-receive-imap"
   }
 }
diff --git a/packages/common-i18n/src/locales/it/sdk.json b/packages/common-i18n/src/locales/it/sdk.json
index f7128f8ddd..a77df1f0c2 100644
--- a/packages/common-i18n/src/locales/it/sdk.json
+++ b/packages/common-i18n/src/locales/it/sdk.json
@@ -158,6 +158,7 @@
     },
     "invalidateSelected": "Valore non valido",
     "invalidateSelectedTips": "Il valore selezionato è stato eliminato, per favore seleziona di nuovo",
+    "invalidConditionTip": "Questa condizione di filtro non è valida e verrà ignorata. Regola il valore.",
     "default": {
       "empty": "Nessuna condizione di filtro applicata",
       "placeholder": "Inserisci un valore"
@@ -264,7 +265,8 @@
     "configLabel_other_visible": "{{count}} campi visibili",
     "showAll": "Mostra tutto",
     "hideAll": "Nascondi tutto",
-    "primaryKey": "Campo principale: Identifica i record\nnon può essere nascosto o eliminato, visibile nei record collegati."
+    "primaryKey": "Campo principale: Identifica i record\nnon può essere nascosto o eliminato, visibile nei record collegati.",
+    "notInCurrentView": "Il campo \"{{fieldName}}\" non è visibile nella vista corrente e non può essere raggiunto"
   },
   "expandRecord": {
     "copy": "Copia negli appunti",
@@ -1121,7 +1123,8 @@
       "notAllowedToExecuteSqlWithKeyword": "Non è consentito eseguire SQL con la parola chiave {{keyword}}",
       "whiteListCheckError": "Si è verificato un errore durante il controllo dell'accesso alla tabella: {{message}}",
       "databaseConnectionFailed": "Connessione al database fallita: {{message}}",
-      "executeQuerySqlFailed": "Esecuzione della query SQL fallita: {{message}}"
+      "executeQuerySqlFailed": "Esecuzione della query SQL fallita: {{message}}",
+      "sqlSyntaxError": "Errore di sintassi SQL, controlla la tua query"
     },
     "permission": {
       "createRecordWithDeniedFields": "Non hai il permesso di creare record con campi({{fields}})",
@@ -1221,7 +1224,9 @@
       "button": {
         "clickCountReachedMaxCount": "Il conteggio dei clic sul pulsante ha raggiunto il limite massimo",
         "notSupportReset": "Il campo pulsante non supporta il ripristino"
-      }
+      },
+      "primaryCannotBeLookup": "Il campo primario non può essere configurato come campo Lookup",
+      "primaryFieldAlreadyExists": "La tabella ha già un campo primario"
     },
     "view": {
       "notFound": "Vista non trovata",
@@ -1432,7 +1437,8 @@
       "linkedInPostNotFound": "Post LinkedIn non trovato: {{postId}}",
       "linkedInAuthorNotFound": "Autore LinkedIn non trovato: {{postId}}",
       "fetchLinkedInUserFailed": "Impossibile recuperare l'utente LinkedIn: {{error}}",
-      "domainAlreadyInUse": "Questo dominio è già associato a un'altra app"
+      "domainAlreadyInUse": "Questo dominio è già associato a un'altra app",
+      "domainReserved": "Sottodominio riservato"
     }
   }
 }
diff --git a/packages/common-i18n/src/locales/it/table.json b/packages/common-i18n/src/locales/it/table.json
index f99cd1d33a..767ba8bbb2 100644
--- a/packages/common-i18n/src/locales/it/table.json
+++ b/packages/common-i18n/src/locales/it/table.json
@@ -641,6 +641,11 @@
             }
           }
         }
+      },
+      "errorType": {
+        "InvalidPrimaryLookup": "Campo primario configurato erroneamente come Lookup",
+        "InvalidPrimaryType": "Il campo primario ha un tipo non supportato",
+        "MissingPrimary": "La tabella non ha un campo primario"
       }
     },
     "index": {
@@ -982,6 +987,7 @@
     "expand": "Espandi",
     "history": "Cronologia",
     "close": "Comprimi",
+    "noModel": "Nessun modello disponibile",
     "addAttachment": "Aggiungi allegato",
     "noHistory": "Nessun chat history",
     "noFoundHistory": "Nessun chat history trovato, per favore inizia una nuova conversazione",
@@ -999,7 +1005,14 @@
       "emptyContext": "Nessun contesto da aggiungere",
       "selectionRows": "Righe {{start}}-{{end}}"
     },
-    "inputPlaceholder": "Invia messaggio...",
+    "mention": {
+      "tables": "Tabelle",
+      "apps": "App",
+      "workflows": "Workflow",
+      "folders": "Cartelle"
+    },
+    "inputPlaceholder": "Digita @ per aggiungere contesto",
+    "inputPlaceholderFiles": "Incolla o trascina file qui",
     "thought": "Pensando",
     "meta": {
       "input": "Input",
@@ -1058,6 +1071,8 @@
       "advancedOptions": "Opzioni avanzate",
       "namingFieldLabel": "Prefisso nome allegato",
       "selectField": "Predefinito: indice allegato",
+      "noPrefixOption": "Nessun prefisso",
+      "noPrefixOptionDesc": "Mantieni il nome file originale",
       "groupByRow": "Archivia in cartelle",
       "groupByRowTip": "Quando una riga ha più allegati, verranno inseriti nella stessa cartella; le righe con un solo allegato non creeranno una cartella."
     }
diff --git a/packages/common-i18n/src/locales/ja/common.json b/packages/common-i18n/src/locales/ja/common.json
index 158a0201b0..c836e3dbc3 100644
--- a/packages/common-i18n/src/locales/ja/common.json
+++ b/packages/common-i18n/src/locales/ja/common.json
@@ -164,8 +164,9 @@
   },
   "settings": {
     "title": "インスタンス設定",
+    "allSetting": "スペースと個人設定",
     "personal": {
-      "title": "個人設定"
+      "title": "個人"
     },
     "templateAdmin": {
       "title": "テンプレート管理",
@@ -892,6 +893,10 @@
           "runQuotaExceeded": {
             "title": "自動化{{name}}は月間実行回数の上限に達しました",
             "message": "自動化{{name}}の今月の実行回数を使い切ったため、現在は実行できません。プランをアップグレードするか、追加実行回数を購入してください。"
+          },
+          "failedSummary": {
+            "title": "自動化{{name}}が{{failCount}}回連続で失敗しました",
+            "message": "自動化{{name}}が{{failCount}}回連続で失敗しています。実行履歴を開いて詳細をご確認ください。"
           }
         },
         "billing": {
@@ -1107,9 +1112,9 @@
     }
   },
   "changelog": {
-    "newUpdate": "4月17日 アップデート",
-    "title": "Claude Opus 4.7 が Teable で利用可能に",
-    "url": "https://help.teable.ai/en/changelog#apr-17-2026",
-    "id": "changelog-2026-04-17-claude-opus-4-7-is-now-in-teable"
+    "newUpdate": "4月28日 アップデート",
+    "title": "新しいトリガー：メール受信時（IMAP）",
+    "url": "https://help.teable.ai/en/changelog#apr-28-2026",
+    "id": "changelog-2026-04-28-new-trigger-when-email-receive-imap"
   }
 }
diff --git a/packages/common-i18n/src/locales/ja/sdk.json b/packages/common-i18n/src/locales/ja/sdk.json
index c954b711e9..661eb99b03 100644
--- a/packages/common-i18n/src/locales/ja/sdk.json
+++ b/packages/common-i18n/src/locales/ja/sdk.json
@@ -158,6 +158,7 @@
     },
     "invalidateSelected": "無効な値",
     "invalidateSelectedTips": "選択した値は削除されました。もう一度選択してください",
+    "invalidConditionTip": "このフィルター条件は無効なため無視されます。値を調整してください。",
     "default": {
       "empty": "フィルター条件は適用されません",
       "placeholder": "値を入力してください"
@@ -264,7 +265,8 @@
     "configLabel_other_visible": "{{count}}表示フィールド",
     "showAll": "すべて表示",
     "hideAll": "すべて非表示",
-    "primaryKey": "プライマリフィールド: レコードを識別するために使用され、非表示にしたり削除したりすることはできません"
+    "primaryKey": "プライマリフィールド: レコードを識別するために使用され、非表示にしたり削除したりすることはできません",
+    "notInCurrentView": "フィールド「{{fieldName}}」は現在のビューに表示されていないため、移動できません"
   },
   "expandRecord": {
     "copy": "クリップボードにコピー",
@@ -1121,7 +1123,8 @@
       "notAllowedToExecuteSqlWithKeyword": "キーワード {{keyword}} を含むSQLの実行は許可されていません",
       "whiteListCheckError": "テーブルアクセスの確認中にエラーが発生しました: {{message}}",
       "databaseConnectionFailed": "データベース接続に失敗しました: {{message}}",
-      "executeQuerySqlFailed": "クエリSQLの実行に失敗しました: {{message}}"
+      "executeQuerySqlFailed": "クエリSQLの実行に失敗しました: {{message}}",
+      "sqlSyntaxError": "SQL構文エラーです。クエリを確認してください"
     },
     "permission": {
       "createRecordWithDeniedFields": "フィールド({{fields}})を含むレコードを作成する権限がありません",
@@ -1221,7 +1224,9 @@
       "button": {
         "clickCountReachedMaxCount": "ボタンのクリック数が最大制限に達しました",
         "notSupportReset": "ボタンはリセットをサポートしていません"
-      }
+      },
+      "primaryCannotBeLookup": "主フィールドを Lookup フィールドとして設定することはできません",
+      "primaryFieldAlreadyExists": "テーブルには既に主フィールドがあります"
     },
     "view": {
       "notFound": "ビューが見つかりません",
@@ -1432,7 +1437,8 @@
       "linkedInPostNotFound": "LinkedIn投稿が見つかりません: {{postId}}",
       "linkedInAuthorNotFound": "LinkedIn投稿者が見つかりません: {{postId}}",
       "fetchLinkedInUserFailed": "LinkedInユーザーの取得に失敗しました: {{error}}",
-      "domainAlreadyInUse": "このドメインはすでに別のアプリに紐付けられています"
+      "domainAlreadyInUse": "このドメインはすでに別のアプリに紐付けられています",
+      "domainReserved": "サブドメインは予約済みです"
     }
   }
 }
diff --git a/packages/common-i18n/src/locales/ja/table.json b/packages/common-i18n/src/locales/ja/table.json
index acf3f2e5aa..0a4f92dd80 100644
--- a/packages/common-i18n/src/locales/ja/table.json
+++ b/packages/common-i18n/src/locales/ja/table.json
@@ -632,6 +632,11 @@
             }
           }
         }
+      },
+      "errorType": {
+        "InvalidPrimaryLookup": "主フィールドが Lookup として誤設定",
+        "InvalidPrimaryType": "主フィールドのタイプが非対応",
+        "MissingPrimary": "テーブルに主フィールドがありません"
       }
     },
     "index": {
@@ -956,6 +961,7 @@
     "expand": "展開",
     "history": "履歴",
     "close": "折りたたむ",
+    "noModel": "利用可能なモデルがありません",
     "addAttachment": "添付ファイルを追加",
     "noHistory": "チャット履歴がありません",
     "noFoundHistory": "チャット履歴が見つかりません。新しいチャットを開始してください",
@@ -973,7 +979,14 @@
       "emptyContext": "追加するコンテキストがありません",
       "selectionRows": "行 {{start}}-{{end}}"
     },
-    "inputPlaceholder": "メッセージを送信...",
+    "mention": {
+      "tables": "テーブル",
+      "apps": "アプリ",
+      "workflows": "ワークフロー",
+      "folders": "フォルダ"
+    },
+    "inputPlaceholder": "@ でコンテキストを追加",
+    "inputPlaceholderFiles": "ファイルを貼り付けまたはドロップ",
     "thought": "思考中",
     "meta": {
       "input": "入力",
@@ -1032,6 +1045,8 @@
       "advancedOptions": "詳細オプション",
       "namingFieldLabel": "添付ファイル名のプレフィックス",
       "selectField": "デフォルト: 添付ファイル番号",
+      "noPrefixOption": "プレフィックスなし",
+      "noPrefixOptionDesc": "元のファイル名を保持",
       "groupByRow": "フォルダにアーカイブ",
       "groupByRowTip": "行に複数の添付ファイルがある場合、同じフォルダに配置されます。添付ファイルが1つだけの行はフォルダを作成しません。"
     }
diff --git a/packages/common-i18n/src/locales/ru/common.json b/packages/common-i18n/src/locales/ru/common.json
index 39ccb67d8f..df1d8d19c5 100644
--- a/packages/common-i18n/src/locales/ru/common.json
+++ b/packages/common-i18n/src/locales/ru/common.json
@@ -164,8 +164,9 @@
   },
   "settings": {
     "title": "Настройки экземпляра",
+    "allSetting": "Настройки пространства и личные настройки",
     "personal": {
-      "title": "Личные настройки"
+      "title": "Личное"
     },
     "templateAdmin": {
       "title": "Управление шаблонами",
@@ -848,6 +849,10 @@
           "runQuotaExceeded": {
             "title": "Автоматизация {{name}} достигла максимального месячного лимита запусков",
             "message": "Месячный лимит запусков для автоматизации {{name}} исчерпан, поэтому сейчас запуск недоступен. Обновите подписку или приобретите дополнительные запуски."
+          },
+          "failedSummary": {
+            "title": "Автоматизация {{name}} завершилась ошибкой {{failCount}} раз",
+            "message": "Ваша автоматизация {{name}} накопила {{failCount}} последовательных ошибок. Откройте историю запусков для просмотра деталей."
           }
         },
         "billing": {
@@ -1063,9 +1068,9 @@
     }
   },
   "changelog": {
-    "newUpdate": "ОБНОВЛЕНИЕ 17 АПР",
-    "title": "Claude Opus 4.7 теперь доступен в Teable",
-    "url": "https://help.teable.ai/en/changelog#apr-17-2026",
-    "id": "changelog-2026-04-17-claude-opus-4-7-is-now-in-teable"
+    "newUpdate": "ОБНОВЛЕНИЕ 28 АПР",
+    "title": "Новый триггер: При получении письма (IMAP)",
+    "url": "https://help.teable.ai/en/changelog#apr-28-2026",
+    "id": "changelog-2026-04-28-new-trigger-when-email-receive-imap"
   }
 }
diff --git a/packages/common-i18n/src/locales/ru/sdk.json b/packages/common-i18n/src/locales/ru/sdk.json
index 276ab5a3e9..5d854e624b 100644
--- a/packages/common-i18n/src/locales/ru/sdk.json
+++ b/packages/common-i18n/src/locales/ru/sdk.json
@@ -158,6 +158,7 @@
     },
     "invalidateSelected": "Неверное значение",
     "invalidateSelectedTips": "Выбранное значение было удалено, выберите другое",
+    "invalidConditionTip": "Это условие фильтра недопустимо и будет проигнорировано. Измените значение.",
     "default": {
       "empty": "Фильтры не применены",
       "placeholder": "Введите значение"
@@ -264,7 +265,8 @@
     "configLabel_other_visible": "{{count}} видимых поля",
     "showAll": "Показать все",
     "hideAll": "Скрыть все",
-    "primaryKey": "Основное поле: Идентифицирует записи\nнельзя скрыть или удалить, видно в связанных записях."
+    "primaryKey": "Основное поле: Идентифицирует записи\nнельзя скрыть или удалить, видно в связанных записях.",
+    "notInCurrentView": "Поле «{{fieldName}}» не отображается в текущем представлении, поэтому перейти к нему нельзя"
   },
   "expandRecord": {
     "copy": "Копировать в буфер обмена",
@@ -1121,7 +1123,8 @@
       "notAllowedToExecuteSqlWithKeyword": "Не разрешено выполнять SQL с ключевым словом {{keyword}}",
       "whiteListCheckError": "Произошла ошибка при проверке доступа к таблице: {{message}}",
       "databaseConnectionFailed": "Не удалось подключиться к базе данных: {{message}}",
-      "executeQuerySqlFailed": "Не удалось выполнить запрос SQL: {{message}}"
+      "executeQuerySqlFailed": "Не удалось выполнить запрос SQL: {{message}}",
+      "sqlSyntaxError": "Ошибка синтаксиса SQL, проверьте ваш запрос"
     },
     "permission": {
       "createRecordWithDeniedFields": "У вас нет разрешения на создание записей с полями({{fields}})",
@@ -1221,7 +1224,9 @@
       "button": {
         "clickCountReachedMaxCount": "Количество нажатий кнопки достигло максимального предела",
         "notSupportReset": "Кнопка не поддерживает сброс"
-      }
+      },
+      "primaryCannotBeLookup": "Основное поле не может быть настроено как поле Lookup",
+      "primaryFieldAlreadyExists": "В таблице уже есть основное поле"
     },
     "view": {
       "notFound": "Представление не найдено",
@@ -1432,7 +1437,8 @@
       "linkedInPostNotFound": "Публикация LinkedIn не найдена: {{postId}}",
       "linkedInAuthorNotFound": "Автор LinkedIn не найден: {{postId}}",
       "fetchLinkedInUserFailed": "Не удалось получить пользователя LinkedIn: {{error}}",
-      "domainAlreadyInUse": "Этот домен уже привязан к другому приложению"
+      "domainAlreadyInUse": "Этот домен уже привязан к другому приложению",
+      "domainReserved": "Поддомен зарезервирован"
     }
   }
 }
diff --git a/packages/common-i18n/src/locales/ru/table.json b/packages/common-i18n/src/locales/ru/table.json
index a4a51abbc7..008260144e 100644
--- a/packages/common-i18n/src/locales/ru/table.json
+++ b/packages/common-i18n/src/locales/ru/table.json
@@ -632,6 +632,11 @@
             }
           }
         }
+      },
+      "errorType": {
+        "InvalidPrimaryLookup": "Основное поле неправильно настроено как Lookup",
+        "InvalidPrimaryType": "Основное поле имеет неподдерживаемый тип",
+        "MissingPrimary": "В таблице отсутствует основное поле"
       }
     },
     "index": {
@@ -957,6 +962,7 @@
     "expand": "Развернуть",
     "history": "История",
     "close": "Свернуть",
+    "noModel": "Нет доступных моделей",
     "addAttachment": "Добавить вложение",
     "noHistory": "Нет истории чата",
     "noFoundHistory": "Нет истории чата, пожалуйста, начните новую беседу",
@@ -974,7 +980,14 @@
       "emptyContext": "Нет контекста для добавления",
       "selectionRows": "Строки {{start}}-{{end}}"
     },
-    "inputPlaceholder": "Отправить сообщение...",
+    "mention": {
+      "tables": "Таблицы",
+      "apps": "Приложения",
+      "workflows": "Рабочие процессы",
+      "folders": "Папки"
+    },
+    "inputPlaceholder": "Введите @, чтобы добавить контекст",
+    "inputPlaceholderFiles": "Вставьте или перетащите файлы сюда",
     "thought": "Мысли",
     "meta": {
       "input": "Ввод",
@@ -1033,6 +1046,8 @@
       "advancedOptions": "Дополнительные параметры",
       "namingFieldLabel": "Префикс имени вложения",
       "selectField": "По умолчанию: индекс вложения",
+      "noPrefixOption": "Без префикса",
+      "noPrefixOptionDesc": "Сохранить исходное имя файла",
       "groupByRow": "Архивировать в папки",
       "groupByRowTip": "Когда в строке несколько вложений, они будут помещены в одну папку; строки с одним вложением не создадут папку."
     }
diff --git a/packages/common-i18n/src/locales/tr/common.json b/packages/common-i18n/src/locales/tr/common.json
index 51af08a2bf..7ecfafab78 100644
--- a/packages/common-i18n/src/locales/tr/common.json
+++ b/packages/common-i18n/src/locales/tr/common.json
@@ -164,8 +164,9 @@
   },
   "settings": {
     "title": "Örnek Ayarları",
+    "allSetting": "Alan ve kişisel ayarlar",
     "personal": {
-      "title": "Kişisel ayarlar"
+      "title": "Kişisel"
     },
     "templateAdmin": {
       "title": "Şablon yönetimi",
@@ -849,6 +850,10 @@
           "runQuotaExceeded": {
             "title": "Otomasyon {{name}} aylık maksimum çalıştırma sayısına ulaştı",
             "message": "Otomasyon {{name}} için aylık çalıştırma hakkı tükendiği için şu anda çalıştırılamıyor. Aboneliğinizi yükseltin veya ek çalıştırma satın alın."
+          },
+          "failedSummary": {
+            "title": "Otomasyon {{name}} {{failCount}} kez başarısız oldu",
+            "message": "Otomasyonunuz {{name}} art arda {{failCount}} kez başarısız oldu. Ayrıntıları görmek için çalıştırma geçmişini açın."
           }
         },
         "billing": {
@@ -1095,9 +1100,9 @@
     }
   },
   "changelog": {
-    "newUpdate": "17 NİS GÜNCELLEMESİ",
-    "title": "Claude Opus 4.7 artık Teable'da",
-    "url": "https://help.teable.ai/en/changelog#apr-17-2026",
-    "id": "changelog-2026-04-17-claude-opus-4-7-is-now-in-teable"
+    "newUpdate": "28 NİS GÜNCELLEMESİ",
+    "title": "Yeni Tetikleyici: E-posta Alındığında (IMAP)",
+    "url": "https://help.teable.ai/en/changelog#apr-28-2026",
+    "id": "changelog-2026-04-28-new-trigger-when-email-receive-imap"
   }
 }
diff --git a/packages/common-i18n/src/locales/tr/sdk.json b/packages/common-i18n/src/locales/tr/sdk.json
index 690689a9c0..050e843d1b 100644
--- a/packages/common-i18n/src/locales/tr/sdk.json
+++ b/packages/common-i18n/src/locales/tr/sdk.json
@@ -158,6 +158,7 @@
     },
     "invalidateSelected": "Geçersiz değer",
     "invalidateSelectedTips": "Seçilen değer silindi, lütfen tekrar seçin",
+    "invalidConditionTip": "Bu filtre koşulu geçersiz ve yok sayılacak. Lütfen değeri ayarlayın.",
     "default": {
       "empty": "Filtre koşulu uygulanmadı",
       "placeholder": "Bir değer girin"
@@ -264,7 +265,8 @@
     "configLabel_other_visible": "{{count}} görünür alan",
     "showAll": "Tümünü Göster",
     "hideAll": "Tümünü Gizle",
-    "primaryKey": "Birincil alan: Kayıtları tanımlar\ngizlenemez veya silinemez, bağlantılı kayıtlarda görünür."
+    "primaryKey": "Birincil alan: Kayıtları tanımlar\ngizlenemez veya silinemez, bağlantılı kayıtlarda görünür.",
+    "notInCurrentView": "\"{{fieldName}}\" alanı mevcut görünümde görünmüyor, bu yüzden alana gidilemiyor"
   },
   "expandRecord": {
     "copy": "Panoya kopyala",
@@ -1121,7 +1123,8 @@
       "notAllowedToExecuteSqlWithKeyword": "{{keyword}} anahtar kelimesiyle SQL çalıştırılmasına izin verilmiyor",
       "whiteListCheckError": "Tablo erişimi kontrol edilirken bir hata oluştu: {{message}}",
       "databaseConnectionFailed": "Veritabanı bağlantısı başarısız oldu: {{message}}",
-      "executeQuerySqlFailed": "Sorgu SQL'i çalıştırılamadı: {{message}}"
+      "executeQuerySqlFailed": "Sorgu SQL'i çalıştırılamadı: {{message}}",
+      "sqlSyntaxError": "SQL sözdizimi hatası, lütfen sorgunuzu kontrol edin"
     },
     "permission": {
       "createRecordWithDeniedFields": "Alanları({{fields}}) olan kayıtlar oluşturma izniniz yok",
@@ -1221,7 +1224,9 @@
       "button": {
         "clickCountReachedMaxCount": "Düğme tıklama sayısı maksimum sınıra ulaştı",
         "notSupportReset": "Düğme sıfırlamayı desteklemiyor"
-      }
+      },
+      "primaryCannotBeLookup": "Birincil alan Lookup alanı olarak yapılandırılamaz",
+      "primaryFieldAlreadyExists": "Tablonun zaten bir birincil alanı var"
     },
     "view": {
       "notFound": "Görünüm bulunamadı",
@@ -1432,7 +1437,8 @@
       "linkedInPostNotFound": "LinkedIn gönderisi bulunamadı: {{postId}}",
       "linkedInAuthorNotFound": "LinkedIn yazarı bulunamadı: {{postId}}",
       "fetchLinkedInUserFailed": "LinkedIn kullanıcısı alınamadı: {{error}}",
-      "domainAlreadyInUse": "Bu alan adı zaten başka bir uygulamaya bağlı"
+      "domainAlreadyInUse": "Bu alan adı zaten başka bir uygulamaya bağlı",
+      "domainReserved": "Alt alan adı ayrılmış"
     }
   }
 }
diff --git a/packages/common-i18n/src/locales/tr/table.json b/packages/common-i18n/src/locales/tr/table.json
index 9e9f81204f..f54f195da4 100644
--- a/packages/common-i18n/src/locales/tr/table.json
+++ b/packages/common-i18n/src/locales/tr/table.json
@@ -640,6 +640,11 @@
             }
           }
         }
+      },
+      "errorType": {
+        "InvalidPrimaryLookup": "Birincil alan Lookup olarak yanlış yapılandırıldı",
+        "InvalidPrimaryType": "Birincil alanın türü desteklenmiyor",
+        "MissingPrimary": "Tabloda birincil alan yok"
       }
     }
   },
@@ -878,6 +883,8 @@
       "advancedOptions": "Gelişmiş seçenekler",
       "namingFieldLabel": "Ek adı öneki",
       "selectField": "Varsayılan: ek dizini",
+      "noPrefixOption": "Önek yok",
+      "noPrefixOptionDesc": "Orijinal dosya adını koru",
       "groupByRow": "Klasörlere arşivle",
       "groupByRowTip": "Bir satırda birden fazla ek varsa, aynı klasöre yerleştirilir; yalnızca bir eki olan satırlar klasör oluşturmaz."
     }
@@ -951,10 +958,19 @@
     "shareNodeTab": "Düğümü paylaş"
   },
   "aiChat": {
+    "noModel": "Kullanılabilir model yok",
     "agent": {
       "askUserQuestion": {
         "otherPlaceholder": "Veya yanıtınızı yazın…"
       }
-    }
+    },
+    "mention": {
+      "tables": "Tablolar",
+      "apps": "Uygulamalar",
+      "workflows": "İş akışları",
+      "folders": "Klasörler"
+    },
+    "inputPlaceholder": "Bağlam eklemek için @ yazın",
+    "inputPlaceholderFiles": "Dosyaları buraya yapıştırın veya bırakın"
   }
 }
diff --git a/packages/common-i18n/src/locales/uk/common.json b/packages/common-i18n/src/locales/uk/common.json
index 40eefbb58f..46c0dccc6f 100644
--- a/packages/common-i18n/src/locales/uk/common.json
+++ b/packages/common-i18n/src/locales/uk/common.json
@@ -151,8 +151,9 @@
   },
   "settings": {
     "title": "Приклад налаштувань",
+    "allSetting": "Налаштування простору й особисті",
     "personal": {
-      "title": "Особисті налаштування"
+      "title": "Особисте"
     },
     "templateAdmin": {
       "title": "Керування шаблонами",
@@ -838,6 +839,10 @@
           "runQuotaExceeded": {
             "title": "Автоматизація {{name}} досягла максимального місячного ліміту запусків",
             "message": "Місячний ліміт запусків для автоматизації {{name}} вичерпано, тому зараз запуск недоступний. Оновіть підписку або придбайте додаткові запуски."
+          },
+          "failedSummary": {
+            "title": "Автоматизація {{name}} завершилася помилкою {{failCount}} разів",
+            "message": "Ваша автоматизація {{name}} накопичила {{failCount}} послідовних помилок. Відкрийте історію запусків, щоб переглянути деталі."
           }
         },
         "billing": {
@@ -1084,9 +1089,9 @@
     }
   },
   "changelog": {
-    "newUpdate": "ОНОВЛЕННЯ 17 КВІТ",
-    "title": "Claude Opus 4.7 тепер доступний у Teable",
-    "url": "https://help.teable.ai/en/changelog#apr-17-2026",
-    "id": "changelog-2026-04-17-claude-opus-4-7-is-now-in-teable"
+    "newUpdate": "ОНОВЛЕННЯ 28 КВІТ",
+    "title": "Новий тригер: При отриманні електронного листа (IMAP)",
+    "url": "https://help.teable.ai/en/changelog#apr-28-2026",
+    "id": "changelog-2026-04-28-new-trigger-when-email-receive-imap"
   }
 }
diff --git a/packages/common-i18n/src/locales/uk/sdk.json b/packages/common-i18n/src/locales/uk/sdk.json
index 26aff93b15..28f7be55ad 100644
--- a/packages/common-i18n/src/locales/uk/sdk.json
+++ b/packages/common-i18n/src/locales/uk/sdk.json
@@ -158,6 +158,7 @@
     },
     "invalidateSelected": "Недійсне значення",
     "invalidateSelectedTips": "Вибране значення видалено, виберіть ще раз",
+    "invalidConditionTip": "Ця умова фільтра недійсна і буде проігнорована. Змініть значення.",
     "default": {
       "empty": "Умови фільтрування не застосовуються",
       "placeholder": "Введіть значення"
@@ -264,7 +265,8 @@
     "configLabel_other_visible": "{{count}} видимих ​​полів",
     "showAll": "Показати все",
     "hideAll": "Приховати все",
-    "primaryKey": "Основне поле: Ідентифікує записи\nне можна приховати або видалити, видно у зв'язаних записах."
+    "primaryKey": "Основне поле: Ідентифікує записи\nне можна приховати або видалити, видно у зв'язаних записах.",
+    "notInCurrentView": "Поле «{{fieldName}}» не відображається в поточному поданні, тому перейти до нього не можна"
   },
   "expandRecord": {
     "copy": "Копіювати в буфер обміну",
@@ -1121,7 +1123,8 @@
       "notAllowedToExecuteSqlWithKeyword": "Не дозволено виконувати SQL з ключовим словом {{keyword}}",
       "whiteListCheckError": "Сталася помилка під час перевірки доступу до таблиці: {{message}}",
       "databaseConnectionFailed": "Не вдалося підключитися до бази даних: {{message}}",
-      "executeQuerySqlFailed": "Не вдалося виконати запит SQL: {{message}}"
+      "executeQuerySqlFailed": "Не вдалося виконати запит SQL: {{message}}",
+      "sqlSyntaxError": "Помилка синтаксису SQL, перевірте ваш запит"
     },
     "permission": {
       "createRecordWithDeniedFields": "У вас немає дозволу на створення записів з полями({{fields}})",
@@ -1221,7 +1224,9 @@
       "button": {
         "clickCountReachedMaxCount": "Кількість натискань кнопки досягла максимальної межі",
         "notSupportReset": "Кнопка не підтримує скидання"
-      }
+      },
+      "primaryCannotBeLookup": "Первинне поле не може бути налаштовано як поле Lookup",
+      "primaryFieldAlreadyExists": "У таблиці вже є первинне поле"
     },
     "view": {
       "notFound": "Представлення не знайдено",
@@ -1432,7 +1437,8 @@
       "linkedInPostNotFound": "Публікацію LinkedIn не знайдено: {{postId}}",
       "linkedInAuthorNotFound": "Автора LinkedIn не знайдено: {{postId}}",
       "fetchLinkedInUserFailed": "Не вдалося отримати користувача LinkedIn: {{error}}",
-      "domainAlreadyInUse": "Цей домен вже прив'язаний до іншого додатка"
+      "domainAlreadyInUse": "Цей домен вже прив'язаний до іншого додатка",
+      "domainReserved": "Піддомен зарезервований"
     }
   }
 }
diff --git a/packages/common-i18n/src/locales/uk/table.json b/packages/common-i18n/src/locales/uk/table.json
index 49fd56f44b..b272eca117 100644
--- a/packages/common-i18n/src/locales/uk/table.json
+++ b/packages/common-i18n/src/locales/uk/table.json
@@ -641,6 +641,11 @@
             }
           }
         }
+      },
+      "errorType": {
+        "InvalidPrimaryLookup": "Первинне поле неправильно налаштовано як Lookup",
+        "InvalidPrimaryType": "Первинне поле має непідтримуваний тип",
+        "MissingPrimary": "У таблиці відсутнє первинне поле"
       }
     },
     "index": {
@@ -976,6 +981,7 @@
     "expand": "Розгорнути",
     "history": "Історія",
     "close": "Згорнути",
+    "noModel": "Немає доступних моделей",
     "addAttachment": "Додати вкладення",
     "noHistory": "Немає історії чату",
     "noFoundHistory": "Немає історії чату, будь ласка, почати нову розмову",
@@ -993,7 +999,14 @@
       "emptyContext": "Немає контексту для додавання",
       "selectionRows": "Рядки {{start}}-{{end}}"
     },
-    "inputPlaceholder": "Відправити повідомлення...",
+    "mention": {
+      "tables": "Таблиці",
+      "apps": "Програми",
+      "workflows": "Робочі процеси",
+      "folders": "Папки"
+    },
+    "inputPlaceholder": "Введіть @, щоб додати контекст",
+    "inputPlaceholderFiles": "Вставте або перетягніть файли сюди",
     "thought": "Міркування",
     "meta": {
       "input": "Вхід",
@@ -1052,6 +1065,8 @@
       "advancedOptions": "Додаткові параметри",
       "namingFieldLabel": "Префікс імені вкладення",
       "selectField": "За замовчуванням: індекс вкладення",
+      "noPrefixOption": "Без префікса",
+      "noPrefixOptionDesc": "Зберегти оригінальну назву файлу",
       "groupByRow": "Архівувати в папки",
       "groupByRowTip": "Коли рядок має кілька вкладень, вони будуть розміщені в одній папці; рядки з одним вкладенням не створюють папку."
     }
diff --git a/packages/common-i18n/src/locales/zh/common.json b/packages/common-i18n/src/locales/zh/common.json
index e39c6e2afb..884d9cf517 100644
--- a/packages/common-i18n/src/locales/zh/common.json
+++ b/packages/common-i18n/src/locales/zh/common.json
@@ -174,8 +174,9 @@
   },
   "settings": {
     "title": "实例设置",
+    "allSetting": "个人 & 空间设置",
     "personal": {
-      "title": "个人设置"
+      "title": "个人"
     },
     "templateAdmin": {
       "title": "模板管理",
@@ -1201,6 +1202,10 @@
           "runQuotaExceeded": {
             "title": "自动化 {{name}} 已触及每月最大运行次数",
             "message": "自动化 {{name}} 本月可运行次数已用完，暂时无法继续运行。请升级订阅或购买额外运行次数。"
+          },
+          "failedSummary": {
+            "title": "自动化 {{name}} 已连续失败 {{failCount}} 次",
+            "message": "自动化 {{name}} 已累计连续失败 {{failCount}} 次，请前往运行历史查看详情。"
           }
         },
         "billing": {
@@ -1449,9 +1454,9 @@
     }
   },
   "changelog": {
-    "newUpdate": "4月17日 更新",
-    "title": "Claude Opus 4.7 现已接入 Teable",
-    "url": "https://help.teable.ai/en/changelog#apr-17-2026",
-    "id": "changelog-2026-04-17-claude-opus-4-7-is-now-in-teable"
+    "newUpdate": "4月28日 更新",
+    "title": "邮件接收触发器（IMAP）上线",
+    "url": "https://help.teable.ai/en/changelog#apr-28-2026",
+    "id": "changelog-2026-04-28-new-trigger-when-email-receive-imap"
   }
 }
diff --git a/packages/common-i18n/src/locales/zh/sdk.json b/packages/common-i18n/src/locales/zh/sdk.json
index 108cd5bba5..1a84dbb2cc 100644
--- a/packages/common-i18n/src/locales/zh/sdk.json
+++ b/packages/common-i18n/src/locales/zh/sdk.json
@@ -191,6 +191,7 @@
     },
     "invalidateSelected": "已删除选项",
     "invalidateSelectedTips": "该选项已被删除，请重新选择",
+    "invalidConditionTip": "此筛选条件无效，将被忽略。请调整后重试。",
     "default": {
       "empty": "当前没有应用任何筛选条件",
       "placeholder": "请输入"
@@ -298,7 +299,8 @@
     "configLabel_other_visible": "字段配置({{count}} 显示)",
     "showAll": "显示全部",
     "hideAll": "隐藏全部",
-    "primaryKey": "主字段：用于标识记录，不可隐藏或删除\n其值会在关联记录中显示"
+    "primaryKey": "主字段：用于标识记录，不可隐藏或删除\n其值会在关联记录中显示",
+    "notInCurrentView": "字段“{{fieldName}}”不在当前视图中显示，无法跳转"
   },
   "expandRecord": {
     "copy": "复制到剪贴板",
@@ -1139,7 +1141,8 @@
       "whiteListCheckError": "检查表访问时发生错误：{{message}}",
       "databaseConnectionFailed": "数据库连接失败：{{message}}",
       "executeQuerySqlFailed": "执行查询 SQL 失败：{{message}}",
-      "readOnlyCheckFailed": "只读检查失败：{{message}}"
+      "readOnlyCheckFailed": "只读检查失败：{{message}}",
+      "sqlSyntaxError": "SQL 语法错误，请检查查询语句"
     },
     "permission": {
       "createRecordWithDeniedFields": "没有权限创建带有字段({{fields}})的记录",
@@ -1241,7 +1244,9 @@
       "button": {
         "clickCountReachedMaxCount": "按钮点击次数已达到最大限制",
         "notSupportReset": "按钮不支持重置"
-      }
+      },
+      "primaryCannotBeLookup": "主字段不能配置为 Lookup 字段",
+      "primaryFieldAlreadyExists": "表已经有主字段"
     },
     "view": {
       "notFound": "视图不存在",
@@ -1439,7 +1444,8 @@
       "noFilesInZip": "ZIP 文件中没有找到文件",
       "zipFileTooLarge": "ZIP 文件大小超过 5MB 限制",
       "invalidZip": "无效的 ZIP 文件",
-      "domainAlreadyInUse": "该域名已被其他应用绑定"
+      "domainAlreadyInUse": "该域名已被其他应用绑定",
+      "domainReserved": "子域名已被保留"
     },
     "reward": {
       "notFound": "奖励记录不存在",
diff --git a/packages/common-i18n/src/locales/zh/table.json b/packages/common-i18n/src/locales/zh/table.json
index 93aa89801f..dc03e304ae 100644
--- a/packages/common-i18n/src/locales/zh/table.json
+++ b/packages/common-i18n/src/locales/zh/table.json
@@ -256,6 +256,7 @@
       "reset": "清空",
       "fieldUpdated": "字段已更新",
       "fieldCreated": "字段已创建",
+      "fieldUnavailable": "字段当前不可用，请刷新表格后重试。",
       "confirmFieldChange": "确认字段变更",
       "areYouSurePerformIt": "确定要执行此操作吗？",
       "addDescription": "添加描述",
@@ -662,6 +663,20 @@
         "manualRepairDialogClose": "关闭",
         "manualRepairPreview": "手动修复配置",
         "manualRepairPreviewTip": "当前仅展示规则要求用户提供的修复选项，尚未真正提交执行。",
+        "repairPreviewTitle": "确认修复内容",
+        "repairPreviewDescription": "下面是 dry-run 返回的修复说明和将要执行的 SQL。确认后才会真正执行修复。",
+        "repairPreviewTooltip": "点击查看 dry-run 修复计划，弹窗会显示实际返回的 SQL；如果没有 SQL，也会明确提示。",
+        "repairPreviewMissingTable": "当前检查结果缺少表信息，无法定位 dry-run 修复目标。",
+        "repairPreviewUnavailableStatus": "当前状态不需要修复，无法生成 dry-run 修复计划。",
+        "repairPreviewWhat": "将修复什么",
+        "repairPreviewTarget": "字段「{{fieldName}}」的「{{ruleName}}」规则",
+        "repairPreviewPrinciple": "修复原理",
+        "repairPreviewNoPrinciple": "该规则未返回额外的修复原理说明。",
+        "repairPreviewSql": "将执行的 SQL",
+        "repairPreviewNoSql": "dry-run 没有返回可执行 SQL，当前不能直接执行自动修复。",
+        "repairPreviewCannotConfirm": "dry-run 返回了 SQL，但该规则当前不支持自动修复确认，只能查看修复计划。",
+        "repairPreviewParameters": "参数",
+        "repairPreviewConfirm": "确认执行修复",
         "checking": "正在检查 schema...",
         "repairing": "正在修复 schema...",
         "streamError": "Schema 完整性流式请求失败。",
@@ -771,6 +786,7 @@
             "junctionForeignKeyOrphanRows": "当前无法自动修复：中间表仍存在无效关系行"
           },
           "description": {
+            "autoRule": "修复会执行该规则生成的 schema 语句，然后重新校验规则，确认 schema 已恢复为正确状态。",
             "symmetricFieldConflict": "有多个字段同时指向同一个对称关联目标。需要先决定哪一个字段应该保留双向关联关系，再继续修复。",
             "foreignKeyTargetTableMissing": "请先确认关联目标表 {{targetPhysicalTableName}} 是否已被删除或重命名。恢复目标表后可重新执行修复；如果该关联已经不再需要，请修改或删除字段「{{fieldName}}」的关联配置。",
             "foreignKeyOrphanRows": "请先清理字段「{{fieldName}}」中指向不存在记录的无效关联数据，然后再重新执行修复。",
@@ -832,7 +848,10 @@
         "ReferenceFieldNotFound": "引用字段不存在",
         "UniqueIndexNotFound": "唯一索引不存在",
         "EmptyString": "存在空字符串单元格",
-        "InvalidFilterOperator": "无效的筛选操作符"
+        "InvalidFilterOperator": "无效的筛选操作符",
+        "InvalidPrimaryLookup": "主字段被错误配置为 Lookup",
+        "InvalidPrimaryType": "主字段类型不支持",
+        "MissingPrimary": "表缺少主字段"
       }
     },
     "index": {
@@ -947,6 +966,8 @@
       "advancedOptions": "高级选项",
       "namingFieldLabel": "附件名前缀",
       "selectField": "默认附件序号",
+      "noPrefixOption": "无前缀",
+      "noPrefixOptionDesc": "保留原始文件名",
       "groupByRow": "归档到文件夹",
       "groupByRowTip": "同一行有多个附件时，会放入同一个文件夹中；只有一个附件的行不会创建文件夹。"
     }
@@ -1262,9 +1283,12 @@
     "expand": "展开",
     "history": "历史记录",
     "close": "收起",
+    "noModel": "没有可用的模型",
     "clearChatConfirmTitle": "确认清除对话",
     "clearChatConfirmDesc": "当前对话内容将不会被保存，确定要清除吗？",
     "dontShowAgain": "不再提醒",
+    "modelSwitchTitle": "切换模型",
+    "modelSwitchHint": "本对话当前由 {{previous}} 处理，发送后切换至新模型，仅携带最近 3 轮对话。",
     "sandboxExpiry": {
       "expiresIn": "智能体的计算机将在 {{time}} 后到期",
       "reset": "续期",
@@ -1296,7 +1320,14 @@
       "emptyContext": "暂无可添加的上下文",
       "selectionRows": "行 {{start}}-{{end}}"
     },
-    "inputPlaceholder": "描述你想要做什么",
+    "mention": {
+      "tables": "数据表",
+      "apps": "应用",
+      "workflows": "工作流",
+      "folders": "文件夹"
+    },
+    "inputPlaceholder": "输入 @ 添加上下文",
+    "inputPlaceholderFiles": "粘贴或拖入文件",
     "thought": "深度思考",
     "meta": {
       "input": "输入",
@@ -1353,7 +1384,10 @@
     },
     "retry": {
       "interrupted": "响应已中断",
-      "button": "重试"
+      "button": "重试",
+      "offline": "当前无网络连接，恢复后将自动重试。",
+      "pausedHidden": "已暂停重试，请切回此标签页以重新连接。",
+      "maxAttemptsReached": "自动重试未成功，请手动刷新页面。"
     },
     "guide": {
       "goToScenario": "跳转到场景 {{index}}"
diff --git a/packages/core/src/auth/actions.ts b/packages/core/src/auth/actions.ts
index 59712d96d2..b5b8b406ad 100644
--- a/packages/core/src/auth/actions.ts
+++ b/packages/core/src/auth/actions.ts
@@ -134,13 +134,29 @@ export type ActionPrefixMap = {
   [ActionPrefix.View]: ViewAction[];
   [ActionPrefix.Field]: FieldAction[];
   [ActionPrefix.Record]: RecordAction[];
+  [ActionPrefix.TableRecordHistory]: TableRecordHistoryAction[];
   [ActionPrefix.Automation]: AutomationAction[];
   [ActionPrefix.App]: AppAction[];
   [ActionPrefix.User]: UserAction[];
-  [ActionPrefix.TableRecordHistory]: TableRecordHistoryAction[];
   [ActionPrefix.Instance]: InstanceAction[];
   [ActionPrefix.Enterprise]: EnterpriseAction[];
 };
+
+export const allActions: readonly Action[] = [
+  ...spaceActions,
+  ...baseActions,
+  ...tableActions,
+  ...viewActions,
+  ...fieldActions,
+  ...recordActions,
+  ...tableRecordHistoryActions,
+  ...automationActions,
+  ...appActions,
+  ...userActions,
+  ...instanceActions,
+  ...enterpriseActions,
+];
+
 export const actionPrefixMap: ActionPrefixMap = {
   [ActionPrefix.Space]: [...spaceActions],
   [ActionPrefix.Base]: [...baseActions],
@@ -148,9 +164,9 @@ export const actionPrefixMap: ActionPrefixMap = {
   [ActionPrefix.View]: [...viewActions],
   [ActionPrefix.Field]: [...fieldActions],
   [ActionPrefix.Record]: [...recordActions],
+  [ActionPrefix.TableRecordHistory]: [...tableRecordHistoryActions],
   [ActionPrefix.Automation]: [...automationActions],
   [ActionPrefix.App]: [...appActions],
-  [ActionPrefix.TableRecordHistory]: [...tableRecordHistoryActions],
   [ActionPrefix.User]: [...userActions],
   [ActionPrefix.Instance]: [...instanceActions],
   [ActionPrefix.Enterprise]: [...enterpriseActions],
diff --git a/packages/core/src/models/field/ai-config/attachment.ts b/packages/core/src/models/field/ai-config/attachment.ts
index d9880de181..9fcba879e0 100644
--- a/packages/core/src/models/field/ai-config/attachment.ts
+++ b/packages/core/src/models/field/ai-config/attachment.ts
@@ -48,7 +48,9 @@ export const attachmentFieldAIConfigBaseSchema = commonFieldAIConfig.extend({
   // Aspect ratio for multimodal LLMs (Gemini, etc.) - injected into prompt
   aspectRatio: z
     .string()
-    .regex(/^\d+:\d+$/, { message: 'Aspect ratio must be in "width:height" format, e.g., "16:9"' })
+    .regex(/^\d+(?:\.\d+)?:\d+(?:\.\d+)?$/, {
+      message: 'Aspect ratio must be in "width:height" format, e.g., "16:9"',
+    })
     .optional(),
   // Resolution for multimodal LLMs (1K, 2K, 4K) - injected into prompt
   resolution: z.enum(IMAGE_RESOLUTIONS).optional(),
diff --git a/packages/core/src/models/field/derivate/formula.field.spec.ts b/packages/core/src/models/field/derivate/formula.field.spec.ts
index a8e198d220..0b4d367bec 100644
--- a/packages/core/src/models/field/derivate/formula.field.spec.ts
+++ b/packages/core/src/models/field/derivate/formula.field.spec.ts
@@ -238,6 +238,19 @@ describe('FormulaFieldCore', () => {
       expect(converted).toBe('{fld123} + 1');
     });
 
+    it('should convert localized BLANK comparisons with spaced function calls', () => {
+      const dependFieldMap = {
+        fldWeight: { name: '入职体重(kg)' },
+      };
+
+      expect(
+        FormulaFieldCore.convertExpressionNameToId('{入职体重(kg)} !=BLANK()', dependFieldMap)
+      ).toBe('{fldWeight} !=BLANK()');
+      expect(
+        FormulaFieldCore.convertExpressionNameToId('{入职体重(kg)} != BLANK()', dependFieldMap)
+      ).toBe('{fldWeight} != BLANK()');
+    });
+
     it('should return current typed value with field context', () => {
       expect(FormulaFieldCore.getParsedValueType('2 + 2', {})).toEqual({
         cellValueType: CellValueType.Number,
diff --git a/packages/core/src/models/view/filter/filter.spec.ts b/packages/core/src/models/view/filter/filter.spec.ts
index 0eb837db5f..906eee2192 100644
--- a/packages/core/src/models/view/filter/filter.spec.ts
+++ b/packages/core/src/models/view/filter/filter.spec.ts
@@ -1,5 +1,6 @@
+import { CellValueType, FieldType } from '../../field/constant';
 import type { IFilter } from './filter';
-import { filterSchema } from './filter';
+import { analyzeFilterValidationIssues, filterSchema } from './filter';
 
 describe('Filter Parse', () => {
   it('should parse single filter', async () => {
@@ -115,3 +116,227 @@ describe('Filter Parse', () => {
     });
   });
 });
+
+describe('analyzeFilterValidationIssues', () => {
+  const dateFieldId = 'fldDate0000000000';
+  const dateReferenceFieldId = 'fldDateRef0000000';
+  const numberFieldId = 'fldNumber00000000';
+
+  const fieldMetaMap = {
+    [dateFieldId]: {
+      type: FieldType.Date,
+      cellValueType: CellValueType.DateTime,
+    },
+    [dateReferenceFieldId]: {
+      type: FieldType.Date,
+      cellValueType: CellValueType.DateTime,
+    },
+    [numberFieldId]: {
+      type: FieldType.Number,
+      cellValueType: CellValueType.Number,
+    },
+  };
+
+  it('reports invalid operator for the field type', () => {
+    const filter: IFilter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: numberFieldId,
+          operator: 'contains',
+          value: 'abc',
+        },
+      ],
+    };
+
+    const errors = analyzeFilterValidationIssues(filter, fieldMetaMap);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toMatchObject({
+      code: 'OPERATOR_NOT_ALLOWED',
+      fieldId: numberFieldId,
+      operator: 'contains',
+      path: [0],
+    });
+  });
+
+  it('reports nested path for invalid sub-operator mode', () => {
+    const filter: IFilter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: numberFieldId,
+          operator: 'is',
+          value: 1,
+        },
+        {
+          conjunction: 'or',
+          filterSet: [
+            {
+              fieldId: dateFieldId,
+              operator: 'isWithIn',
+              value: { mode: 'notAMode', exactDate: null, timeZone: 'UTC' } as never,
+            },
+          ],
+        },
+      ],
+    };
+
+    const errors = analyzeFilterValidationIssues(filter, fieldMetaMap);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toMatchObject({
+      code: 'MODE_NOT_ALLOWED',
+      fieldId: dateFieldId,
+      mode: 'notAMode',
+      path: [1, 0],
+    });
+  });
+
+  it('reports shape mismatch when isWithIn value is a primitive', () => {
+    const filter: IFilter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: dateFieldId,
+          operator: 'isWithIn',
+          value: 'today' as never,
+        },
+      ],
+    };
+
+    const errors = analyzeFilterValidationIssues(filter, fieldMetaMap);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toMatchObject({
+      code: 'VALUE_SHAPE_INVALID',
+      fieldId: dateFieldId,
+      operator: 'isWithIn',
+      path: [0],
+    });
+    expect(errors[0].message).toContain('Valid modes:');
+    expect(errors[0].message).toContain('pastWeek');
+  });
+
+  it('reports shape mismatch when isBefore value is a plain date string', () => {
+    const filter: IFilter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: dateFieldId,
+          operator: 'isBefore',
+          value: '2026-04-27T00:00:00.000Z' as never,
+        },
+      ],
+    };
+
+    const errors = analyzeFilterValidationIssues(filter, fieldMetaMap);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toMatchObject({
+      code: 'VALUE_SHAPE_INVALID',
+      fieldId: dateFieldId,
+      operator: 'isBefore',
+      path: [0],
+    });
+    expect(errors[0].message).toContain('Valid modes:');
+    expect(errors[0].message).toContain('today');
+  });
+
+  it('reports invalid mode when value is an object with unknown mode', () => {
+    const filter: IFilter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: dateFieldId,
+          operator: 'isWithIn',
+          value: { mode: 'notAMode', exactDate: null, timeZone: 'UTC' } as never,
+        },
+      ],
+    };
+
+    const errors = analyzeFilterValidationIssues(filter, fieldMetaMap);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toMatchObject({
+      code: 'MODE_NOT_ALLOWED',
+      fieldId: dateFieldId,
+      mode: 'notAMode',
+      path: [0],
+    });
+  });
+
+  it('treats null value as in-progress, not an error', () => {
+    const filter: IFilter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: dateFieldId,
+          operator: 'isWithIn',
+          value: null,
+        },
+      ],
+    };
+
+    const errors = analyzeFilterValidationIssues(filter, fieldMetaMap);
+    expect(errors).toEqual([]);
+  });
+
+  it('allows date field reference comparisons without requiring mode', () => {
+    const filter: IFilter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: dateFieldId,
+          operator: 'is',
+          value: {
+            type: 'field',
+            fieldId: dateReferenceFieldId,
+          },
+        },
+      ],
+    };
+
+    const errors = analyzeFilterValidationIssues(filter, fieldMetaMap);
+    expect(errors).toEqual([]);
+  });
+
+  it('reports date field reference arrays as invalid date value shape', () => {
+    const filter: IFilter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: dateFieldId,
+          operator: 'is',
+          value: [
+            {
+              type: 'field',
+              fieldId: dateReferenceFieldId,
+            },
+          ] as never,
+        },
+      ],
+    };
+
+    const errors = analyzeFilterValidationIssues(filter, fieldMetaMap);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toMatchObject({
+      code: 'VALUE_SHAPE_INVALID',
+      fieldId: dateFieldId,
+      operator: 'is',
+      path: [0],
+    });
+  });
+
+  it('treats symbol operator as compatible when mapping exists', () => {
+    const filter: IFilter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: numberFieldId,
+          isSymbol: true,
+          operator: '=',
+          value: 3,
+        },
+      ],
+    };
+
+    const errors = analyzeFilterValidationIssues(filter, fieldMetaMap);
+    expect(errors).toEqual([]);
+  });
+});
diff --git a/packages/core/src/models/view/filter/filter.ts b/packages/core/src/models/view/filter/filter.ts
index 39679803e2..47d181292b 100644
--- a/packages/core/src/models/view/filter/filter.ts
+++ b/packages/core/src/models/view/filter/filter.ts
@@ -1,11 +1,15 @@
 import { z } from 'zod';
-import { FieldType } from '../../field/constant';
+import type { CellValueType, FieldType } from '../../field/constant';
 import type { IConjunction } from './conjunction';
 import { and, conjunctionSchema } from './conjunction';
-import type { IFilterItem } from './filter-item';
-import { filterItemSchema, isFieldReferenceValue } from './filter-item';
-import type { IDateTimeFieldOperator } from './operator';
-import { getValidFilterSubOperators, isWithIn } from './operator';
+import { filterItemSchema, isFieldReferenceValue, type IFilterItem } from './filter-item';
+import type { IDateTimeFieldOperator, IOperator } from './operator';
+import {
+  getFilterOperatorMapping,
+  getValidFilterOperators,
+  getValidFilterSubOperators,
+  isWithIn,
+} from './operator';
 
 export const baseFilterSetSchema = z.object({
   conjunction: conjunctionSchema,
@@ -129,54 +133,130 @@ export const extractFieldIdsFromFilter = (
 };
 
 export interface IFilterValidationError {
+  code: 'FIELD_NOT_FOUND' | 'OPERATOR_NOT_ALLOWED' | 'MODE_NOT_ALLOWED' | 'VALUE_SHAPE_INVALID';
+  path: number[];
   fieldId: string;
   operator: string;
   mode?: string;
   message: string;
 }
 
-/**
- * Validate filter operator and mode compatibility
- * Returns an array of validation errors if any, empty array if valid
- * @param filter - The filter to validate
- * @param fieldTypeMap - A map of fieldId to FieldType
- */
-export const validateFilterOperatorModeCompatibility = (
+export interface IFilterValidationFieldMeta {
+  type: FieldType;
+  cellValueType: CellValueType;
+  isMultipleCellValue?: boolean;
+}
+
+const normalizeFilterOperator = (
+  operator: string,
+  isSymbol: boolean | undefined,
+  fieldMeta: IFilterValidationFieldMeta
+): IOperator | undefined => {
+  if (!isSymbol) {
+    return operator as IOperator;
+  }
+
+  const operatorMapping = getFilterOperatorMapping(fieldMeta);
+  return (Object.entries(operatorMapping).find(([, symbol]) => symbol === operator)?.[0] ??
+    undefined) as IOperator | undefined;
+};
+
+const analyzeFilterItemValidationIssues = (
+  filterItem: IFilterItem,
+  path: number[],
+  fieldMetaMap: Record<string, IFilterValidationFieldMeta>
+): IFilterValidationError[] => {
+  const { fieldId, operator, value, isSymbol } = filterItem;
+  const fieldMeta = fieldMetaMap[fieldId];
+  if (!fieldMeta) {
+    return [
+      {
+        code: 'FIELD_NOT_FOUND',
+        path,
+        fieldId,
+        operator,
+        message: `The field '${fieldId}' was not found and this filter condition will be ignored.`,
+      },
+    ];
+  }
+
+  const normalizedOperator = normalizeFilterOperator(operator, isSymbol, fieldMeta);
+  const validFilterOperators = getValidFilterOperators(fieldMeta);
+  if (!normalizedOperator || !validFilterOperators.includes(normalizedOperator)) {
+    return [
+      {
+        code: 'OPERATOR_NOT_ALLOWED',
+        path,
+        fieldId,
+        operator,
+        message: `The '${operator}' operation provided for '${fieldId}' is invalid. Allowed operators: [${validFilterOperators.join(',')}].`,
+      },
+    ];
+  }
+
+  const validFilterSubOperators = getValidFilterSubOperators(
+    fieldMeta.type,
+    normalizedOperator as IDateTimeFieldOperator
+  );
+  // Operator without sub-operators (isEmpty / isNotEmpty / ...) has no mode to check.
+  if (!validFilterSubOperators) return [];
+
+  // null/undefined is treated as "in-progress" — backend drops these silently.
+  if (value == null) return [];
+
+  // Date operators support comparing against another field directly.
+  if (isFieldReferenceValue(value)) return [];
+
+  const operatorName = normalizedOperator === isWithIn.value ? 'isWithIn' : normalizedOperator;
+  // Shape mismatch: operator expects { mode, ... } but value is a primitive/array.
+  if (typeof value !== 'object' || Array.isArray(value) || !('mode' in (value as object))) {
+    return [
+      {
+        code: 'VALUE_SHAPE_INVALID',
+        path,
+        fieldId,
+        operator: normalizedOperator,
+        message: `The '${operatorName}' operation requires an object value with a 'mode' field. Valid modes: [${validFilterSubOperators.join(',')}]. Example: { mode: "${validFilterSubOperators[0]}", timeZone: "UTC" }`,
+      },
+    ];
+  }
+
+  const mode = String((value as { mode: unknown }).mode);
+  if (!validFilterSubOperators.includes(mode as never)) {
+    return [
+      {
+        code: 'MODE_NOT_ALLOWED',
+        path,
+        fieldId,
+        operator: normalizedOperator,
+        mode,
+        message: `The '${operatorName}' operation with mode '${mode}' is invalid. Allowed modes: [${validFilterSubOperators.join(',')}].`,
+      },
+    ];
+  }
+
+  return [];
+};
+
+export const analyzeFilterValidationIssues = (
   filter: IFilter | null | undefined,
-  fieldTypeMap: Record<string, FieldType>
+  fieldMetaMap: Record<string, IFilterValidationFieldMeta>
 ): IFilterValidationError[] => {
   if (!filter) return [];
 
   const errors: IFilterValidationError[] = [];
 
-  const traverse = (filterItem: IFilter | IFilterItem) => {
+  const traverse = (filterItem: IFilter | IFilterItem, path: number[]) => {
     if (filterItem && 'fieldId' in filterItem) {
-      const { fieldId, operator, value } = filterItem;
-      const fieldType = fieldTypeMap[fieldId];
-
-      // Only validate date fields with date filter value
-      if (fieldType === FieldType.Date && value && typeof value === 'object' && 'mode' in value) {
-        const dateValue = value as { mode: string };
-        const validSubOperators = getValidFilterSubOperators(
-          fieldType,
-          operator as IDateTimeFieldOperator
-        );
-
-        if (validSubOperators && !validSubOperators.includes(dateValue.mode as never)) {
-          const operatorName = operator === isWithIn.value ? 'isWithIn' : operator;
-          errors.push({
-            fieldId,
-            operator: operator as string,
-            mode: dateValue.mode,
-            message: `The '${operatorName}' operation with mode '${dateValue.mode}' is invalid. Allowed modes: [${validSubOperators.join(',')}]`,
-          });
-        }
-      }
-    } else if (filterItem && 'filterSet' in filterItem) {
-      filterItem.filterSet.forEach((item) => traverse(item));
+      errors.push(...analyzeFilterItemValidationIssues(filterItem, path, fieldMetaMap));
+      return;
+    }
+
+    if (filterItem && 'filterSet' in filterItem) {
+      filterItem.filterSet.forEach((item, index) => traverse(item, [...path, index]));
     }
   };
 
-  traverse(filter);
+  traverse(filter, []);
   return errors;
 };
diff --git a/packages/core/src/models/view/filter/operator.ts b/packages/core/src/models/view/filter/operator.ts
index 926309c7b8..8c966d3961 100644
--- a/packages/core/src/models/view/filter/operator.ts
+++ b/packages/core/src/models/view/filter/operator.ts
@@ -2,7 +2,6 @@
 import { pick, pullAll, uniq } from 'lodash';
 import { z } from 'zod';
 import { CellValueType, FieldType } from '../../field/constant';
-import type { FieldCore } from '../../field/field';
 
 export const is = z.literal('is');
 export const isNot = z.literal('isNot');
@@ -371,7 +370,11 @@ export const dateTimeFieldValidSubOperatorsByIsWithin = [
   nextNumberOfDays.value,
 ];
 
-export function getFilterOperatorMapping(field: FieldCore) {
+export function getFilterOperatorMapping(field: {
+  cellValueType: CellValueType;
+  type: FieldType;
+  isMultipleCellValue?: boolean;
+}) {
   const validFilterOperators = getValidFilterOperators(field);
 
   return pick(mappingOperatorSymbol, validFilterOperators);
diff --git a/packages/db-main-prisma/prisma/postgres/migrations/20260424000000_add_base_v2_enabled/migration.sql b/packages/db-main-prisma/prisma/postgres/migrations/20260424000000_add_base_v2_enabled/migration.sql
new file mode 100644
index 0000000000..f5c1aa62f5
--- /dev/null
+++ b/packages/db-main-prisma/prisma/postgres/migrations/20260424000000_add_base_v2_enabled/migration.sql
@@ -0,0 +1 @@
+ALTER TABLE "base" ADD COLUMN "v2_enabled" BOOLEAN NOT NULL DEFAULT false;
diff --git a/packages/db-main-prisma/prisma/postgres/schema.prisma b/packages/db-main-prisma/prisma/postgres/schema.prisma
index 7434c5def6..98a1038267 100644
--- a/packages/db-main-prisma/prisma/postgres/schema.prisma
+++ b/packages/db-main-prisma/prisma/postgres/schema.prisma
@@ -44,6 +44,7 @@ model Base {
   order            Float
   icon             String?
   schemaPass       String?     @map("schema_pass")
+  v2Enabled        Boolean     @default(false) @map("v2_enabled")
   deletedTime      DateTime?   @map("deleted_time")
   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 090167512b..d51df76b14 100644
--- a/packages/db-main-prisma/prisma/template.prisma
+++ b/packages/db-main-prisma/prisma/template.prisma
@@ -44,6 +44,7 @@ model Base {
   order            Float
   icon             String?
   schemaPass       String?     @map("schema_pass")
+  v2Enabled        Boolean     @default(false) @map("v2_enabled")
   deletedTime      DateTime?   @map("deleted_time")
   createdTime      DateTime    @default(now()) @map("created_time")
   createdBy        String      @map("created_by")
diff --git a/packages/icons/src/components/CircleDollarSign.tsx b/packages/icons/src/components/CircleDollarSign.tsx
new file mode 100644
index 0000000000..259a358055
--- /dev/null
+++ b/packages/icons/src/components/CircleDollarSign.tsx
@@ -0,0 +1,18 @@
+import * as React from 'react';
+import type { SVGProps } from 'react';
+const CircleDollarSign = (props: SVGProps<SVGSVGElement>) => (
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    width="1em"
+    height="1em"
+    fill="none"
+    viewBox="0 0 24 24"
+    {...props}
+  >
+    <path
+      d="M21 12C21 7.02944 16.9706 3 12 3C7.02944 3 3 7.02944 3 12C3 16.9706 7.02944 21 12 21C16.9706 21 21 16.9706 21 12ZM15 14C15 13.7348 14.8946 13.4805 14.707 13.293C14.5195 13.1054 14.2652 13 14 13H13V15H14C14.2652 15 14.5195 14.8946 14.707 14.707C14.8946 14.5195 15 14.2652 15 14ZM17 14C17 14.7957 16.6837 15.5585 16.1211 16.1211C15.5585 16.6837 14.7957 17 14 17H13V18C13 18.5523 12.5523 19 12 19C11.4477 19 11 18.5523 11 18V17H8C7.44772 17 7 16.5523 7 16C7 15.4477 7.44772 15 8 15H11V13H10C9.20435 13 8.44151 12.6837 7.87891 12.1211C7.3163 11.5585 7 10.7957 7 10C7 9.20435 7.3163 8.44151 7.87891 7.87891C8.44151 7.3163 9.20435 7 10 7H11V6C11 5.44772 11.4477 5 12 5C12.5523 5 13 5.44772 13 6V7H16C16.5523 7 17 7.44772 17 8C17 8.55228 16.5523 9 16 9H13V11H14C14.7957 11 15.5585 11.3163 16.1211 11.8789C16.6837 12.4415 17 13.2043 17 14ZM23 12C23 18.0751 18.0751 23 12 23C5.92487 23 1 18.0751 1 12C1 5.92487 5.92487 1 12 1C18.0751 1 23 5.92487 23 12ZM9 10C9 10.2652 9.10543 10.5195 9.29297 10.707C9.48051 10.8946 9.73478 11 10 11H11V9H10C9.73478 9 9.48051 9.10543 9.29297 9.29297C9.10543 9.48051 9 9.73478 9 10Z"
+      fill="currentColor"
+    />
+  </svg>
+);
+export default CircleDollarSign;
diff --git a/packages/icons/src/components/IDCard.tsx b/packages/icons/src/components/IDCard.tsx
new file mode 100644
index 0000000000..5d3b3afff0
--- /dev/null
+++ b/packages/icons/src/components/IDCard.tsx
@@ -0,0 +1,34 @@
+import * as React from 'react';
+import type { SVGProps } from 'react';
+const IDCard = (props: SVGProps<SVGSVGElement>) => (
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    width="1em"
+    height="1em"
+    fill="none"
+    viewBox="0 0 24 24"
+    {...props}
+  >
+    <path
+      fillRule="evenodd"
+      clipRule="evenodd"
+      d="M9 8C10.6569 8 12 9.34315 12 11C12 11.6751 11.7738 12.2956 11.3975 12.7969C12.03 13.2711 12.5106 13.9217 12.7734 14.6689C12.9562 15.1897 12.6828 15.7611 12.1621 15.9443C11.6413 16.1274 11.0701 15.8527 10.8867 15.332C10.7493 14.9417 10.4938 14.6035 10.1562 14.3643C9.83508 14.1368 9.45403 14.0102 9.06152 13.998C9.04106 13.9985 9.02057 14 9 14C8.97911 14 8.95829 13.9985 8.9375 13.998C8.54536 14.0103 8.16464 14.137 7.84375 14.3643C7.50616 14.6035 7.25067 14.9417 7.11328 15.332C6.92985 15.8527 6.3587 16.1275 5.83789 15.9443C5.31714 15.7611 5.04376 15.1897 5.22656 14.6689C5.48941 13.9218 5.96917 13.2711 6.60156 12.7969C6.22547 12.2957 6 11.6749 6 11C6 9.34315 7.34315 8 9 8ZM9 10C8.44772 10 8 10.4477 8 11C8 11.5369 8.42316 11.973 8.9541 11.9971C8.9694 11.9969 8.98469 11.9961 9 11.9961C9.01497 11.9961 9.02997 11.9969 9.04492 11.9971C9.57632 11.9735 10 11.5372 10 11C10 10.4477 9.55228 10 9 10Z"
+      fill="currentColor"
+    />
+    <path
+      d="M18 13C18.5523 13 19 13.4477 19 14C19 14.5523 18.5523 15 18 15H16C15.4477 15 15 14.5523 15 14C15 13.4477 15.4477 13 16 13H18Z"
+      fill="currentColor"
+    />
+    <path
+      d="M18 9C18.5523 9 19 9.44772 19 10C19 10.5523 18.5523 11 18 11H16C15.4477 11 15 10.5523 15 10C15 9.44772 15.4477 9 16 9H18Z"
+      fill="currentColor"
+    />
+    <path
+      fillRule="evenodd"
+      clipRule="evenodd"
+      d="M20 4C21.6569 4 23 5.34315 23 7V17C23 18.6569 21.6569 20 20 20H4C2.34315 20 1 18.6569 1 17V7C1 5.34315 2.34315 4 4 4H20ZM4 6C3.44772 6 3 6.44772 3 7V17C3 17.5523 3.44772 18 4 18H20C20.5523 18 21 17.5523 21 17V7C21 6.44772 20.5523 6 20 6H4Z"
+      fill="currentColor"
+    />
+  </svg>
+);
+export default IDCard;
diff --git a/packages/icons/src/components/Info.tsx b/packages/icons/src/components/Info.tsx
index 58e625e969..c51f121241 100644
--- a/packages/icons/src/components/Info.tsx
+++ b/packages/icons/src/components/Info.tsx
@@ -10,7 +10,17 @@ const Info = (props: SVGProps<SVGSVGElement>) => (
     {...props}
   >
     <path
-      d="M21 12C21 7.02944 16.9706 3 12 3C7.02944 3 3 7.02944 3 12C3 16.9706 7.02944 21 12 21C16.9706 21 21 16.9706 21 12ZM11 16V12C11 11.4477 11.4477 11 12 11C12.5523 11 13 11.4477 13 12V16C13 16.5523 12.5523 17 12 17C11.4477 17 11 16.5523 11 16ZM12.0098 7C12.5621 7 13.0098 7.44772 13.0098 8C13.0098 8.55228 12.5621 9 12.0098 9H12C11.4477 9 11 8.55228 11 8C11 7.44772 11.4477 7 12 7H12.0098ZM23 12C23 18.0751 18.0751 23 12 23C5.92487 23 1 18.0751 1 12C1 5.92487 5.92487 1 12 1C18.0751 1 23 5.92487 23 12Z"
+      d="M12 11.5C12.5523 11.5 13 11.9477 13 12.5V17C13 17.5523 12.5523 18 12 18C11.4477 18 11 17.5523 11 17V12.5C11 11.9477 11.4477 11.5 12 11.5Z"
+      fill="currentColor"
+    />
+    <path
+      d="M12 6.5C12.8284 6.5 13.5 7.17157 13.5 8C13.5 8.82843 12.8284 9.5 12 9.5C11.1716 9.5 10.5 8.82843 10.5 8C10.5 7.17157 11.1716 6.5 12 6.5Z"
+      fill="currentColor"
+    />
+    <path
+      fillRule="evenodd"
+      clipRule="evenodd"
+      d="M12 1C18.0751 1 23 5.92487 23 12C23 18.0751 18.0751 23 12 23C5.92487 23 1 18.0751 1 12C1 5.92487 5.92487 1 12 1ZM12 3C7.02944 3 3 7.02944 3 12C3 16.9706 7.02944 21 12 21C16.9706 21 21 16.9706 21 12C21 7.02944 16.9706 3 12 3Z"
       fill="currentColor"
     />
   </svg>
diff --git a/packages/icons/src/components/Prodia.tsx b/packages/icons/src/components/Prodia.tsx
new file mode 100644
index 0000000000..879f92218a
--- /dev/null
+++ b/packages/icons/src/components/Prodia.tsx
@@ -0,0 +1,18 @@
+import * as React from 'react';
+import type { SVGProps } from 'react';
+const Prodia = (props: SVGProps<SVGSVGElement>) => (
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    width="1em"
+    height="1em"
+    fill="none"
+    viewBox="0 0 48 48"
+    {...props}
+  >
+    <path
+      fill="currentColor"
+      d="M12 0h16c11 0 20 9 20 20v4H24V12H12zM0 12h12v12H0zm12 12h12v12H12zm24 0h12v4c0 11-9 20-20 20h-4V36h12zM0 36h12v12H0z"
+    />
+  </svg>
+);
+export default Prodia;
diff --git a/packages/icons/src/components/Recraft.tsx b/packages/icons/src/components/Recraft.tsx
new file mode 100644
index 0000000000..7e8b95d5d3
--- /dev/null
+++ b/packages/icons/src/components/Recraft.tsx
@@ -0,0 +1,27 @@
+import * as React from 'react';
+import type { SVGProps } from 'react';
+const Recraft = (props: SVGProps<SVGSVGElement>) => (
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    width="1em"
+    height="1em"
+    fill="none"
+    viewBox="0 0 80 80"
+    {...props}
+  >
+    <rect width={80} height={80} fill="#000" rx={16} />
+    <g clipPath="url(#prefix__recraft)" clipRule="evenodd">
+      <path
+        fill="#fff"
+        d="M56.56 30.743c0-10.175-9.239-18.424-20.636-18.424-3.953 0-7.155 8.25-7.155 18.424 0 2.545.2 4.971.564 7.178h-7.006L15 63.522h20.926V49.17c11.394 0 20.63-8.252 20.63-18.424zm-20.636-15.05c2.068 0 3.743 6.74 3.743 15.05s-1.675 15.05-3.743 15.05-3.743-6.74-3.743-15.05 1.675-15.05 3.743-15.05"
+      />
+      <path fill="#fff" d="M56.963 49.17H35.945l8.06 14.355H65.02z" />
+    </g>
+    <defs>
+      <clipPath id="prefix__recraft">
+        <path fill="#fff" d="M15 12.32h50.02v51.205H15z" />
+      </clipPath>
+    </defs>
+  </svg>
+);
+export default Recraft;
diff --git a/packages/icons/src/index.ts b/packages/icons/src/index.ts
index e83f5cb73d..d07ec3f4ff 100644
--- a/packages/icons/src/index.ts
+++ b/packages/icons/src/index.ts
@@ -112,8 +112,10 @@ export { default as GoogleLogo } from './components/GoogleLogo';
 export { default as Hash } from './components/Hash';
 export { default as Heart } from './components/Heart';
 export { default as HelpCircle } from './components/HelpCircle';
+export { default as CircleDollarSign } from './components/CircleDollarSign';
 export { default as History } from './components/History';
 export { default as Home } from './components/Home';
+export { default as IDCard } from './components/IDCard';
 export { default as Info } from './components/Info';
 export { default as Image } from './components/Image';
 export { default as ImageGeneration } from './components/ImageGeneration';
@@ -241,6 +243,8 @@ export { default as Meituan } from './components/Meituan';
 export { default as Kwaipilot } from './components/Kwaipilot';
 export { default as ArceeAi } from './components/ArceeAi';
 export { default as PrimeIntellect } from './components/PrimeIntellect';
+export { default as Prodia } from './components/Prodia';
+export { default as Recraft } from './components/Recraft';
 export { default as Morph } from './components/Morph';
 export { default as Inception } from './components/Inception';
 export { default as Stealth } from './components/Stealth';
diff --git a/packages/openapi/src/access-token/create.ts b/packages/openapi/src/access-token/create.ts
index 72e172811d..0f05ab8f67 100644
--- a/packages/openapi/src/access-token/create.ts
+++ b/packages/openapi/src/access-token/create.ts
@@ -1,3 +1,4 @@
+import { allActions } from '@teable/core';
 import { axios } from '../axios';
 import { registerRoute } from '../utils';
 import { z } from '../zod';
@@ -12,7 +13,7 @@ const isValidDateString = (dateString: string) => {
 export const createAccessTokenRoSchema = z.object({
   name: z.string().min(1),
   description: z.string().optional(),
-  scopes: z.array(z.string()).min(1),
+  scopes: z.array(z.enum(allActions)).min(1),
   spaceIds: z.array(z.string()).min(1).nullable().optional(),
   baseIds: z.array(z.string()).min(1).nullable().optional(),
   hasFullAccess: z.boolean().optional(),
@@ -24,7 +25,11 @@ export const createAccessTokenRoSchema = z.object({
     .meta({ type: 'string', example: '2024-03-25' }),
 });
 
-export type CreateAccessTokenRo = z.infer<typeof createAccessTokenRoSchema>;
+type CreateAccessTokenRoSchema = z.infer<typeof createAccessTokenRoSchema>;
+
+export type CreateAccessTokenRo = Omit<CreateAccessTokenRoSchema, 'scopes'> & {
+  scopes: string[];
+};
 
 export const createAccessTokenVoSchema = z.object({
   id: z.string(),
diff --git a/packages/openapi/src/access-token/update.ts b/packages/openapi/src/access-token/update.ts
index 4083695734..afb33badde 100644
--- a/packages/openapi/src/access-token/update.ts
+++ b/packages/openapi/src/access-token/update.ts
@@ -1,3 +1,4 @@
+import { allActions } from '@teable/core';
 import { axios } from '../axios';
 import { registerRoute, urlBuilder } from '../utils';
 import { z } from '../zod';
@@ -7,13 +8,17 @@ export const UPDATE_ACCESS_TOKEN = '/access-token/{id}';
 export const updateAccessTokenRoSchema = z.object({
   name: z.string(),
   description: z.string().optional(),
-  scopes: z.array(z.string()),
+  scopes: z.array(z.enum(allActions)).min(1),
   spaceIds: z.array(z.string()).nullable().optional(),
   baseIds: z.array(z.string()).nullable().optional(),
   hasFullAccess: z.boolean().optional(),
 });
 
-export type UpdateAccessTokenRo = z.infer<typeof updateAccessTokenRoSchema>;
+type UpdateAccessTokenRoSchema = z.infer<typeof updateAccessTokenRoSchema>;
+
+export type UpdateAccessTokenRo = Omit<UpdateAccessTokenRoSchema, 'scopes'> & {
+  scopes: string[];
+};
 
 export const updateAccessTokenVoSchema = z.object({
   id: z.string(),
diff --git a/packages/openapi/src/admin/setting/batch-test-llm.ts b/packages/openapi/src/admin/setting/batch-test-llm.ts
index 705a766bab..57d5d83943 100644
--- a/packages/openapi/src/admin/setting/batch-test-llm.ts
+++ b/packages/openapi/src/admin/setting/batch-test-llm.ts
@@ -2,7 +2,8 @@ import type { RouteConfig } from '@asteasolutions/zod-to-openapi';
 import { z } from 'zod';
 import { axios } from '../../axios';
 import { registerRoute } from '../../utils';
-import { llmProviderSchema, chatModelAbilitySchema, LLMProviderType } from './update';
+import { chatModelAbilitySchema } from './model-ability';
+import { LLMProviderType, llmProviderSchema } from './update';
 
 /**
  * Request schema for batch testing all LLM models
diff --git a/packages/openapi/src/admin/setting/gateway-model.ts b/packages/openapi/src/admin/setting/gateway-model.ts
new file mode 100644
index 0000000000..757ee39105
--- /dev/null
+++ b/packages/openapi/src/admin/setting/gateway-model.ts
@@ -0,0 +1,166 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { z } from 'zod';
+import { modelAbilitySchema } from './model-ability';
+import {
+  legacyRatesSchema,
+  normalizeGatewayPricing,
+  pricingSchema,
+  rawPricingSchema,
+} from './pricing';
+
+// Gateway model type from API (language, embedding, image)
+export const GatewayModelTypeValues = ['language', 'embedding', 'image'] as const;
+export type GatewayModelType = (typeof GatewayModelTypeValues)[number];
+export const gatewayModelTypeSchema = z.enum(GatewayModelTypeValues);
+
+// Known gateway model capability tags from API.
+// Tags are external API metadata, so validation accepts any non-empty string for forward compatibility.
+export const GatewayModelTagValues = [
+  'reasoning',
+  'tool-use',
+  'vision',
+  'file-input',
+  'image-generation',
+  'implicit-caching',
+  'explicit-caching',
+  'web-search',
+] as const;
+export type KnownGatewayModelTag = (typeof GatewayModelTagValues)[number];
+export type GatewayModelTag = string;
+export const gatewayModelTagSchema = z.string().min(1);
+
+// Gateway model provider (owned_by) from API
+export const GatewayModelProviderValues = [
+  'alibaba',
+  'amazon',
+  'anthropic',
+  'arcee-ai',
+  'bfl',
+  'bytedance',
+  'cohere',
+  'deepseek',
+  'google',
+  'inception',
+  'kwaipilot',
+  'meituan',
+  'meta',
+  'minimax',
+  'mistral',
+  'moonshotai',
+  'morph',
+  'nvidia',
+  'openai',
+  'perplexity',
+  'prime-intellect',
+  'prodia',
+  'recraft',
+  'stealth',
+  'vercel',
+  'voyage',
+  'xai',
+  'xiaomi',
+  'zai',
+] as const;
+export type GatewayModelProvider = (typeof GatewayModelProviderValues)[number];
+export const gatewayModelProviderSchema = z.enum(GatewayModelProviderValues);
+
+// Gateway model default assignment targets
+export enum GatewayModelDefaultFor {
+  CHAT_LG = 'chatLg',
+  CHAT_MD = 'chatMd',
+  CHAT_SM = 'chatSm',
+  AI_FIELD_TEXT = 'aiFieldText',
+  AI_FIELD_IMAGE = 'aiFieldImage',
+}
+
+// Individual gateway model configuration (admin-maintained)
+export const gatewayModelSchema = z.object({
+  // modelId used directly with AI Gateway (e.g., "anthropic/claude-sonnet-4")
+  id: z.string(),
+  // Display label (e.g., "Claude Sonnet 4")
+  label: z.string(),
+  // Whether this model is visible to end users
+  enabled: z.boolean().default(true),
+  // Model capabilities (for UI tags and validation)
+  capabilities: modelAbilitySchema.optional(),
+  // Pricing in USD (new unified format)
+  pricing: pricingSchema.optional(),
+  // @deprecated Legacy rates in credits per 1M tokens - use pricing instead
+  rates: legacyRatesSchema.optional(),
+  // Mark as image generation model
+  isImageModel: z.boolean().optional(),
+  // Default assignment (which use cases this model is default for)
+  defaultFor: z.array(z.nativeEnum(GatewayModelDefaultFor)).optional(),
+  // Last test timestamp
+  testedAt: z.number().optional(),
+  // === Metadata from AI Gateway API ===
+  // Provider that owns this model (e.g., "anthropic", "google", "openai")
+  ownedBy: gatewayModelProviderSchema.optional(),
+  // Model type from API (e.g., "language", "image")
+  modelType: gatewayModelTypeSchema.optional(),
+  // Capability tags from API (e.g., ["image-generation", "vision", "tool-use"])
+  tags: z.array(gatewayModelTagSchema).optional(),
+  // Context window size (input tokens)
+  contextWindow: z.number().optional(),
+  // Maximum output tokens
+  maxTokens: z.number().optional(),
+  // Model description
+  description: z.string().optional(),
+  // Admin-curated i18n description (e.g., "Most capable for ambitious work")
+  i18nDescription: z
+    .object({
+      en: z.string().optional(),
+      zh: z.string().optional(),
+    })
+    .optional(),
+});
+
+export type IGatewayModel = z.infer<typeof gatewayModelSchema>;
+
+// Raw API response structure from Vercel AI Gateway (snake_case as returned by API)
+export const gatewayApiModelRawSchema = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+  description: z.string().optional(),
+  type: gatewayModelTypeSchema.optional(),
+  tags: z.array(gatewayModelTagSchema).optional(),
+  context_window: z.number().optional(),
+  max_tokens: z.number().optional(),
+  created: z.number().optional(),
+  owned_by: gatewayModelProviderSchema.optional(),
+  pricing: rawPricingSchema.optional(),
+});
+
+export type IGatewayApiModelRaw = z.infer<typeof gatewayApiModelRawSchema>;
+
+// Gateway API model structure (camelCase, converted from API snake_case)
+export const gatewayApiModelSchema = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+  description: z.string().optional(),
+  type: gatewayModelTypeSchema.optional(),
+  tags: z.array(gatewayModelTagSchema).optional(),
+  contextWindow: z.number().optional(),
+  maxTokens: z.number().optional(),
+  created: z.number().optional(),
+  ownedBy: gatewayModelProviderSchema.optional(),
+  pricing: pricingSchema.optional(),
+});
+
+export type IGatewayApiModel = z.infer<typeof gatewayApiModelSchema>;
+
+// Helper function to convert raw API response to camelCase
+export function convertGatewayApiModel(raw: IGatewayApiModelRaw): IGatewayApiModel {
+  return {
+    id: raw.id,
+    name: raw.name,
+    description: raw.description,
+    type: raw.type,
+    tags: raw.tags,
+    contextWindow: raw.context_window,
+    maxTokens: raw.max_tokens,
+    created: raw.created,
+    ownedBy: raw.owned_by,
+    pricing: normalizeGatewayPricing(raw.pricing),
+  };
+}
diff --git a/packages/openapi/src/admin/setting/get-public.ts b/packages/openapi/src/admin/setting/get-public.ts
index d29232abb3..00e4fd8659 100644
--- a/packages/openapi/src/admin/setting/get-public.ts
+++ b/packages/openapi/src/admin/setting/get-public.ts
@@ -2,8 +2,9 @@ import type { RouteConfig } from '@asteasolutions/zod-to-openapi';
 import { z } from 'zod';
 import { axios } from '../../axios';
 import { registerRoute } from '../../utils';
+import { gatewayModelSchema } from './gateway-model';
 import { settingVoSchema } from './get';
-import { chatModelSchema, gatewayModelSchema, llmProviderSchema } from './update';
+import { chatModelSchema, llmProviderSchema } from './update';
 
 export const simpleLLMProviderSchema = llmProviderSchema.pick({
   type: true,
diff --git a/packages/openapi/src/admin/setting/index.ts b/packages/openapi/src/admin/setting/index.ts
index 437970c4ea..44ec6f6833 100644
--- a/packages/openapi/src/admin/setting/index.ts
+++ b/packages/openapi/src/admin/setting/index.ts
@@ -1,4 +1,7 @@
 export * from './key.enum';
+export * from './gateway-model';
+export * from './model-ability';
+export * from './pricing';
 export * from './get';
 export * from './get-public';
 export * from './update';
diff --git a/packages/openapi/src/admin/setting/model-ability.spec.ts b/packages/openapi/src/admin/setting/model-ability.spec.ts
new file mode 100644
index 0000000000..de759d389e
--- /dev/null
+++ b/packages/openapi/src/admin/setting/model-ability.spec.ts
@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+import { getImageModelTagsFromAbility } from './model-ability';
+
+const IMAGE_GENERATION_TAG = 'image-generation';
+const VISION_TAG = 'vision';
+
+describe('getImageModelTagsFromAbility', () => {
+  it('derives persisted image capability tags from image test results', () => {
+    expect(
+      getImageModelTagsFromAbility(
+        {
+          generation: true,
+          imageToImage: true,
+        },
+        ['tool-use']
+      )
+    ).toEqual(['tool-use', IMAGE_GENERATION_TAG, VISION_TAG]);
+  });
+
+  it('removes stale image-to-image tags when the latest result does not support it', () => {
+    expect(
+      getImageModelTagsFromAbility(
+        {
+          generation: true,
+          imageToImage: false,
+        },
+        [IMAGE_GENERATION_TAG, VISION_TAG]
+      )
+    ).toEqual([IMAGE_GENERATION_TAG]);
+  });
+});
diff --git a/packages/openapi/src/admin/setting/model-ability.ts b/packages/openapi/src/admin/setting/model-ability.ts
new file mode 100644
index 0000000000..687079639f
--- /dev/null
+++ b/packages/openapi/src/admin/setting/model-ability.ts
@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import type { GatewayModelTag } from './gateway-model';
+
+// Detailed ability support with URL and base64 variants
+export const abilityDetailSchema = z.object({
+  url: z.boolean().optional(),
+  base64: z.boolean().optional(),
+});
+
+export type IAbilityDetail = z.infer<typeof abilityDetailSchema>;
+
+// Model ability schema for test results
+export const modelAbilitySchema = z.object({
+  image: z.union([z.boolean(), abilityDetailSchema]).optional(), // vision/image input
+  pdf: z.union([z.boolean(), abilityDetailSchema]).optional(), // PDF/file input
+  webSearch: z.boolean().optional(),
+  toolCall: z.boolean().optional(), // tool/function calling
+  reasoning: z.boolean().optional(), // extended thinking/reasoning
+  imageGeneration: z.boolean().optional(), // can generate images
+});
+
+export type IModelAbility = z.infer<typeof modelAbilitySchema>;
+
+// Image model ability schema
+export const imageModelAbilitySchema = z.object({
+  generation: z.boolean().optional(), // can generate images from text
+  imageToImage: z.boolean().optional(), // can generate images from image input
+});
+
+export type IImageModelAbility = z.infer<typeof imageModelAbilitySchema>;
+
+const IMAGE_GENERATION_TAG: GatewayModelTag = 'image-generation';
+const VISION_TAG: GatewayModelTag = 'vision';
+const IMAGE_ABILITY_TAGS = new Set<GatewayModelTag>([IMAGE_GENERATION_TAG, VISION_TAG]);
+
+export const getImageModelTagsFromAbility = (
+  imageAbility: IImageModelAbility | undefined,
+  currentTags: readonly GatewayModelTag[] | undefined
+): GatewayModelTag[] | undefined => {
+  if (!imageAbility) return currentTags ? [...currentTags] : undefined;
+
+  const nextTags = (currentTags ?? []).filter((tag) => !IMAGE_ABILITY_TAGS.has(tag));
+  if (imageAbility.generation) {
+    nextTags.push(IMAGE_GENERATION_TAG);
+  }
+  if (imageAbility.imageToImage) {
+    nextTags.push(VISION_TAG);
+  }
+
+  return nextTags.length ? nextTags : undefined;
+};
+
+// chatModelAbilitySchema is same as modelAbilitySchema, for backward compatibility
+export const chatModelAbilitySchema = modelAbilitySchema;
+
+export const chatModelAbilityType = chatModelAbilitySchema.keyof();
+
+export type IChatModelAbilityType = z.infer<typeof chatModelAbilityType>;
+
+export type IChatModelAbility = z.infer<typeof chatModelAbilitySchema>;
diff --git a/packages/openapi/src/admin/setting/pricing.spec.ts b/packages/openapi/src/admin/setting/pricing.spec.ts
index 73accda60a..7168e885e7 100644
--- a/packages/openapi/src/admin/setting/pricing.spec.ts
+++ b/packages/openapi/src/admin/setting/pricing.spec.ts
@@ -1,13 +1,13 @@
 /* eslint-disable sonarjs/no-duplicate-string */
 import { describe, it, expect } from 'vitest';
-import type { IModelPricing, IPricingTier } from './update';
+import type { IModelPricing, IPricingTier } from './pricing';
 import {
   calculateTieredCost,
   pricingToCredits,
   pricingToCreditsFromUsage,
   normalizeGatewayPricing,
   USD_PER_CREDIT,
-} from './update';
+} from './pricing';
 
 describe('pricing', () => {
   describe('USD_PER_CREDIT', () => {
diff --git a/packages/openapi/src/admin/setting/pricing.ts b/packages/openapi/src/admin/setting/pricing.ts
new file mode 100644
index 0000000000..14a2ad8d7a
--- /dev/null
+++ b/packages/openapi/src/admin/setting/pricing.ts
@@ -0,0 +1,255 @@
+import { z } from 'zod';
+
+// Tiered pricing tier - for volume-based pricing where cost changes at token thresholds
+export const pricingTierSchema = z.object({
+  cost: z.string(), // USD per token at this tier
+  min: z.number(), // Tier start (inclusive)
+  max: z.number().optional(), // Tier end (absent = open-ended last tier)
+});
+
+export type IPricingTier = z.infer<typeof pricingTierSchema>;
+
+// Unified pricing schema - USD per token (string format, same as Vercel AI Gateway API)
+// 100 credits = $1 USD. Credits = totalUSD / USD_PER_CREDIT
+export const pricingSchema = z.object({
+  // Flat rates (USD per token/unit as string)
+  input: z.string().optional(),
+  output: z.string().optional(),
+  inputCacheRead: z.string().optional(),
+  inputCacheWrite: z.string().optional(),
+  reasoning: z.string().optional(),
+  image: z.string().optional(),
+  webSearch: z.string().optional(),
+
+  // Tiered pricing (overrides flat rate when present)
+  inputTiers: z.array(pricingTierSchema).optional(),
+  outputTiers: z.array(pricingTierSchema).optional(),
+  inputCacheReadTiers: z.array(pricingTierSchema).optional(),
+  inputCacheWriteTiers: z.array(pricingTierSchema).optional(),
+});
+
+export type IModelPricing = z.infer<typeof pricingSchema>;
+
+// Legacy rates schema (credits per 1M tokens) - for backward compatibility
+// Will be converted to new pricing format when reading
+export const legacyRatesSchema = z.object({
+  inputRate: z.number().min(0).optional(),
+  outputRate: z.number().min(0).optional(),
+  cacheReadRate: z.number().min(0).optional(),
+  cacheWriteRate: z.number().min(0).optional(),
+  reasoningRate: z.number().min(0).optional(),
+  imageRate: z.number().min(0).optional(),
+  webSearchRate: z.number().min(0).optional(),
+});
+
+export type ILegacyRates = z.infer<typeof legacyRatesSchema>;
+
+// Conversion constants
+// 1 credit = $0.01 USD (100 credits = $1)
+export const USD_PER_CREDIT = 0.01;
+// Legacy rates were in credits per 1M tokens
+export const TOKENS_PER_RATE_UNIT = 1_000_000;
+
+/**
+ * Calculate cost for tokens using tiered (progressive) pricing.
+ * Each tier covers a range [min, max). The last tier has no max (open-ended).
+ */
+export function calculateTieredCost(tokenCount: number, tiers: IPricingTier[]): number {
+  let totalCost = 0;
+  for (const tier of tiers) {
+    if (tokenCount <= tier.min) break;
+    const tierMax = tier.max ?? Infinity;
+    const tokensInTier = Math.min(tokenCount, tierMax) - tier.min;
+    totalCost += tokensInTier * parseFloat(tier.cost);
+  }
+  return totalCost;
+}
+
+/**
+ * Calculate USD cost for a single pricing category.
+ * Uses tiered pricing if available, otherwise falls back to flat rate.
+ */
+function categoryUsd(
+  tokenCount: number | undefined,
+  flatRate: string | undefined,
+  tiers: IPricingTier[] | undefined
+): number {
+  if (!tokenCount) return 0;
+  if (tiers?.length) return calculateTieredCost(tokenCount, tiers);
+  if (flatRate) return parseFloat(flatRate) * tokenCount;
+  return 0;
+}
+
+// Convert pricing (USD/token) to credits for billing
+// 100 credits = $1 USD
+export function pricingToCredits(
+  pricing: IModelPricing | undefined,
+  usage: {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    reasoningTokens?: number;
+    images?: number;
+    webSearches?: number;
+  }
+): number {
+  if (!pricing) return 0;
+
+  let totalUsd = 0;
+
+  totalUsd += categoryUsd(usage.inputTokens, pricing.input, pricing.inputTiers);
+  totalUsd += categoryUsd(usage.outputTokens, pricing.output, pricing.outputTiers);
+  totalUsd += categoryUsd(
+    usage.cacheReadTokens,
+    pricing.inputCacheRead,
+    pricing.inputCacheReadTiers
+  );
+  totalUsd += categoryUsd(
+    usage.cacheWriteTokens,
+    pricing.inputCacheWrite,
+    pricing.inputCacheWriteTiers
+  );
+  totalUsd += categoryUsd(usage.reasoningTokens, pricing.reasoning, undefined);
+
+  if (pricing.image && usage.images) {
+    totalUsd += parseFloat(pricing.image) * usage.images;
+  }
+  if (pricing.webSearch && usage.webSearches) {
+    // pricing.webSearch is USD per 1,000 searches
+    totalUsd += (parseFloat(pricing.webSearch) * usage.webSearches) / 1000;
+  }
+
+  return totalUsd / USD_PER_CREDIT;
+}
+
+/**
+ * AI SDK LanguageModelUsage compatible interface
+ * This is a subset of the AI SDK's LanguageModelUsage type
+ */
+export interface IAIModelUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+  reasoningTokens?: number;
+  cachedInputTokens?: number;
+  inputTokenDetails?: {
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    noCacheTokens?: number;
+  };
+  outputTokenDetails?: {
+    reasoningTokens?: number;
+    textTokens?: number;
+  };
+}
+
+/**
+ * Calculate credits from AI SDK LanguageModelUsage
+ * Supports detailed token breakdown (cached tokens, reasoning tokens, etc.)
+ * Round up to 2 decimal places
+ */
+export function pricingToCreditsFromUsage(
+  pricing: IModelPricing | undefined,
+  usage: IAIModelUsage
+): number {
+  if (!pricing) return 0;
+
+  // Extract detailed token info
+  const inputDetails = usage.inputTokenDetails || {};
+  const outputDetails = usage.outputTokenDetails || {};
+
+  // Calculate INPUT token counts (avoid double counting)
+  // inputTokens = noCacheTokens + cacheReadTokens
+  const totalInputTokens = usage.inputTokens ?? 0;
+  const cacheReadTokens = inputDetails.cacheReadTokens ?? usage.cachedInputTokens ?? 0;
+  const cacheWriteTokens = inputDetails.cacheWriteTokens ?? 0;
+  const noCacheTokens =
+    inputDetails.noCacheTokens ?? Math.max(0, totalInputTokens - cacheReadTokens);
+
+  // Calculate OUTPUT token counts (avoid double counting)
+  // outputTokens = textTokens + reasoningTokens
+  const totalOutputTokens = usage.outputTokens ?? 0;
+  const reasoningTokens = outputDetails.reasoningTokens ?? usage.reasoningTokens ?? 0;
+  const textOutputTokens =
+    outputDetails.textTokens ?? Math.max(0, totalOutputTokens - reasoningTokens);
+
+  const credits = pricingToCredits(pricing, {
+    inputTokens: noCacheTokens,
+    outputTokens: textOutputTokens,
+    cacheReadTokens,
+    cacheWriteTokens,
+    reasoningTokens,
+  });
+
+  // Round up to 2 decimal places
+  return Math.ceil(credits * 100) / 100;
+}
+
+/* eslint-disable @typescript-eslint/naming-convention */
+// Raw pricing schema matching Vercel AI Gateway API response (snake_case)
+// @see https://ai-gateway.vercel.sh/v1/models
+export const rawPricingSchema = z.object({
+  // Flat rates (USD per token/unit as string)
+  input: z.string().optional(),
+  output: z.string().optional(),
+  input_cache_read: z.string().optional(),
+  input_cache_write: z.string().optional(),
+  reasoning: z.string().optional(),
+  image: z.string().optional(),
+  web_search: z.string().optional(),
+
+  // Tiered pricing (overrides flat rate when present)
+  input_tiers: z.array(pricingTierSchema).optional(),
+  output_tiers: z.array(pricingTierSchema).optional(),
+  input_cache_read_tiers: z.array(pricingTierSchema).optional(),
+  input_cache_write_tiers: z.array(pricingTierSchema).optional(),
+});
+/* eslint-enable @typescript-eslint/naming-convention */
+
+export type IRawPricing = z.infer<typeof rawPricingSchema>;
+
+// Field mappings: [snakeCase, camelCase] pairs for pricing normalization
+const PRICING_STRING_FIELDS: [string, keyof IModelPricing][] = [
+  ['input', 'input'],
+  ['output', 'output'],
+  ['reasoning', 'reasoning'],
+  ['image', 'image'],
+  ['input_cache_read', 'inputCacheRead'],
+  ['input_cache_write', 'inputCacheWrite'],
+  ['web_search', 'webSearch'],
+];
+
+const PRICING_TIER_FIELDS: [string, keyof IModelPricing][] = [
+  ['input_tiers', 'inputTiers'],
+  ['output_tiers', 'outputTiers'],
+  ['input_cache_read_tiers', 'inputCacheReadTiers'],
+  ['input_cache_write_tiers', 'inputCacheWriteTiers'],
+];
+
+/**
+ * Normalize a pricing object from any source (gateway API snake_case or admin config camelCase)
+ * into our canonical camelCase IModelPricing format.
+ */
+export function normalizeGatewayPricing(
+  raw: IRawPricing | IModelPricing | Record<string, unknown> | undefined
+): IModelPricing | undefined {
+  if (!raw || Object.keys(raw).length === 0) return undefined;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const r = raw as Record<string, any>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const pricing: Record<string, any> = {};
+
+  for (const [snake, camel] of PRICING_STRING_FIELDS) {
+    const val = r[snake] ?? (snake !== camel ? r[camel] : undefined);
+    if (val != null) pricing[camel] = String(val);
+  }
+
+  for (const [snake, camel] of PRICING_TIER_FIELDS) {
+    const val = r[snake] ?? (snake !== camel ? r[camel] : undefined);
+    if (Array.isArray(val)) pricing[camel] = val;
+  }
+
+  return Object.keys(pricing).length > 0 ? (pricing as IModelPricing) : undefined;
+}
diff --git a/packages/openapi/src/admin/setting/test-llm.ts b/packages/openapi/src/admin/setting/test-llm.ts
index ab7068f4c0..4849f6e9af 100644
--- a/packages/openapi/src/admin/setting/test-llm.ts
+++ b/packages/openapi/src/admin/setting/test-llm.ts
@@ -2,7 +2,8 @@ import type { RouteConfig } from '@asteasolutions/zod-to-openapi';
 import { z } from 'zod';
 import { axios } from '../../axios';
 import { registerRoute } from '../../utils';
-import { chatModelAbilitySchema, chatModelAbilityType, llmProviderSchema } from './update';
+import { chatModelAbilitySchema, chatModelAbilityType } from './model-ability';
+import { llmProviderSchema } from './update';
 
 export const testLLMRoSchema = llmProviderSchema
   .omit({
diff --git a/packages/openapi/src/admin/setting/update.spec.ts b/packages/openapi/src/admin/setting/update.spec.ts
new file mode 100644
index 0000000000..04920e086c
--- /dev/null
+++ b/packages/openapi/src/admin/setting/update.spec.ts
@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import { gatewayApiModelRawSchema, getImageModelTagsFromAbility } from './index';
+
+const IMAGE_GENERATION_TAG = 'image-generation';
+
+describe('setting index exports', () => {
+  it('re-exports model ability helpers from the setting barrel', () => {
+    expect(
+      getImageModelTagsFromAbility(
+        {
+          generation: true,
+          imageToImage: true,
+        },
+        undefined
+      )
+    ).toEqual([IMAGE_GENERATION_TAG, 'vision']);
+  });
+
+  it('accepts current AI Gateway image model providers', () => {
+    expect(
+      gatewayApiModelRawSchema.parse({
+        id: 'prodia/flux-fast-schnell',
+        type: 'image',
+        owned_by: 'prodia',
+        tags: [IMAGE_GENERATION_TAG],
+      }).owned_by
+    ).toBe('prodia');
+    expect(
+      gatewayApiModelRawSchema.parse({
+        id: 'recraft/recraft-v4-pro',
+        type: 'image',
+        owned_by: 'recraft',
+        tags: [IMAGE_GENERATION_TAG],
+      }).owned_by
+    ).toBe('recraft');
+  });
+});
diff --git a/packages/openapi/src/admin/setting/update.ts b/packages/openapi/src/admin/setting/update.ts
index 62e403d212..c53cb9eaad 100644
--- a/packages/openapi/src/admin/setting/update.ts
+++ b/packages/openapi/src/admin/setting/update.ts
@@ -3,6 +3,18 @@ import { z } from 'zod';
 import { axios } from '../../axios';
 import { mailTransportConfigSchema } from '../../mail';
 import { registerRoute } from '../../utils';
+import {
+  gatewayModelProviderSchema,
+  gatewayModelSchema,
+  gatewayModelTagSchema,
+  gatewayModelTypeSchema,
+} from './gateway-model';
+import {
+  chatModelAbilitySchema,
+  imageModelAbilitySchema,
+  modelAbilitySchema,
+} from './model-ability';
+import { pricingSchema } from './pricing';
 
 export enum LLMProviderType {
   OPENAI = 'openai',
@@ -27,270 +39,6 @@ export enum LLMProviderType {
   CLAUDE_CODE = 'claudeCode',
 }
 
-// Gateway model type from API (language, embedding, image)
-export const GatewayModelTypeValues = ['language', 'embedding', 'image'] as const;
-export type GatewayModelType = (typeof GatewayModelTypeValues)[number];
-export const gatewayModelTypeSchema = z.enum(GatewayModelTypeValues);
-
-// Gateway model capability tags from API
-export const GatewayModelTagValues = [
-  'reasoning',
-  'tool-use',
-  'vision',
-  'file-input',
-  'image-generation',
-  'implicit-caching',
-] as const;
-export type GatewayModelTag = (typeof GatewayModelTagValues)[number];
-export const gatewayModelTagSchema = z.enum(GatewayModelTagValues);
-
-// Gateway model provider (owned_by) from API
-export const GatewayModelProviderValues = [
-  'alibaba',
-  'amazon',
-  'anthropic',
-  'arcee-ai',
-  'bfl',
-  'bytedance',
-  'cohere',
-  'deepseek',
-  'google',
-  'inception',
-  'kwaipilot',
-  'meituan',
-  'meta',
-  'minimax',
-  'mistral',
-  'moonshotai',
-  'morph',
-  'nvidia',
-  'openai',
-  'perplexity',
-  'prime-intellect',
-  'stealth',
-  'vercel',
-  'voyage',
-  'xai',
-  'xiaomi',
-  'zai',
-] as const;
-export type GatewayModelProvider = (typeof GatewayModelProviderValues)[number];
-export const gatewayModelProviderSchema = z.enum(GatewayModelProviderValues);
-
-// Detailed ability support with URL and base64 variants
-export const abilityDetailSchema = z.object({
-  url: z.boolean().optional(),
-  base64: z.boolean().optional(),
-});
-
-export type IAbilityDetail = z.infer<typeof abilityDetailSchema>;
-
-// Model ability schema for test results
-export const modelAbilitySchema = z.object({
-  image: z.union([z.boolean(), abilityDetailSchema]).optional(), // vision/image input
-  pdf: z.union([z.boolean(), abilityDetailSchema]).optional(), // PDF/file input
-  webSearch: z.boolean().optional(),
-  toolCall: z.boolean().optional(), // tool/function calling
-  reasoning: z.boolean().optional(), // extended thinking/reasoning
-  imageGeneration: z.boolean().optional(), // can generate images
-});
-
-export type IModelAbility = z.infer<typeof modelAbilitySchema>;
-
-// Image model ability schema
-export const imageModelAbilitySchema = z.object({
-  generation: z.boolean().optional(), // can generate images from text
-  imageToImage: z.boolean().optional(), // can generate images from image input
-});
-
-export type IImageModelAbility = z.infer<typeof imageModelAbilitySchema>;
-
-// Tiered pricing tier - for volume-based pricing where cost changes at token thresholds
-export const pricingTierSchema = z.object({
-  cost: z.string(), // USD per token at this tier
-  min: z.number(), // Tier start (inclusive)
-  max: z.number().optional(), // Tier end (absent = open-ended last tier)
-});
-
-export type IPricingTier = z.infer<typeof pricingTierSchema>;
-
-// Unified pricing schema - USD per token (string format, same as Vercel AI Gateway API)
-// 100 credits = $1 USD. Credits = totalUSD / USD_PER_CREDIT
-export const pricingSchema = z.object({
-  // Flat rates (USD per token/unit as string)
-  input: z.string().optional(),
-  output: z.string().optional(),
-  inputCacheRead: z.string().optional(),
-  inputCacheWrite: z.string().optional(),
-  reasoning: z.string().optional(),
-  image: z.string().optional(),
-  webSearch: z.string().optional(),
-
-  // Tiered pricing (overrides flat rate when present)
-  inputTiers: z.array(pricingTierSchema).optional(),
-  outputTiers: z.array(pricingTierSchema).optional(),
-  inputCacheReadTiers: z.array(pricingTierSchema).optional(),
-  inputCacheWriteTiers: z.array(pricingTierSchema).optional(),
-});
-
-export type IModelPricing = z.infer<typeof pricingSchema>;
-
-// Legacy rates schema (credits per 1M tokens) - for backward compatibility
-// Will be converted to new pricing format when reading
-export const legacyRatesSchema = z.object({
-  inputRate: z.number().min(0).optional(),
-  outputRate: z.number().min(0).optional(),
-  cacheReadRate: z.number().min(0).optional(),
-  cacheWriteRate: z.number().min(0).optional(),
-  reasoningRate: z.number().min(0).optional(),
-  imageRate: z.number().min(0).optional(),
-  webSearchRate: z.number().min(0).optional(),
-});
-
-export type ILegacyRates = z.infer<typeof legacyRatesSchema>;
-
-// Conversion constants
-// 1 credit = $0.01 USD (100 credits = $1)
-export const USD_PER_CREDIT = 0.01;
-// Legacy rates were in credits per 1M tokens
-export const TOKENS_PER_RATE_UNIT = 1_000_000;
-
-/**
- * Calculate cost for tokens using tiered (progressive) pricing.
- * Each tier covers a range [min, max). The last tier has no max (open-ended).
- */
-export function calculateTieredCost(tokenCount: number, tiers: IPricingTier[]): number {
-  let totalCost = 0;
-  for (const tier of tiers) {
-    if (tokenCount <= tier.min) break;
-    const tierMax = tier.max ?? Infinity;
-    const tokensInTier = Math.min(tokenCount, tierMax) - tier.min;
-    totalCost += tokensInTier * parseFloat(tier.cost);
-  }
-  return totalCost;
-}
-
-/**
- * Calculate USD cost for a single pricing category.
- * Uses tiered pricing if available, otherwise falls back to flat rate.
- */
-function categoryUsd(
-  tokenCount: number | undefined,
-  flatRate: string | undefined,
-  tiers: IPricingTier[] | undefined
-): number {
-  if (!tokenCount) return 0;
-  if (tiers?.length) return calculateTieredCost(tokenCount, tiers);
-  if (flatRate) return parseFloat(flatRate) * tokenCount;
-  return 0;
-}
-
-// Convert pricing (USD/token) to credits for billing
-// 100 credits = $1 USD
-export function pricingToCredits(
-  pricing: IModelPricing | undefined,
-  usage: {
-    inputTokens?: number;
-    outputTokens?: number;
-    cacheReadTokens?: number;
-    cacheWriteTokens?: number;
-    reasoningTokens?: number;
-    images?: number;
-    webSearches?: number;
-  }
-): number {
-  if (!pricing) return 0;
-
-  let totalUsd = 0;
-
-  totalUsd += categoryUsd(usage.inputTokens, pricing.input, pricing.inputTiers);
-  totalUsd += categoryUsd(usage.outputTokens, pricing.output, pricing.outputTiers);
-  totalUsd += categoryUsd(
-    usage.cacheReadTokens,
-    pricing.inputCacheRead,
-    pricing.inputCacheReadTiers
-  );
-  totalUsd += categoryUsd(
-    usage.cacheWriteTokens,
-    pricing.inputCacheWrite,
-    pricing.inputCacheWriteTiers
-  );
-  totalUsd += categoryUsd(usage.reasoningTokens, pricing.reasoning, undefined);
-
-  if (pricing.image && usage.images) {
-    totalUsd += parseFloat(pricing.image) * usage.images;
-  }
-  if (pricing.webSearch && usage.webSearches) {
-    // pricing.webSearch is USD per 1,000 searches
-    totalUsd += (parseFloat(pricing.webSearch) * usage.webSearches) / 1000;
-  }
-
-  return totalUsd / USD_PER_CREDIT;
-}
-
-/**
- * AI SDK LanguageModelUsage compatible interface
- * This is a subset of the AI SDK's LanguageModelUsage type
- */
-export interface IAIModelUsage {
-  inputTokens?: number;
-  outputTokens?: number;
-  totalTokens?: number;
-  reasoningTokens?: number;
-  cachedInputTokens?: number;
-  inputTokenDetails?: {
-    cacheReadTokens?: number;
-    cacheWriteTokens?: number;
-    noCacheTokens?: number;
-  };
-  outputTokenDetails?: {
-    reasoningTokens?: number;
-    textTokens?: number;
-  };
-}
-
-/**
- * Calculate credits from AI SDK LanguageModelUsage
- * Supports detailed token breakdown (cached tokens, reasoning tokens, etc.)
- * Round up to 2 decimal places
- */
-export function pricingToCreditsFromUsage(
-  pricing: IModelPricing | undefined,
-  usage: IAIModelUsage
-): number {
-  if (!pricing) return 0;
-
-  // Extract detailed token info
-  const inputDetails = usage.inputTokenDetails || {};
-  const outputDetails = usage.outputTokenDetails || {};
-
-  // Calculate INPUT token counts (avoid double counting)
-  // inputTokens = noCacheTokens + cacheReadTokens
-  const totalInputTokens = usage.inputTokens ?? 0;
-  const cacheReadTokens = inputDetails.cacheReadTokens ?? usage.cachedInputTokens ?? 0;
-  const cacheWriteTokens = inputDetails.cacheWriteTokens ?? 0;
-  const noCacheTokens =
-    inputDetails.noCacheTokens ?? Math.max(0, totalInputTokens - cacheReadTokens);
-
-  // Calculate OUTPUT token counts (avoid double counting)
-  // outputTokens = textTokens + reasoningTokens
-  const totalOutputTokens = usage.outputTokens ?? 0;
-  const reasoningTokens = outputDetails.reasoningTokens ?? usage.reasoningTokens ?? 0;
-  const textOutputTokens =
-    outputDetails.textTokens ?? Math.max(0, totalOutputTokens - reasoningTokens);
-
-  const credits = pricingToCredits(pricing, {
-    inputTokens: noCacheTokens,
-    outputTokens: textOutputTokens,
-    cacheReadTokens,
-    cacheWriteTokens,
-    reasoningTokens,
-  });
-
-  // Round up to 2 decimal places
-  return Math.ceil(credits * 100) / 100;
-}
-
 // Model-specific configuration - unified structure for all model types
 // Supports both new pricing (USD) and legacy rates (credits/1M) for backward compatibility
 export const modelConfigSchema = z.object({
@@ -342,15 +90,6 @@ export const llmProviderSchema = z.object({
 
 export type LLMProvider = z.infer<typeof llmProviderSchema>;
 
-// chatModelAbilitySchema is same as modelAbilitySchema, for backward compatibility
-export const chatModelAbilitySchema = modelAbilitySchema;
-
-export const chatModelAbilityType = chatModelAbilitySchema.keyof();
-
-export type IChatModelAbilityType = z.infer<typeof chatModelAbilityType>;
-
-export type IChatModelAbility = z.infer<typeof chatModelAbilitySchema>;
-
 export const chatModelSchema = z.object({
   lg: z.string().optional(),
   md: z.string().optional(),
@@ -358,179 +97,6 @@ export const chatModelSchema = z.object({
   ability: chatModelAbilitySchema.optional(),
 });
 
-// Gateway model default assignment targets
-export enum GatewayModelDefaultFor {
-  CHAT_LG = 'chatLg',
-  CHAT_MD = 'chatMd',
-  CHAT_SM = 'chatSm',
-  AI_FIELD_TEXT = 'aiFieldText',
-  AI_FIELD_IMAGE = 'aiFieldImage',
-}
-
-// Individual gateway model configuration (admin-maintained)
-export const gatewayModelSchema = z.object({
-  // modelId used directly with AI Gateway (e.g., "anthropic/claude-sonnet-4")
-  id: z.string(),
-  // Display label (e.g., "Claude Sonnet 4")
-  label: z.string(),
-  // Whether this model is visible to end users
-  enabled: z.boolean().default(true),
-  // Model capabilities (for UI tags and validation)
-  capabilities: modelAbilitySchema.optional(),
-  // Pricing in USD (new unified format)
-  pricing: pricingSchema.optional(),
-  // @deprecated Legacy rates in credits per 1M tokens - use pricing instead
-  rates: legacyRatesSchema.optional(),
-  // Mark as image generation model
-  isImageModel: z.boolean().optional(),
-  // Default assignment (which use cases this model is default for)
-  defaultFor: z.array(z.nativeEnum(GatewayModelDefaultFor)).optional(),
-  // Last test timestamp
-  testedAt: z.number().optional(),
-  // === Metadata from AI Gateway API ===
-  // Provider that owns this model (e.g., "anthropic", "google", "openai")
-  ownedBy: gatewayModelProviderSchema.optional(),
-  // Model type from API (e.g., "language", "image")
-  modelType: gatewayModelTypeSchema.optional(),
-  // Capability tags from API (e.g., ["image-generation", "vision", "tool-use"])
-  tags: z.array(gatewayModelTagSchema).optional(),
-  // Context window size (input tokens)
-  contextWindow: z.number().optional(),
-  // Maximum output tokens
-  maxTokens: z.number().optional(),
-  // Model description
-  description: z.string().optional(),
-  // Admin-curated i18n description (e.g., "Most capable for ambitious work")
-  i18nDescription: z
-    .object({
-      en: z.string().optional(),
-      zh: z.string().optional(),
-    })
-    .optional(),
-});
-
-export type IGatewayModel = z.infer<typeof gatewayModelSchema>;
-
-/* eslint-disable @typescript-eslint/naming-convention */
-// Raw pricing schema matching Vercel AI Gateway API response (snake_case)
-// @see https://ai-gateway.vercel.sh/v1/models
-export const rawPricingSchema = z.object({
-  // Flat rates (USD per token/unit as string)
-  input: z.string().optional(),
-  output: z.string().optional(),
-  input_cache_read: z.string().optional(),
-  input_cache_write: z.string().optional(),
-  reasoning: z.string().optional(),
-  image: z.string().optional(),
-  web_search: z.string().optional(),
-
-  // Tiered pricing (overrides flat rate when present)
-  input_tiers: z.array(pricingTierSchema).optional(),
-  output_tiers: z.array(pricingTierSchema).optional(),
-  input_cache_read_tiers: z.array(pricingTierSchema).optional(),
-  input_cache_write_tiers: z.array(pricingTierSchema).optional(),
-});
-
-export type IRawPricing = z.infer<typeof rawPricingSchema>;
-
-// Raw API response structure from Vercel AI Gateway (snake_case as returned by API)
-export const gatewayApiModelRawSchema = z.object({
-  id: z.string(),
-  name: z.string().optional(),
-  description: z.string().optional(),
-  type: gatewayModelTypeSchema.optional(),
-  tags: z.array(gatewayModelTagSchema).optional(),
-  context_window: z.number().optional(),
-  max_tokens: z.number().optional(),
-  created: z.number().optional(),
-  owned_by: gatewayModelProviderSchema.optional(),
-  pricing: rawPricingSchema.optional(),
-});
-/* eslint-enable @typescript-eslint/naming-convention */
-
-export type IGatewayApiModelRaw = z.infer<typeof gatewayApiModelRawSchema>;
-
-// Gateway API model structure (camelCase, converted from API snake_case)
-export const gatewayApiModelSchema = z.object({
-  id: z.string(),
-  name: z.string().optional(),
-  description: z.string().optional(),
-  type: gatewayModelTypeSchema.optional(),
-  tags: z.array(gatewayModelTagSchema).optional(),
-  contextWindow: z.number().optional(),
-  maxTokens: z.number().optional(),
-  created: z.number().optional(),
-  ownedBy: gatewayModelProviderSchema.optional(),
-  pricing: pricingSchema.optional(),
-});
-
-export type IGatewayApiModel = z.infer<typeof gatewayApiModelSchema>;
-
-/**
- * Normalize a pricing object from any source (gateway API snake_case or admin config camelCase)
- * into our canonical camelCase IModelPricing format.
- */
-// Field mappings: [snakeCase, camelCase] pairs for pricing normalization
-const PRICING_STRING_FIELDS: [string, keyof IModelPricing][] = [
-  ['input', 'input'],
-  ['output', 'output'],
-  ['reasoning', 'reasoning'],
-  ['image', 'image'],
-  ['input_cache_read', 'inputCacheRead'],
-  ['input_cache_write', 'inputCacheWrite'],
-  ['web_search', 'webSearch'],
-];
-
-const PRICING_TIER_FIELDS: [string, keyof IModelPricing][] = [
-  ['input_tiers', 'inputTiers'],
-  ['output_tiers', 'outputTiers'],
-  ['input_cache_read_tiers', 'inputCacheReadTiers'],
-  ['input_cache_write_tiers', 'inputCacheWriteTiers'],
-];
-
-/**
- * Normalize a pricing object from any source (gateway API snake_case or admin config camelCase)
- * into our canonical camelCase IModelPricing format.
- */
-export function normalizeGatewayPricing(
-  raw: IRawPricing | IModelPricing | Record<string, unknown> | undefined
-): IModelPricing | undefined {
-  if (!raw || Object.keys(raw).length === 0) return undefined;
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const r = raw as Record<string, any>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const pricing: Record<string, any> = {};
-
-  for (const [snake, camel] of PRICING_STRING_FIELDS) {
-    const val = r[snake] ?? (snake !== camel ? r[camel] : undefined);
-    if (val != null) pricing[camel] = String(val);
-  }
-
-  for (const [snake, camel] of PRICING_TIER_FIELDS) {
-    const val = r[snake] ?? (snake !== camel ? r[camel] : undefined);
-    if (Array.isArray(val)) pricing[camel] = val;
-  }
-
-  return Object.keys(pricing).length > 0 ? (pricing as IModelPricing) : undefined;
-}
-
-// Helper function to convert raw API response to camelCase
-export function convertGatewayApiModel(raw: IGatewayApiModelRaw): IGatewayApiModel {
-  return {
-    id: raw.id,
-    name: raw.name,
-    description: raw.description,
-    type: raw.type,
-    tags: raw.tags,
-    contextWindow: raw.context_window,
-    maxTokens: raw.max_tokens,
-    created: raw.created,
-    ownedBy: raw.owned_by,
-    pricing: normalizeGatewayPricing(raw.pricing),
-  };
-}
-
 // Attachment transfer mode test result for a single mode
 export const attachmentModeTestResultSchema = z.object({
   success: z.boolean(),
@@ -693,6 +259,18 @@ export const sandboxAgentModelSchema = z.object({
   name: z.string(),
 });
 
+export const SANDBOX_AGENT_EFFORT_VALUES = [
+  'auto',
+  'low',
+  'medium',
+  'high',
+  'xhigh',
+  'max',
+] as const;
+export const sandboxAgentEffortSchema = z.enum(SANDBOX_AGENT_EFFORT_VALUES);
+export type EffortLevel = z.infer<typeof sandboxAgentEffortSchema>;
+export const DEFAULT_SANDBOX_AGENT_EFFORT: EffortLevel = 'auto';
+
 export type ISandboxAgentModel = z.infer<typeof sandboxAgentModelSchema>;
 
 export const sandboxAgentConfigSchema = z.object({
@@ -705,10 +283,7 @@ export const sandboxAgentConfigSchema = z.object({
   maxConcurrentChats: z.number().min(1).max(20).default(3).optional(),
   activeSnapshotId: z.string().optional(),
   activeAppBuilderSnapshotId: z.string().optional(),
-  defaultEffort: z
-    .enum(['auto', 'low', 'medium', 'high', 'xhigh', 'max'])
-    .default('auto')
-    .optional(),
+  defaultEffort: sandboxAgentEffortSchema.default(DEFAULT_SANDBOX_AGENT_EFFORT).optional(),
 });
 
 export type ISandboxAgentConfig = z.infer<typeof sandboxAgentConfigSchema>;
diff --git a/packages/openapi/src/ai/image-generation-input-capability.ts b/packages/openapi/src/ai/image-generation-input-capability.ts
new file mode 100644
index 0000000000..a8640a847c
--- /dev/null
+++ b/packages/openapi/src/ai/image-generation-input-capability.ts
@@ -0,0 +1,83 @@
+export enum ImageGenerationInputMode {
+  None = 'none',
+  MultimodalMessage = 'multimodal-message',
+  ImageEditPrompt = 'image-edit-prompt',
+}
+
+export interface IImageGenerationInputCapabilityRule {
+  provider: string;
+  modelPrefix: string;
+  requiredTags: readonly string[];
+  mode: ImageGenerationInputMode;
+}
+
+/**
+ * Provider/model specific rules for image generation models that can consume input images.
+ *
+ * AI Gateway currently exposes generic `image-generation` and `vision` tags but
+ * does not expose a distinct image-to-image/image-edit capability. Keep the
+ * rule registry here so adding future model families is localized.
+ */
+export const IMAGE_GENERATION_INPUT_CAPABILITY_RULES: readonly IImageGenerationInputCapabilityRule[] =
+  [
+    {
+      provider: 'openai',
+      modelPrefix: 'gpt-image-',
+      requiredTags: ['image-generation'],
+      mode: ImageGenerationInputMode.ImageEditPrompt,
+    },
+    {
+      provider: 'google',
+      modelPrefix: 'gemini-',
+      requiredTags: ['image-generation'],
+      mode: ImageGenerationInputMode.MultimodalMessage,
+    },
+  ];
+
+const parseGatewayModelId = (modelId: string): { provider: string; model: string } => {
+  const [provider, ...modelParts] = modelId.split('/');
+  return {
+    provider,
+    model: modelParts.join('/'),
+  };
+};
+
+/**
+ * Resolve how image attachments should be passed to an image generation model.
+ */
+export function getImageGenerationInputMode(
+  modelId: string,
+  tags: readonly string[] = []
+): ImageGenerationInputMode {
+  const { provider, model } = parseGatewayModelId(modelId);
+
+  const matchedRule = IMAGE_GENERATION_INPUT_CAPABILITY_RULES.find((rule) => {
+    return (
+      rule.provider === provider &&
+      model.startsWith(rule.modelPrefix) &&
+      rule.requiredTags.every((tag) => tags.includes(tag))
+    );
+  });
+
+  return matchedRule?.mode ?? ImageGenerationInputMode.None;
+}
+
+/**
+ * Whether the model can consume input images while generating output images.
+ */
+export function supportsImageInputForImageGeneration(
+  modelId: string,
+  tags: readonly string[] = []
+): boolean {
+  return getImageGenerationInputMode(modelId, tags) !== ImageGenerationInputMode.None;
+}
+
+/**
+ * Whether the model should receive image attachments through AI SDK generateImage prompt.images.
+ */
+export function supportsImageEditPromptForImageGeneration(
+  modelId: string,
+  tags: readonly string[] = []
+): boolean {
+  return getImageGenerationInputMode(modelId, tags) === ImageGenerationInputMode.ImageEditPrompt;
+}
diff --git a/packages/openapi/src/ai/image-model-catalog.ts b/packages/openapi/src/ai/image-model-catalog.ts
new file mode 100644
index 0000000000..cc6554f100
--- /dev/null
+++ b/packages/openapi/src/ai/image-model-catalog.ts
@@ -0,0 +1,457 @@
+/* eslint-disable sonarjs/no-duplicate-string */
+import {
+  BFL_ASPECT_RATIO_PRESETS,
+  BFL_ASPECT_RATIO_RANGE,
+  DEEPINFRA_STABILITY_ASPECT_RATIOS,
+  DIMENSION_RANGE_256_1440_MULTIPLE_32,
+  FIREWORKS_1024_SIZES,
+  FIREWORKS_FLUX_ASPECT_RATIOS,
+  GEMINI_IMAGE_ASPECT_RATIOS,
+  GOOGLE_IMAGEN_ASPECT_RATIOS,
+  OPENAI_DALLE2_SIZES,
+  OPENAI_DALLE3_SIZES,
+  OPENAI_GPT_IMAGE_2_SIZES,
+  OPENAI_GPT_IMAGE_SIZES,
+  REPLICATE_FLUX_SCHNELL_ASPECT_RATIOS,
+  REPLICATE_RECRAFT_SIZES,
+  STANDARD_ASPECT_RATIOS,
+  TOGETHERAI_SQUARE_SIZES,
+  XAI_GROK_ASPECT_RATIOS,
+} from './image-model-dimensions';
+import type { IAspectRatio, IImageSize } from './image-model-dimensions';
+import type { IImageModelConfig } from './image-model-types';
+
+const createAspectRatioImageModel = (
+  provider: string,
+  model: string,
+  displayName: string,
+  supportedAspectRatios: IAspectRatio[] = STANDARD_ASPECT_RATIOS
+): IImageModelConfig => ({
+  provider,
+  model,
+  displayName,
+  sizeType: 'aspectRatio',
+  supportedAspectRatios,
+  defaultAspectRatio: '1:1',
+  modelType: 'image',
+});
+
+const createSizeImageModel = (
+  provider: string,
+  model: string,
+  displayName: string,
+  supportedSizes: IImageSize[],
+  defaultSize: IImageSize = supportedSizes[0]
+): IImageModelConfig => ({
+  provider,
+  model,
+  displayName,
+  sizeType: 'size',
+  supportedSizes,
+  defaultSize,
+  modelType: 'image',
+});
+
+const createOpenAIGptImageModel = (
+  model: string,
+  displayName: string,
+  supportedSizes: IImageSize[] = OPENAI_GPT_IMAGE_SIZES
+): IImageModelConfig => ({
+  provider: 'openai',
+  model,
+  displayName,
+  sizeType: 'size',
+  supportedSizes,
+  defaultSize: '1024x1024',
+  supportsQuality: true,
+  supportsStyle: true,
+  modelType: 'image',
+  tags: ['image-generation'],
+});
+
+const createGeminiImageLanguageModel = (model: string, displayName: string): IImageModelConfig => ({
+  provider: 'google',
+  model,
+  displayName,
+  sizeType: 'flexible',
+  supportedAspectRatios: GEMINI_IMAGE_ASPECT_RATIOS,
+  modelType: 'language',
+  tags: ['image-generation'],
+  notes: 'Multimodal LLM with image generation via generateText',
+});
+
+const createDimensionRangeImageModel = (
+  provider: string,
+  model: string,
+  displayName: string,
+  sizeRange: NonNullable<IImageModelConfig['sizeRange']>
+): IImageModelConfig => ({
+  provider,
+  model,
+  displayName,
+  sizeType: 'flexible',
+  sizeRange,
+  modelType: 'image',
+});
+
+const createBflImageModel = (model: string, displayName: string): IImageModelConfig => ({
+  provider: 'bfl',
+  model,
+  displayName,
+  sizeType: 'aspectRatio',
+  supportedAspectRatios: BFL_ASPECT_RATIO_PRESETS,
+  aspectRatioRange: BFL_ASPECT_RATIO_RANGE,
+  defaultAspectRatio: '1:1',
+  modelType: 'image',
+});
+
+const createRecraftImageModel = (model: string, displayName: string): IImageModelConfig =>
+  createSizeImageModel('recraft', model, displayName, REPLICATE_RECRAFT_SIZES);
+
+/**
+ * Image model configurations by provider
+ * Based on: https://ai-sdk.dev/docs/ai-sdk-core/image-generation#image-models
+ */
+export const IMAGE_MODEL_CONFIGS: IImageModelConfig[] = [
+  // xAI Grok
+  {
+    provider: 'xai',
+    model: 'grok-imagine-image',
+    displayName: 'Grok Imagine Image',
+    sizeType: 'aspectRatio',
+    supportedAspectRatios: XAI_GROK_ASPECT_RATIOS,
+    supportsAutoAspectRatio: true,
+    defaultAspectRatio: '1:1',
+    modelType: 'image',
+  },
+
+  // OpenAI
+  createOpenAIGptImageModel('gpt-image-2', 'GPT Image 2', OPENAI_GPT_IMAGE_2_SIZES),
+  createOpenAIGptImageModel('gpt-image-1.5', 'GPT Image 1.5'),
+  createOpenAIGptImageModel('gpt-image-1-mini', 'GPT Image 1 Mini'),
+  createOpenAIGptImageModel('gpt-image-1', 'GPT Image 1'),
+  {
+    provider: 'openai',
+    model: 'dall-e-3',
+    displayName: 'DALL-E 3',
+    sizeType: 'size',
+    supportedSizes: OPENAI_DALLE3_SIZES,
+    defaultSize: '1024x1024',
+    maxImagesPerCall: 1,
+    supportsQuality: true,
+    supportsStyle: true,
+    supportsSeed: true,
+    modelType: 'image',
+  },
+  {
+    provider: 'openai',
+    model: 'dall-e-2',
+    displayName: 'DALL-E 2',
+    sizeType: 'size',
+    supportedSizes: OPENAI_DALLE2_SIZES,
+    defaultSize: '1024x1024',
+    maxImagesPerCall: 10,
+    modelType: 'image',
+  },
+
+  // Amazon Bedrock
+  {
+    provider: 'amazonBedrock',
+    model: 'amazon.nova-canvas-v1:0',
+    displayName: 'Amazon Nova Canvas',
+    sizeType: 'both',
+    sizeRange: {
+      min: 320,
+      max: 4096,
+      multipleOf: 16,
+      maxPixels: 4_200_000,
+    },
+    aspectRatioRange: {
+      min: '1:4',
+      max: '4:1',
+      notes: '1:4 to 4:1',
+    },
+    modelType: 'image',
+  },
+
+  // Fal
+  createAspectRatioImageModel('fal', 'fal-ai/flux/dev', 'FLUX Dev'),
+  createAspectRatioImageModel('fal', 'fal-ai/flux-lora', 'FLUX LoRA'),
+  createAspectRatioImageModel('fal', 'fal-ai/fast-sdxl', 'Fast SDXL'),
+  createAspectRatioImageModel('fal', 'fal-ai/flux-pro/v1.1-ultra', 'FLUX Pro 1.1 Ultra'),
+  createAspectRatioImageModel('fal', 'fal-ai/ideogram/v2', 'Ideogram V2'),
+  createAspectRatioImageModel('fal', 'fal-ai/recraft-v3', 'Recraft V3'),
+  createAspectRatioImageModel(
+    'fal',
+    'fal-ai/stable-diffusion-3.5-large',
+    'Stable Diffusion 3.5 Large'
+  ),
+  createAspectRatioImageModel('fal', 'fal-ai/hyper-sdxl', 'Hyper SDXL'),
+
+  // DeepInfra
+  createAspectRatioImageModel(
+    'deepinfra',
+    'stabilityai/sd3.5',
+    'Stable Diffusion 3.5',
+    DEEPINFRA_STABILITY_ASPECT_RATIOS
+  ),
+  createDimensionRangeImageModel(
+    'deepinfra',
+    'black-forest-labs/FLUX-1.1-pro',
+    'FLUX 1.1 Pro',
+    DIMENSION_RANGE_256_1440_MULTIPLE_32
+  ),
+  createDimensionRangeImageModel(
+    'deepinfra',
+    'black-forest-labs/FLUX-1-schnell',
+    'FLUX 1 Schnell',
+    DIMENSION_RANGE_256_1440_MULTIPLE_32
+  ),
+  createDimensionRangeImageModel(
+    'deepinfra',
+    'black-forest-labs/FLUX-1-dev',
+    'FLUX 1 Dev',
+    DIMENSION_RANGE_256_1440_MULTIPLE_32
+  ),
+  createDimensionRangeImageModel(
+    'deepinfra',
+    'black-forest-labs/FLUX-pro',
+    'FLUX Pro',
+    DIMENSION_RANGE_256_1440_MULTIPLE_32
+  ),
+  createAspectRatioImageModel(
+    'deepinfra',
+    'stabilityai/sd3.5-medium',
+    'Stable Diffusion 3.5 Medium',
+    DEEPINFRA_STABILITY_ASPECT_RATIOS
+  ),
+  createAspectRatioImageModel(
+    'deepinfra',
+    'stabilityai/sdxl-turbo',
+    'SDXL Turbo',
+    DEEPINFRA_STABILITY_ASPECT_RATIOS
+  ),
+
+  // Replicate
+  createAspectRatioImageModel(
+    'replicate',
+    'black-forest-labs/flux-schnell',
+    'FLUX Schnell',
+    REPLICATE_FLUX_SCHNELL_ASPECT_RATIOS
+  ),
+  createSizeImageModel('replicate', 'recraft-ai/recraft-v3', 'Recraft V3', REPLICATE_RECRAFT_SIZES),
+
+  // Google (Multimodal LLMs with image generation capability)
+  createGeminiImageLanguageModel('gemini-2.5-flash-image', 'Gemini 2.5 Flash Image'),
+  createGeminiImageLanguageModel(
+    'gemini-2.5-flash-image-preview',
+    'Gemini 2.5 Flash Image Preview'
+  ),
+  createGeminiImageLanguageModel('gemini-3-pro-image', 'Gemini 3 Pro Image'),
+  createGeminiImageLanguageModel(
+    'gemini-3.1-flash-image-preview',
+    'Gemini 3.1 Flash Image Preview'
+  ),
+
+  // Google Imagen
+  createAspectRatioImageModel(
+    'google',
+    'imagen-4.0-generate-001',
+    'Imagen 4.0',
+    GOOGLE_IMAGEN_ASPECT_RATIOS
+  ),
+  createAspectRatioImageModel(
+    'google',
+    'imagen-4.0-fast-generate-001',
+    'Imagen 4.0 Fast',
+    GOOGLE_IMAGEN_ASPECT_RATIOS
+  ),
+  createAspectRatioImageModel(
+    'google',
+    'imagen-4.0-ultra-generate-001',
+    'Imagen 4.0 Ultra',
+    GOOGLE_IMAGEN_ASPECT_RATIOS
+  ),
+
+  // ByteDance
+  createAspectRatioImageModel('bytedance', 'seedream-4.0', 'Seedream 4.0'),
+  createAspectRatioImageModel('bytedance', 'seedream-4.5', 'Seedream 4.5'),
+  createAspectRatioImageModel('bytedance', 'seedream-5.0-lite', 'Seedream 5.0 Lite'),
+
+  // Google Vertex
+  createAspectRatioImageModel(
+    'googleVertex',
+    'imagen-4.0-generate-001',
+    'Imagen 4.0',
+    GOOGLE_IMAGEN_ASPECT_RATIOS
+  ),
+  createAspectRatioImageModel(
+    'googleVertex',
+    'imagen-4.0-fast-generate-001',
+    'Imagen 4.0 Fast',
+    GOOGLE_IMAGEN_ASPECT_RATIOS
+  ),
+  createAspectRatioImageModel(
+    'googleVertex',
+    'imagen-4.0-ultra-generate-001',
+    'Imagen 4.0 Ultra',
+    GOOGLE_IMAGEN_ASPECT_RATIOS
+  ),
+  createAspectRatioImageModel(
+    'googleVertex',
+    'imagen-3.0-fast-generate-001',
+    'Imagen 3.0 Fast',
+    GOOGLE_IMAGEN_ASPECT_RATIOS
+  ),
+
+  // Fireworks
+  createAspectRatioImageModel(
+    'fireworks',
+    'accounts/fireworks/models/flux-1-dev-fp8',
+    'FLUX 1 Dev FP8',
+    FIREWORKS_FLUX_ASPECT_RATIOS
+  ),
+  createAspectRatioImageModel(
+    'fireworks',
+    'accounts/fireworks/models/flux-1-schnell-fp8',
+    'FLUX 1 Schnell FP8',
+    FIREWORKS_FLUX_ASPECT_RATIOS
+  ),
+  createSizeImageModel(
+    'fireworks',
+    'accounts/fireworks/models/playground-v2-5-1024px-aesthetic',
+    'Playground V2.5 1024px Aesthetic',
+    FIREWORKS_1024_SIZES,
+    '1024x1024'
+  ),
+  createSizeImageModel(
+    'fireworks',
+    'accounts/fireworks/models/japanese-stable-diffusion-xl',
+    'Japanese Stable Diffusion XL',
+    FIREWORKS_1024_SIZES,
+    '1024x1024'
+  ),
+  createSizeImageModel(
+    'fireworks',
+    'accounts/fireworks/models/playground-v2-1024px-aesthetic',
+    'Playground V2 1024px Aesthetic',
+    FIREWORKS_1024_SIZES,
+    '1024x1024'
+  ),
+  createSizeImageModel(
+    'fireworks',
+    'accounts/fireworks/models/SSD-1B',
+    'SSD-1B',
+    FIREWORKS_1024_SIZES,
+    '1024x1024'
+  ),
+  createSizeImageModel(
+    'fireworks',
+    'accounts/fireworks/models/stable-diffusion-xl-1024-v1-0',
+    'Stable Diffusion XL 1024 v1.0',
+    FIREWORKS_1024_SIZES,
+    '1024x1024'
+  ),
+
+  // Luma
+  createAspectRatioImageModel('luma', 'photon-1', 'Photon 1'),
+  createAspectRatioImageModel('luma', 'photon-flash-1', 'Photon Flash 1'),
+
+  // Together.ai
+  createSizeImageModel(
+    'togetherai',
+    'stabilityai/stable-diffusion-xl-base-1.0',
+    'Stable Diffusion XL Base 1.0',
+    TOGETHERAI_SQUARE_SIZES,
+    '1024x1024'
+  ),
+  createSizeImageModel(
+    'togetherai',
+    'black-forest-labs/FLUX.1-dev',
+    'FLUX.1 Dev',
+    TOGETHERAI_SQUARE_SIZES,
+    '1024x1024'
+  ),
+  createSizeImageModel(
+    'togetherai',
+    'black-forest-labs/FLUX.1-dev-lora',
+    'FLUX.1 Dev LoRA',
+    TOGETHERAI_SQUARE_SIZES,
+    '1024x1024'
+  ),
+  createSizeImageModel(
+    'togetherai',
+    'black-forest-labs/FLUX.1-schnell',
+    'FLUX.1 Schnell',
+    TOGETHERAI_SQUARE_SIZES,
+    '1024x1024'
+  ),
+  createSizeImageModel(
+    'togetherai',
+    'black-forest-labs/FLUX.1-canny',
+    'FLUX.1 Canny',
+    TOGETHERAI_SQUARE_SIZES,
+    '1024x1024'
+  ),
+  createSizeImageModel(
+    'togetherai',
+    'black-forest-labs/FLUX.1-depth',
+    'FLUX.1 Depth',
+    TOGETHERAI_SQUARE_SIZES,
+    '1024x1024'
+  ),
+  createSizeImageModel(
+    'togetherai',
+    'black-forest-labs/FLUX.1-redux',
+    'FLUX.1 Redux',
+    TOGETHERAI_SQUARE_SIZES,
+    '1024x1024'
+  ),
+  createSizeImageModel(
+    'togetherai',
+    'black-forest-labs/FLUX.1.1-pro',
+    'FLUX.1.1 Pro',
+    TOGETHERAI_SQUARE_SIZES,
+    '1024x1024'
+  ),
+  createSizeImageModel(
+    'togetherai',
+    'black-forest-labs/FLUX.1-pro',
+    'FLUX.1 Pro',
+    TOGETHERAI_SQUARE_SIZES,
+    '1024x1024'
+  ),
+  createSizeImageModel(
+    'togetherai',
+    'black-forest-labs/FLUX.1-schnell-Free',
+    'FLUX.1 Schnell Free',
+    TOGETHERAI_SQUARE_SIZES,
+    '1024x1024'
+  ),
+
+  // Black Forest Labs
+  createBflImageModel('flux-2-flex', 'FLUX.2 Flex'),
+  createBflImageModel('flux-2-klein-4b', 'FLUX.2 Klein 4B'),
+  createBflImageModel('flux-2-klein-9b', 'FLUX.2 Klein 9B'),
+  createBflImageModel('flux-2-max', 'FLUX.2 Max'),
+  createBflImageModel('flux-2-pro', 'FLUX.2 Pro'),
+  createBflImageModel('flux-kontext-pro', 'FLUX Kontext Pro'),
+  createBflImageModel('flux-kontext-max', 'FLUX Kontext Max'),
+  createBflImageModel('flux-pro-1.1-ultra', 'FLUX Pro 1.1 Ultra'),
+  createBflImageModel('flux-pro-1.1', 'FLUX Pro 1.1'),
+  createBflImageModel('flux-pro-1.0-fill', 'FLUX Pro 1.0 Fill'),
+
+  // Prodia
+  createAspectRatioImageModel(
+    'prodia',
+    'flux-fast-schnell',
+    'Flux Schnell',
+    REPLICATE_FLUX_SCHNELL_ASPECT_RATIOS
+  ),
+
+  // Recraft
+  createRecraftImageModel('recraft-v2', 'Recraft V2'),
+  createRecraftImageModel('recraft-v3', 'Recraft V3'),
+  createRecraftImageModel('recraft-v4', 'Recraft V4'),
+  createRecraftImageModel('recraft-v4-pro', 'Recraft V4 Pro'),
+];
diff --git a/packages/openapi/src/ai/image-model-config.spec.ts b/packages/openapi/src/ai/image-model-config.spec.ts
new file mode 100644
index 0000000000..24ce31629b
--- /dev/null
+++ b/packages/openapi/src/ai/image-model-config.spec.ts
@@ -0,0 +1,251 @@
+import { describe, expect, it } from 'vitest';
+import {
+  getImageAspectRatioCandidates,
+  getImageModelConfigByModelKey,
+  getImageModelConfigByGatewayId,
+  getImageModelIdFromModelKey,
+  getImageSizeCandidates,
+  getKnownImageModelAbility,
+  isPromptControlledImageGenerationModel,
+  supportsImageAspectRatioSelection,
+  supportsImageInputForImageModel,
+  supportsKnownImageInputForImageModel,
+  supportsImageSizeSelection,
+} from './image-model-config';
+
+const GPT_IMAGE_2_MODEL_ID = 'openai/gpt-image-2';
+const GPT_IMAGE_2_MODEL = 'gpt-image-2';
+const GPT_IMAGE_15_MODEL = 'gpt-image-1.5';
+const GPT_IMAGE_MINI_GATEWAY_MODEL_ID = 'openai/gpt-image-1-mini';
+const GPT_IMAGE_2_MODEL_KEY = `aiGateway@${GPT_IMAGE_2_MODEL_ID}@teable`;
+const GPT_IMAGE_2_DIRECT_MODEL_KEY = 'openai@gpt-image-2@OpenAI';
+const IMAGE_GENERATION_TAG = 'image-generation';
+const SIZE_1024 = '1024x1024';
+
+describe('getImageModelConfigByGatewayId', () => {
+  it('resolves provider-qualified gateway model IDs', () => {
+    expect(getImageModelConfigByGatewayId('google/imagen-4.0-generate-001')?.provider).toBe(
+      'google'
+    );
+    expect(getImageModelConfigByGatewayId('googleVertex/imagen-4.0-generate-001')?.provider).toBe(
+      'googleVertex'
+    );
+  });
+
+  it('resolves full model IDs that include provider-like path segments', () => {
+    expect(getImageModelConfigByGatewayId('fal-ai/flux/dev')?.provider).toBe('fal');
+  });
+
+  it('does not guess when a bare model ID is shared by multiple providers', () => {
+    expect(getImageModelConfigByGatewayId('imagen-4.0-generate-001')).toBeUndefined();
+  });
+
+  it('allows bare model ID fallback only when the catalog has a single matching model', () => {
+    expect(getImageModelConfigByGatewayId('gpt-image-1')?.provider).toBe('openai');
+  });
+
+  it('resolves newer GPT image model family entries', () => {
+    expect(getImageModelConfigByGatewayId(GPT_IMAGE_2_MODEL_ID)?.supportedSizes).toEqual([
+      SIZE_1024,
+      '1536x1024',
+      '1024x1536',
+      '2048x2048',
+      '2048x1152',
+      '3840x2160',
+      '2160x3840',
+    ]);
+    expect(getImageModelConfigByGatewayId('openai/gpt-image-1.5')?.provider).toBe('openai');
+    expect(getImageModelConfigByGatewayId('openai/gpt-image-1.5')?.supportedSizes).toEqual([
+      SIZE_1024,
+      '1536x1024',
+      '1024x1536',
+    ]);
+    expect(getImageModelConfigByGatewayId('openai/gpt-image-1-mini')?.provider).toBe('openai');
+  });
+
+  it('derives finite preset candidates from range-only size models', () => {
+    const config = getImageModelConfigByGatewayId('deepinfra/black-forest-labs/FLUX-1-dev');
+
+    expect(config).toBeDefined();
+    expect(getImageSizeCandidates(config!)).toEqual([
+      '256x256',
+      '512x512',
+      '768x768',
+      SIZE_1024,
+      '1024x768',
+      '1152x896',
+      '1216x832',
+      '1280x1024',
+      '1344x768',
+      '768x1344',
+      '832x1216',
+      '896x1152',
+      '1024x1280',
+      '1024x1344',
+    ]);
+  });
+
+  it('filters range-backed size candidates against provider constraints', () => {
+    const config = getImageModelConfigByGatewayId('amazonBedrock/amazon.nova-canvas-v1:0');
+
+    expect(config).toBeDefined();
+    expect(getImageSizeCandidates(config!)).not.toContain('256x256');
+    expect(getImageSizeCandidates(config!)).toContain('1024x768');
+    expect(getImageSizeCandidates(config!)).toContain('2048x1024');
+    expect(getImageAspectRatioCandidates(config!)).toContain('1:4');
+    expect(getImageAspectRatioCandidates(config!)).toContain('4:1');
+  });
+
+  it('uses explicit product aspect-ratio candidates for Gemini image language models', () => {
+    const config = getImageModelConfigByGatewayId('google/gemini-3-pro-image');
+
+    expect(config).toBeDefined();
+    expect(config?.defaultAspectRatio).toBeUndefined();
+    expect(getImageAspectRatioCandidates(config!)).toEqual([
+      '1:1',
+      '2:3',
+      '3:2',
+      '3:4',
+      '4:3',
+      '4:5',
+      '5:4',
+      '9:16',
+      '16:9',
+      '21:9',
+    ]);
+    expect(getImageAspectRatioCandidates(config!)).not.toContain('9:21');
+    expect(getImageAspectRatioCandidates(config!)).not.toContain('2:1');
+    expect(getImageAspectRatioCandidates(config!)).not.toContain('1:2');
+  });
+
+  it('resolves current AI Gateway image-generation catalog entries', () => {
+    const gatewayModelIds = [
+      'bfl/flux-2-flex',
+      'bfl/flux-2-klein-4b',
+      'bfl/flux-2-klein-9b',
+      'bfl/flux-2-max',
+      'bfl/flux-2-pro',
+      'bytedance/seedream-4.0',
+      'bytedance/seedream-4.5',
+      'bytedance/seedream-5.0-lite',
+      'google/gemini-3.1-flash-image-preview',
+      'prodia/flux-fast-schnell',
+      'recraft/recraft-v2',
+      'recraft/recraft-v3',
+      'recraft/recraft-v4',
+      'recraft/recraft-v4-pro',
+    ];
+
+    for (const modelId of gatewayModelIds) {
+      expect(getImageModelConfigByGatewayId(modelId), modelId).toBeDefined();
+    }
+
+    expect(getImageModelConfigByGatewayId('google/gemini-3.1-flash-image-preview')?.modelType).toBe(
+      'language'
+    );
+    expect(getImageModelConfigByGatewayId('bfl/flux-2-pro')?.modelType).toBe('image');
+    expect(getImageModelConfigByGatewayId('recraft/recraft-v4-pro')?.modelType).toBe('image');
+  });
+});
+
+describe('getImageModelConfigByModelKey', () => {
+  it('parses model keys consistently for gateway and direct providers', () => {
+    expect(getImageModelIdFromModelKey(GPT_IMAGE_2_MODEL_KEY)).toBe(GPT_IMAGE_2_MODEL_ID);
+    expect(getImageModelIdFromModelKey(GPT_IMAGE_2_DIRECT_MODEL_KEY)).toBe(GPT_IMAGE_2_MODEL_ID);
+  });
+
+  it('resolves direct provider model keys from the shared catalog', () => {
+    const resolved = getImageModelConfigByModelKey(GPT_IMAGE_2_DIRECT_MODEL_KEY);
+
+    expect(resolved?.config.provider).toBe('openai');
+    expect(getImageSizeCandidates(resolved!.config)).toEqual([
+      SIZE_1024,
+      '1536x1024',
+      '1024x1536',
+      '2048x2048',
+      '2048x1152',
+      '3840x2160',
+      '2160x3840',
+    ]);
+    expect(
+      supportsImageInputForImageModel(resolved!.config, resolved!.modelId, resolved!.tags)
+    ).toBe(true);
+  });
+
+  it('resolves gateway catalog models and keeps gateway tags available', () => {
+    const resolved = getImageModelConfigByModelKey(GPT_IMAGE_2_MODEL_KEY, [
+      {
+        id: GPT_IMAGE_2_MODEL_ID,
+        modelType: 'image',
+        tags: [IMAGE_GENERATION_TAG, 'vision'],
+      },
+    ]);
+
+    expect(resolved?.config.model).toBe(GPT_IMAGE_2_MODEL);
+    expect(resolved?.tags).toEqual([IMAGE_GENERATION_TAG, 'vision']);
+    expect(
+      supportsImageInputForImageModel(resolved!.config, resolved!.modelId, resolved!.tags)
+    ).toBe(true);
+  });
+
+  it('falls back to gateway language model metadata for prompt-controlled image generation', () => {
+    const resolved = getImageModelConfigByModelKey('aiGateway@google/gemini-future-image@teable', [
+      {
+        id: 'google/gemini-future-image',
+        modelType: 'language',
+        tags: [IMAGE_GENERATION_TAG],
+      },
+    ]);
+
+    expect(resolved?.config.modelType).toBe('language');
+    expect(isPromptControlledImageGenerationModel(resolved!.config)).toBe(true);
+    expect(supportsImageSizeSelection(resolved!.config)).toBe(false);
+    expect(supportsImageAspectRatioSelection(resolved!.config)).toBe(true);
+  });
+
+  it('falls back to gateway image model metadata with shared default size candidates', () => {
+    const resolved = getImageModelConfigByModelKey('aiGateway@custom/new-image-model@teable', [
+      {
+        id: 'custom/new-image-model',
+        modelType: 'image',
+      },
+    ]);
+
+    expect(resolved?.config.modelType).toBe('image');
+    expect(supportsImageSizeSelection(resolved!.config)).toBe(true);
+    expect(getImageSizeCandidates(resolved!.config)).toContain(SIZE_1024);
+  });
+});
+
+describe('supportsKnownImageInputForImageModel', () => {
+  it('uses the catalog for known direct and gateway image models', () => {
+    expect(supportsKnownImageInputForImageModel('openai', GPT_IMAGE_2_MODEL)).toBe(true);
+    expect(supportsKnownImageInputForImageModel('openai', GPT_IMAGE_15_MODEL)).toBe(true);
+    expect(supportsKnownImageInputForImageModel('aiGateway', GPT_IMAGE_MINI_GATEWAY_MODEL_ID)).toBe(
+      true
+    );
+  });
+
+  it('does not infer BYOK providers from bare model names', () => {
+    expect(supportsKnownImageInputForImageModel('openRouter', GPT_IMAGE_2_MODEL)).toBe(false);
+    expect(supportsKnownImageInputForImageModel('openaiCompatible', GPT_IMAGE_2_MODEL)).toBe(false);
+  });
+});
+
+describe('getKnownImageModelAbility', () => {
+  it('derives image generation ability from known catalog image models', () => {
+    expect(getKnownImageModelAbility('openai', GPT_IMAGE_2_MODEL)).toEqual({
+      generation: true,
+      imageToImage: true,
+    });
+    expect(getKnownImageModelAbility('openai', 'dall-e-3')).toEqual({
+      generation: true,
+      imageToImage: false,
+    });
+  });
+
+  it('does not infer custom BYOK provider abilities from bare model names', () => {
+    expect(getKnownImageModelAbility('openRouter', GPT_IMAGE_2_MODEL)).toBeUndefined();
+    expect(getKnownImageModelAbility('openaiCompatible', GPT_IMAGE_2_MODEL)).toBeUndefined();
+  });
+});
diff --git a/packages/openapi/src/ai/image-model-config.ts b/packages/openapi/src/ai/image-model-config.ts
index 62d77ddb81..b2580d6712 100644
--- a/packages/openapi/src/ai/image-model-config.ts
+++ b/packages/openapi/src/ai/image-model-config.ts
@@ -1,5 +1,40 @@
-/* eslint-disable sonarjs/no-duplicate-string */
 import { z } from 'zod';
+import type { IImageModelAbility } from '../admin';
+import { supportsImageInputForImageGeneration } from './image-generation-input-capability';
+import { IMAGE_MODEL_CONFIGS } from './image-model-catalog';
+import {
+  DEFAULT_IMAGE_SIZE_CANDIDATES,
+  getImageAspectRatioCandidates,
+  getImageSizeCandidates,
+} from './image-model-dimensions';
+import type { IImageModelConfig } from './image-model-types';
+export {
+  getImageGenerationInputMode,
+  ImageGenerationInputMode,
+  supportsImageEditPromptForImageGeneration,
+  supportsImageInputForImageGeneration,
+} from './image-generation-input-capability';
+export { IMAGE_MODEL_CONFIGS } from './image-model-catalog';
+export {
+  DEFAULT_ASPECT_RATIO_CANDIDATES,
+  DEFAULT_IMAGE_SIZE_CANDIDATES,
+  aspectRatioToSize,
+  aspectRatioSchema,
+  getDefaultImageDimension,
+  getImageAspectRatioCandidates,
+  getImageSizeCandidates,
+  imageSizeSchema,
+  isAspectRatioSupported,
+  isImageSizeSupported,
+} from './image-model-dimensions';
+export type {
+  IAspectRatio,
+  IDefaultImageDimensionConfig,
+  IImageAspectRatioRange,
+  IImageSize,
+  IImageSizeRange,
+} from './image-model-dimensions';
+export type { IImageModelConfig } from './image-model-types';
 
 /**
  * Image Model Configuration
@@ -8,65 +43,6 @@ import { z } from 'zod';
  * This config provides standardized image generation parameters for different providers and models.
  */
 
-// Supported image sizes (width x height)
-export const imageSizeSchema = z.enum([
-  // Common sizes
-  '256x256',
-  '512x512',
-  '768x768',
-  '1024x1024',
-  // Wide sizes
-  '1024x768',
-  '1152x896',
-  '1216x832',
-  '1280x1024',
-  '1344x768',
-  '1365x1024',
-  '1434x1024',
-  '1536x640',
-  '1536x1024',
-  '1707x1024',
-  '1792x1024',
-  '1820x1024',
-  '2048x1024',
-  // Tall sizes
-  '768x1344',
-  '832x1216',
-  '896x1152',
-  '640x1536',
-  '1024x1280',
-  '1024x1344',
-  '1024x1365',
-  '1024x1434',
-  '1024x1536',
-  '1024x1707',
-  '1024x1792',
-  '1024x1820',
-  '1024x2048',
-]);
-
-export type IImageSize = z.infer<typeof imageSizeSchema>;
-
-// Supported aspect ratios (width : height)
-export const aspectRatioSchema = z.enum([
-  '1:1',
-  '2:3',
-  '3:2',
-  '3:4',
-  '4:3',
-  '4:5',
-  '5:4',
-  '9:16',
-  '16:9',
-  '9:21',
-  '21:9',
-  '1:9',
-  '3:7',
-  '7:3',
-]);
-
-export type IAspectRatio = z.infer<typeof aspectRatioSchema>;
-
 // Image quality options
 export const imageQualitySchema = z.enum(['standard', 'hd', 'low', 'medium', 'high', 'ultra']);
 
@@ -77,164 +53,8 @@ export const imageStyleSchema = z.enum(['vivid', 'natural']);
 
 export type IImageStyle = z.infer<typeof imageStyleSchema>;
 
-/**
- * Image model configuration interface
- */
-export interface IImageModelConfig {
-  /** Provider name */
-  provider: string;
-  /** Model ID */
-  model: string;
-  /** Display name */
-  displayName?: string;
-  /** Whether the model uses sizes or aspect ratios */
-  sizeType: 'size' | 'aspectRatio' | 'both' | 'flexible';
-  /** Supported sizes (if sizeType is 'size' or 'both') */
-  supportedSizes?: IImageSize[];
-  /** Supported aspect ratios (if sizeType is 'aspectRatio' or 'both') */
-  supportedAspectRatios?: IAspectRatio[];
-  /** Default size */
-  defaultSize?: IImageSize;
-  /** Default aspect ratio */
-  defaultAspectRatio?: IAspectRatio;
-  /** Maximum images per call */
-  maxImagesPerCall?: number;
-  /** Whether the model supports quality parameter */
-  supportsQuality?: boolean;
-  /** Whether the model supports style parameter */
-  supportsStyle?: boolean;
-  /** Whether the model supports seed parameter */
-  supportsSeed?: boolean;
-  /** Model type: 'image' for pure image models, 'language' for multimodal LLMs */
-  modelType: 'image' | 'language';
-  /** Tags for additional capabilities */
-  tags?: string[];
-  /** Additional notes */
-  notes?: string;
-}
-
-/**
- * Standard aspect ratios used by most models
- */
-export const STANDARD_ASPECT_RATIOS: IAspectRatio[] = [
-  '1:1',
-  '3:4',
-  '4:3',
-  '9:16',
-  '16:9',
-  '9:21',
-  '21:9',
-];
-
-/**
- * Extended aspect ratios (includes portrait/landscape variants)
- */
-export const EXTENDED_ASPECT_RATIOS: IAspectRatio[] = [
-  '1:1',
-  '2:3',
-  '3:2',
-  '3:4',
-  '4:3',
-  '4:5',
-  '5:4',
-  '9:16',
-  '16:9',
-  '9:21',
-  '21:9',
-];
-
-/**
- * Image model configurations by provider
- * Based on: https://ai-sdk.dev/docs/ai-sdk-core/image-generation#image-models
- */
-export const IMAGE_MODEL_CONFIGS: IImageModelConfig[] = [
-  // xAI Grok
-  {
-    provider: 'xai',
-    model: 'grok-2-image',
-    displayName: 'Grok 2 Image',
-    sizeType: 'size',
-    supportedSizes: ['1024x768'],
-    defaultSize: '1024x768',
-    modelType: 'image',
-  },
-
-  // OpenAI
-  {
-    provider: 'openai',
-    model: 'gpt-image-1',
-    displayName: 'GPT Image 1',
-    sizeType: 'size',
-    supportedSizes: ['1024x1024', '1536x1024', '1024x1536'],
-    defaultSize: '1024x1024',
-    supportsQuality: true,
-    supportsStyle: true,
-    modelType: 'image',
-  },
-  {
-    provider: 'openai',
-    model: 'dall-e-3',
-    displayName: 'DALL-E 3',
-    sizeType: 'size',
-    supportedSizes: ['1024x1024', '1792x1024', '1024x1792'],
-    defaultSize: '1024x1024',
-    maxImagesPerCall: 1,
-    supportsQuality: true,
-    supportsStyle: true,
-    supportsSeed: true,
-    modelType: 'image',
-  },
-  {
-    provider: 'openai',
-    model: 'dall-e-2',
-    displayName: 'DALL-E 2',
-    sizeType: 'size',
-    supportedSizes: ['256x256', '512x512', '1024x1024'],
-    defaultSize: '1024x1024',
-    maxImagesPerCall: 10,
-    modelType: 'image',
-  },
-
-  // Google (Multimodal LLMs with image generation capability)
-  {
-    provider: 'google',
-    model: 'gemini-2.5-flash-image-preview',
-    displayName: 'Gemini 2.5 Flash Image Preview',
-    sizeType: 'flexible',
-    defaultSize: '1024x1024',
-    modelType: 'language',
-    tags: ['image-generation'],
-    notes: 'Multimodal LLM with image generation via generateText',
-  },
-  {
-    provider: 'google',
-    model: 'gemini-3-pro-image',
-    displayName: 'Gemini 3 Pro Image',
-    sizeType: 'flexible',
-    modelType: 'language',
-    tags: ['image-generation'],
-    notes: 'Multimodal LLM with image generation via generateText',
-  },
-  // Google Imagen
-  {
-    provider: 'google',
-    model: 'imagen-4.0-generate-001',
-    displayName: 'Imagen 4.0',
-    sizeType: 'aspectRatio',
-    supportedAspectRatios: ['1:1', '3:4', '4:3', '9:16', '16:9'],
-    defaultAspectRatio: '1:1',
-    modelType: 'image',
-  },
-  {
-    provider: 'google',
-    model: 'imagen-4.0-fast-generate-001',
-    displayName: 'Imagen 4.0 Fast',
-    sizeType: 'aspectRatio',
-    supportedAspectRatios: ['1:1', '3:4', '4:3', '9:16', '16:9'],
-    defaultAspectRatio: '1:1',
-    modelType: 'image',
-  },
-];
+const AI_GATEWAY_MODEL_KEY_TYPE = 'aiGateway';
+const IMAGE_GENERATION_TAG = 'image-generation';
 
 /**
  * Get image model config by provider and model
@@ -246,6 +66,11 @@ export function getImageModelConfig(
   return IMAGE_MODEL_CONFIGS.find((c) => c.provider === provider && c.model === model);
 }
 
+const getUniqueImageModelConfigByModel = (model: string): IImageModelConfig | undefined => {
+  const matches = IMAGE_MODEL_CONFIGS.filter((c) => c.model === model);
+  return matches.length === 1 ? matches[0] : undefined;
+};
+
 /**
  * Get image model config by model ID (for gateway models like "google/gemini-2.5-flash-image-preview")
  */
@@ -254,9 +79,26 @@ export function getImageModelConfigByGatewayId(
 ): IImageModelConfig | undefined {
   const [provider, ...modelParts] = gatewayModelId.split('/');
   const model = modelParts.join('/');
+
+  if (!model) {
+    return getUniqueImageModelConfigByModel(gatewayModelId);
+  }
+
+  const providerModelMatch = IMAGE_MODEL_CONFIGS.find(
+    (c) => c.provider === provider && c.model === model
+  );
+  if (providerModelMatch) {
+    return providerModelMatch;
+  }
+
+  const fullModelIdMatch = IMAGE_MODEL_CONFIGS.find((c) => c.model === gatewayModelId);
+  if (fullModelIdMatch) {
+    return fullModelIdMatch;
+  }
+
+  // Only fall back to bare model IDs when the catalog has a single owner for that model.
   return (
-    IMAGE_MODEL_CONFIGS.find((c) => c.provider === provider && c.model === model) ||
-    IMAGE_MODEL_CONFIGS.find((c) => c.model === gatewayModelId || c.model === model)
+    getUniqueImageModelConfigByModel(model) ?? getUniqueImageModelConfigByModel(gatewayModelId)
   );
 }
 
@@ -279,56 +121,200 @@ export function getPureImageModels(): IImageModelConfig[] {
  */
 export function getMultimodalImageModels(): IImageModelConfig[] {
   return IMAGE_MODEL_CONFIGS.filter(
-    (c) => c.modelType === 'language' && c.tags?.includes('image-generation')
+    (c) => c.modelType === 'language' && c.tags?.includes(IMAGE_GENERATION_TAG)
   );
 }
 
 /**
  * Check if a model supports image generation
  */
-export function supportsImageGeneration(modelType?: string, tags?: string[]): boolean {
+export function supportsImageGeneration(modelType?: string, tags?: readonly string[]): boolean {
   if (modelType === 'image') return true;
-  if (modelType === 'language' && tags?.includes('image-generation')) return true;
+  if (modelType === 'language' && tags?.includes(IMAGE_GENERATION_TAG)) return true;
   return false;
 }
 
-/**
- * Get default size or aspect ratio for a model
- */
-export function getDefaultImageDimension(config: IImageModelConfig): {
-  size?: IImageSize;
-  aspectRatio?: IAspectRatio;
-} {
-  if (config.defaultSize) {
-    return { size: config.defaultSize };
+export interface IImageModelMetadata {
+  id: string;
+  type?: string;
+  modelType?: string;
+  tags?: readonly string[];
+}
+
+export interface IResolvedImageModelConfig {
+  config: IImageModelConfig;
+  modelId: string;
+  tags: string[];
+}
+
+const mergeTags = (...tagGroups: Array<readonly string[] | undefined>): string[] => [
+  ...new Set(tagGroups.flatMap((tags) => tags ?? [])),
+];
+
+const splitModelId = (modelId: string): Pick<IImageModelConfig, 'provider' | 'model'> => {
+  const [provider, ...modelParts] = modelId.split('/');
+  const model = modelParts.join('/');
+
+  if (!provider || !model) {
+    return { provider: 'custom', model: modelId };
   }
-  if (config.defaultAspectRatio) {
-    return { aspectRatio: config.defaultAspectRatio };
+
+  return { provider, model };
+};
+
+const createGenericImageModelConfig = (
+  modelId: string,
+  tags: readonly string[] = []
+): IImageModelConfig => ({
+  ...splitModelId(modelId),
+  displayName: modelId,
+  sizeType: 'size',
+  supportedSizes: DEFAULT_IMAGE_SIZE_CANDIDATES,
+  defaultSize: '1024x1024',
+  supportsQuality: true,
+  modelType: 'image',
+  tags: mergeTags(tags),
+});
+
+const createPromptControlledImageModelConfig = (
+  modelId: string,
+  tags: readonly string[] = []
+): IImageModelConfig => ({
+  ...splitModelId(modelId),
+  displayName: modelId,
+  sizeType: 'flexible',
+  modelType: 'language',
+  tags: mergeTags(tags, [IMAGE_GENERATION_TAG]),
+});
+
+const getModelTypeFromMetadata = (metadata?: IImageModelMetadata) =>
+  metadata?.modelType ?? metadata?.type;
+
+const getLegacyImageModelConfig = (modelId: string): IImageModelConfig | undefined => {
+  if (modelId.toLowerCase().includes('gemini')) {
+    return createPromptControlledImageModelConfig(modelId);
   }
-  return { size: '1024x1024' };
+  return undefined;
+};
+
+export function getImageModelIdFromModelKey(modelKey?: string): string | undefined {
+  if (!modelKey) return undefined;
+
+  const [type, model] = modelKey.split('@');
+  if (!type || !model) return undefined;
+
+  return type === AI_GATEWAY_MODEL_KEY_TYPE ? model : `${type}/${model}`;
 }
 
-/**
- * Convert aspect ratio to approximate size
- */
-export function aspectRatioToSize(aspectRatio: IAspectRatio, baseSize = 1024): IImageSize {
-  const [widthRatio, heightRatio] = aspectRatio.split(':').map(Number);
-  const ratio = widthRatio / heightRatio;
-
-  let width: number;
-  let height: number;
-
-  if (ratio >= 1) {
-    width = baseSize;
-    height = Math.round(baseSize / ratio);
-  } else {
-    height = baseSize;
-    width = Math.round(baseSize * ratio);
+export function getImageModelCatalogId(config: Pick<IImageModelConfig, 'provider' | 'model'>) {
+  return `${config.provider}/${config.model}`;
+}
+
+export function isPromptControlledImageGenerationModel(config: IImageModelConfig): boolean {
+  return config.modelType === 'language' && (config.tags?.includes(IMAGE_GENERATION_TAG) ?? false);
+}
+
+export function supportsImageSizeSelection(config: IImageModelConfig): boolean {
+  return (
+    config.modelType === 'image' &&
+    ['size', 'both', 'flexible'].includes(config.sizeType) &&
+    getImageSizeCandidates(config).length > 0
+  );
+}
+
+export function supportsImageAspectRatioSelection(config: IImageModelConfig): boolean {
+  return (
+    isPromptControlledImageGenerationModel(config) ||
+    (['aspectRatio', 'both', 'flexible'].includes(config.sizeType) &&
+      getImageAspectRatioCandidates(config).length > 0)
+  );
+}
+
+export function supportsImageCountSelection(config: IImageModelConfig): boolean {
+  return config.maxImagesPerCall !== 1;
+}
+
+export function supportsImageInputForImageModel(
+  config: IImageModelConfig,
+  modelId = getImageModelCatalogId(config),
+  tags: readonly string[] = config.tags ?? []
+): boolean {
+  return (
+    isPromptControlledImageGenerationModel(config) ||
+    supportsImageInputForImageGeneration(modelId, tags)
+  );
+}
+
+export function supportsKnownImageInputForImageModel(
+  providerType: string | undefined,
+  model: string | undefined
+): boolean {
+  if (!providerType || !model) return false;
+
+  const config =
+    providerType === AI_GATEWAY_MODEL_KEY_TYPE
+      ? getImageModelConfigByGatewayId(model)
+      : getImageModelConfig(providerType, model);
+  if (!config) return false;
+
+  return supportsImageInputForImageModel(config, getImageModelCatalogId(config), config.tags);
+}
+
+export function getKnownImageModelAbility(
+  providerType: string | undefined,
+  model: string | undefined
+): IImageModelAbility | undefined {
+  if (!providerType || !model) return undefined;
+
+  const config =
+    providerType === AI_GATEWAY_MODEL_KEY_TYPE
+      ? getImageModelConfigByGatewayId(model)
+      : getImageModelConfig(providerType, model);
+  if (!config || !supportsImageGeneration(config.modelType, config.tags)) return undefined;
+
+  return {
+    generation: true,
+    imageToImage: supportsImageInputForImageModel(
+      config,
+      getImageModelCatalogId(config),
+      config.tags
+    ),
+  };
+}
+
+export function getImageModelConfigByModelKey(
+  modelKey?: string,
+  gatewayModels: readonly IImageModelMetadata[] = []
+): IResolvedImageModelConfig | undefined {
+  const modelId = getImageModelIdFromModelKey(modelKey);
+  if (!modelId) return undefined;
+
+  const gatewayModel = gatewayModels.find((model) => model.id === modelId);
+  const gatewayTags = gatewayModel?.tags ?? [];
+  const catalogConfig = getImageModelConfigByGatewayId(modelId);
+  if (catalogConfig) {
+    const tags = mergeTags(catalogConfig.tags, gatewayTags);
+    const config = { ...catalogConfig, tags };
+    return { config, modelId: getImageModelCatalogId(config), tags };
+  }
+
+  const gatewayModelType = getModelTypeFromMetadata(gatewayModel);
+  if (gatewayModelType === 'language' && gatewayTags.includes(IMAGE_GENERATION_TAG)) {
+    const config = createPromptControlledImageModelConfig(modelId, gatewayTags);
+    return { config, modelId: getImageModelCatalogId(config), tags: config.tags ?? [] };
+  }
+
+  if (gatewayModelType === 'image') {
+    const config = createGenericImageModelConfig(modelId, gatewayTags);
+    return { config, modelId: getImageModelCatalogId(config), tags: config.tags ?? [] };
   }
 
-  // Round to nearest multiple of 64 (common requirement for image models)
-  width = Math.round(width / 64) * 64;
-  height = Math.round(height / 64) * 64;
+  const legacyConfig = getLegacyImageModelConfig(modelId);
+  if (!legacyConfig) return undefined;
 
-  return `${width}x${height}` as IImageSize;
+  return {
+    config: legacyConfig,
+    modelId: getImageModelCatalogId(legacyConfig),
+    tags: legacyConfig.tags ?? [],
+  };
 }
diff --git a/packages/openapi/src/ai/image-model-dimensions.ts b/packages/openapi/src/ai/image-model-dimensions.ts
new file mode 100644
index 0000000000..963837b108
--- /dev/null
+++ b/packages/openapi/src/ai/image-model-dimensions.ts
@@ -0,0 +1,475 @@
+import { z } from 'zod';
+
+/**
+ * Full set of image-size literals that Teable's image model catalog can reference.
+ *
+ * Keep provider/model presets below as subsets of this tuple. Do not add `auto`
+ * here: `auto` is a provider behavior, represented by omitting the size option.
+ */
+export const ALL_IMAGE_SIZES = [
+  // Square/common sizes.
+  '256x256',
+  '512x512',
+  '768x768',
+  '1024x1024',
+  '2048x2048',
+  // Landscape sizes.
+  '1024x768',
+  '1152x896',
+  '1216x832',
+  '1280x1024',
+  '1344x768',
+  '1365x1024',
+  '1434x1024',
+  '1536x640',
+  '1536x1024',
+  '1707x1024',
+  '1792x1024',
+  '1820x1024',
+  '2048x1024',
+  '2048x1152',
+  '3840x2160',
+  // Portrait sizes.
+  '768x1344',
+  '832x1216',
+  '896x1152',
+  '640x1536',
+  '1024x1280',
+  '1024x1344',
+  '1024x1365',
+  '1024x1434',
+  '1024x1536',
+  '1024x1707',
+  '1024x1792',
+  '1024x1820',
+  '1024x2048',
+  '2160x3840',
+] as const;
+
+export const imageSizeSchema = z.enum(ALL_IMAGE_SIZES);
+
+export type IImageSize = z.infer<typeof imageSizeSchema>;
+
+/**
+ * Full set of aspect-ratio literals accepted by catalog presets and range fallbacks.
+ *
+ * Keep this list provider-neutral. Provider-specific subsets belong in the preset
+ * constants below. `auto` is intentionally excluded for the same reason as sizes.
+ */
+export const ALL_ASPECT_RATIOS = [
+  '1:1',
+  '2:3',
+  '3:2',
+  '3:4',
+  '4:3',
+  '4:5',
+  '5:4',
+  '9:16',
+  '16:9',
+  '9:21',
+  '21:9',
+  '1:9',
+  '2:1',
+  '1:2',
+  '19.5:9',
+  '9:19.5',
+  '20:9',
+  '9:20',
+  '1:4',
+  '4:1',
+  '3:7',
+  '7:3',
+] as const;
+
+export const aspectRatioSchema = z.enum(ALL_ASPECT_RATIOS);
+
+export type IAspectRatio = z.infer<typeof aspectRatioSchema>;
+
+export interface IImageSizeRange {
+  min: number;
+  max: number;
+  multipleOf?: number;
+  maxPixels?: number;
+  notes?: string;
+}
+
+export interface IImageAspectRatioRange {
+  min: IAspectRatio;
+  max: IAspectRatio;
+  notes?: string;
+}
+
+export interface IDefaultImageDimensionConfig {
+  defaultSize?: IImageSize;
+  defaultAspectRatio?: IAspectRatio;
+}
+
+export interface IImageDimensionConstraintConfig {
+  supportedSizes?: IImageSize[];
+  supportedAspectRatios?: IAspectRatio[];
+  sizeRange?: IImageSizeRange;
+  aspectRatioRange?: IImageAspectRatioRange;
+}
+
+const imageSizePattern = /^\d+x\d+$/;
+const aspectRatioPattern = /^\d+(?:\.\d+)?:\d+(?:\.\d+)?$/;
+
+/**
+ * Conservative fallback sizes shown for generic or unknown size-based image models.
+ */
+export const DEFAULT_IMAGE_SIZE_CANDIDATES = [
+  '256x256',
+  '512x512',
+  '768x768',
+  '1024x1024',
+  '1536x1024',
+  '1024x1536',
+  '1792x1024',
+  '1024x1792',
+] satisfies IImageSize[];
+
+/**
+ * Finite UI candidates used when a provider exposes a numeric size range.
+ *
+ * The range validator still decides which of these candidates apply to a model.
+ */
+export const RANGE_IMAGE_SIZE_CANDIDATES = [
+  ...DEFAULT_IMAGE_SIZE_CANDIDATES,
+  '1024x768',
+  '1152x896',
+  '1216x832',
+  '1280x1024',
+  '1344x768',
+  '1365x1024',
+  '1434x1024',
+  '1536x640',
+  '1707x1024',
+  '1820x1024',
+  '2048x1024',
+  '768x1344',
+  '832x1216',
+  '896x1152',
+  '640x1536',
+  '1024x1280',
+  '1024x1344',
+  '1024x1365',
+  '1024x1434',
+  '1024x1707',
+  '1024x1820',
+  '1024x2048',
+] satisfies IImageSize[];
+
+/**
+ * Fallback aspect-ratio candidates for range-backed models and generic UI state.
+ *
+ * This name is kept for compatibility with existing imports; it is not a model
+ * default. Specific models should prefer explicit provider presets below.
+ */
+export const DEFAULT_ASPECT_RATIO_CANDIDATES = [
+  '1:1',
+  '16:9',
+  '9:16',
+  '4:3',
+  '3:4',
+  '21:9',
+  '9:21',
+  '3:2',
+  '2:3',
+  '2:1',
+  '1:2',
+  '1:4',
+  '4:1',
+] satisfies IAspectRatio[];
+
+/**
+ * Common aspect-ratio preset used by providers where the catalog does not need
+ * a more specific product subset.
+ */
+export const STANDARD_ASPECT_RATIOS = [
+  '1:1',
+  '3:4',
+  '4:3',
+  '9:16',
+  '16:9',
+  '9:21',
+  '21:9',
+] satisfies IAspectRatio[];
+
+/**
+ * Wider common preset that includes additional portrait/landscape pairs.
+ */
+export const EXTENDED_ASPECT_RATIOS = [
+  '1:1',
+  '2:3',
+  '3:2',
+  '3:4',
+  '4:3',
+  '4:5',
+  '5:4',
+  '9:16',
+  '16:9',
+  '9:21',
+  '21:9',
+] satisfies IAspectRatio[];
+
+/**
+ * OpenAI uses concrete size literals for pure image models. `auto` is handled as
+ * a separate provider option when/if the product exposes it.
+ */
+export const OPENAI_GPT_IMAGE_SIZES = [
+  '1024x1024',
+  '1536x1024',
+  '1024x1536',
+] satisfies IImageSize[];
+export const OPENAI_GPT_IMAGE_2_SIZES = [
+  ...OPENAI_GPT_IMAGE_SIZES,
+  '2048x2048',
+  '2048x1152',
+  '3840x2160',
+  '2160x3840',
+] satisfies IImageSize[];
+export const OPENAI_DALLE3_SIZES = ['1024x1024', '1792x1024', '1024x1792'] satisfies IImageSize[];
+export const OPENAI_DALLE2_SIZES = ['256x256', '512x512', '1024x1024'] satisfies IImageSize[];
+
+export const GOOGLE_IMAGEN_ASPECT_RATIOS = [
+  '1:1',
+  '3:4',
+  '4:3',
+  '9:16',
+  '16:9',
+] satisfies IAspectRatio[];
+
+/**
+ * Product-facing Gemini subset.
+ *
+ * The local AI SDK also accepts extreme ratios such as 1:8, 8:1, 1:4, and 4:1
+ * for Gemini imageConfig. They are intentionally omitted until the product needs
+ * ultra-long images.
+ */
+export const GEMINI_IMAGE_ASPECT_RATIOS = [
+  '1:1',
+  '2:3',
+  '3:2',
+  '3:4',
+  '4:3',
+  '4:5',
+  '5:4',
+  '9:16',
+  '16:9',
+  '21:9',
+] satisfies IAspectRatio[];
+
+export const XAI_GROK_ASPECT_RATIOS = [
+  '1:1',
+  '16:9',
+  '9:16',
+  '4:3',
+  '3:4',
+  '3:2',
+  '2:3',
+  '2:1',
+  '1:2',
+  '19.5:9',
+  '9:19.5',
+  '20:9',
+  '9:20',
+] satisfies IAspectRatio[];
+
+export const DEEPINFRA_STABILITY_ASPECT_RATIOS = [
+  '1:1',
+  '16:9',
+  '1:9',
+  '3:2',
+  '2:3',
+  '4:5',
+  '5:4',
+  '9:16',
+  '9:21',
+] satisfies IAspectRatio[];
+
+/**
+ * Shared FLUX aspect-ratio preset used by providers that expose the same list.
+ */
+export const FLUX_ASPECT_RATIOS = [
+  '1:1',
+  '2:3',
+  '3:2',
+  '4:5',
+  '5:4',
+  '16:9',
+  '9:16',
+  '9:21',
+  '21:9',
+] satisfies IAspectRatio[];
+
+export const REPLICATE_FLUX_SCHNELL_ASPECT_RATIOS = FLUX_ASPECT_RATIOS;
+
+export const REPLICATE_RECRAFT_SIZES = [
+  '1024x1024',
+  '1365x1024',
+  '1024x1365',
+  '1536x1024',
+  '1024x1536',
+  '1820x1024',
+  '1024x1820',
+  '1024x2048',
+  '2048x1024',
+  '1434x1024',
+  '1024x1434',
+  '1024x1280',
+  '1280x1024',
+  '1024x1707',
+  '1707x1024',
+] satisfies IImageSize[];
+
+export const FIREWORKS_FLUX_ASPECT_RATIOS = FLUX_ASPECT_RATIOS;
+
+export const FIREWORKS_1024_SIZES = [
+  '640x1536',
+  '768x1344',
+  '832x1216',
+  '896x1152',
+  '1024x1024',
+  '1152x896',
+  '1216x832',
+  '1344x768',
+  '1536x640',
+] satisfies IImageSize[];
+
+export const TOGETHERAI_SQUARE_SIZES = ['512x512', '768x768', '1024x1024'] satisfies IImageSize[];
+
+/**
+ * BFL supports both preset ratios and a continuous ratio range.
+ */
+export const BFL_ASPECT_RATIO_PRESETS = [
+  '3:7',
+  '2:3',
+  '3:4',
+  '1:1',
+  '4:3',
+  '3:2',
+  '7:3',
+] satisfies IAspectRatio[];
+
+export const BFL_ASPECT_RATIO_RANGE = {
+  min: '3:7',
+  max: '7:3',
+  notes: 'From 3:7 (portrait) to 7:3 (landscape)',
+} satisfies IImageAspectRatioRange;
+
+export const DIMENSION_RANGE_256_1440_MULTIPLE_32 = {
+  min: 256,
+  max: 1440,
+  multipleOf: 32,
+} satisfies IImageSizeRange;
+
+export function isImageSizeSupported(
+  config: IImageDimensionConstraintConfig,
+  size?: string
+): size is `${number}x${number}` {
+  if (!size || !imageSizePattern.test(size)) return false;
+
+  if (config.supportedSizes?.includes(size as IImageSize)) {
+    return true;
+  }
+
+  if (!config.sizeRange) return false;
+
+  const [width, height] = size.split('x').map(Number);
+  const { min, max, multipleOf, maxPixels } = config.sizeRange;
+
+  if (!width || !height || width < min || height < min || width > max || height > max) {
+    return false;
+  }
+  if (multipleOf && (width % multipleOf !== 0 || height % multipleOf !== 0)) {
+    return false;
+  }
+  if (maxPixels && width * height > maxPixels) {
+    return false;
+  }
+
+  return true;
+}
+
+const aspectRatioToNumber = (aspectRatio: string): number | undefined => {
+  const [width, height] = aspectRatio.split(':').map(Number);
+  if (!width || !height) return undefined;
+  return width / height;
+};
+
+export function isAspectRatioSupported(
+  config: IImageDimensionConstraintConfig,
+  aspectRatio?: string
+): aspectRatio is `${number}:${number}` {
+  if (!aspectRatio || !aspectRatioPattern.test(aspectRatio)) return false;
+
+  if (config.supportedAspectRatios?.includes(aspectRatio as IAspectRatio)) {
+    return true;
+  }
+
+  if (!config.aspectRatioRange) return false;
+
+  const ratio = aspectRatioToNumber(aspectRatio);
+  const minRatio = aspectRatioToNumber(config.aspectRatioRange.min);
+  const maxRatio = aspectRatioToNumber(config.aspectRatioRange.max);
+  if (!ratio || !minRatio || !maxRatio) return false;
+
+  return ratio >= minRatio && ratio <= maxRatio;
+}
+
+export function getImageSizeCandidates(config: IImageDimensionConstraintConfig): IImageSize[] {
+  if (config.supportedSizes?.length) return config.supportedSizes;
+  if (!config.sizeRange) return [];
+  return RANGE_IMAGE_SIZE_CANDIDATES.filter((size) => isImageSizeSupported(config, size));
+}
+
+export function getImageAspectRatioCandidates(
+  config: IImageDimensionConstraintConfig
+): IAspectRatio[] {
+  if (config.supportedAspectRatios?.length) return config.supportedAspectRatios;
+  if (!config.aspectRatioRange) return [];
+  return DEFAULT_ASPECT_RATIO_CANDIDATES.filter((aspectRatio) =>
+    isAspectRatioSupported(config, aspectRatio)
+  );
+}
+
+/**
+ * Get default size or aspect ratio for a model-like dimension config.
+ */
+export function getDefaultImageDimension(config: IDefaultImageDimensionConfig): {
+  size?: IImageSize;
+  aspectRatio?: IAspectRatio;
+} {
+  if (config.defaultSize) {
+    return { size: config.defaultSize };
+  }
+  if (config.defaultAspectRatio) {
+    return { aspectRatio: config.defaultAspectRatio };
+  }
+  return { size: '1024x1024' };
+}
+
+/**
+ * Convert aspect ratio to approximate size.
+ */
+export function aspectRatioToSize(aspectRatio: IAspectRatio, baseSize = 1024): IImageSize {
+  const [widthRatio, heightRatio] = aspectRatio.split(':').map(Number);
+  const ratio = widthRatio / heightRatio;
+
+  let width: number;
+  let height: number;
+
+  if (ratio >= 1) {
+    width = baseSize;
+    height = Math.round(baseSize / ratio);
+  } else {
+    height = baseSize;
+    width = Math.round(baseSize * ratio);
+  }
+
+  // Round to nearest multiple of 64 (common requirement for image models)
+  width = Math.round(width / 64) * 64;
+  height = Math.round(height / 64) * 64;
+
+  return `${width}x${height}` as IImageSize;
+}
diff --git a/packages/openapi/src/ai/image-model-types.ts b/packages/openapi/src/ai/image-model-types.ts
new file mode 100644
index 0000000000..07d403165e
--- /dev/null
+++ b/packages/openapi/src/ai/image-model-types.ts
@@ -0,0 +1,48 @@
+import type {
+  IAspectRatio,
+  IImageAspectRatioRange,
+  IImageSize,
+  IImageSizeRange,
+} from './image-model-dimensions';
+
+/**
+ * Image model configuration interface.
+ */
+export interface IImageModelConfig {
+  /** Provider name */
+  provider: string;
+  /** Model ID */
+  model: string;
+  /** Display name */
+  displayName?: string;
+  /** Whether the model uses sizes or aspect ratios */
+  sizeType: 'size' | 'aspectRatio' | 'both' | 'flexible';
+  /** Supported sizes (if sizeType is 'size' or 'both') */
+  supportedSizes?: IImageSize[];
+  /** Supported aspect ratios (if sizeType is 'aspectRatio' or 'both') */
+  supportedAspectRatios?: IAspectRatio[];
+  /** Whether the provider supports automatic aspect ratio selection */
+  supportsAutoAspectRatio?: boolean;
+  /** Supported size range for models that accept arbitrary dimensions */
+  sizeRange?: IImageSizeRange;
+  /** Supported aspect ratio range for models that accept arbitrary ratios */
+  aspectRatioRange?: IImageAspectRatioRange;
+  /** Default size */
+  defaultSize?: IImageSize;
+  /** Default aspect ratio */
+  defaultAspectRatio?: IAspectRatio;
+  /** Maximum images per call */
+  maxImagesPerCall?: number;
+  /** Whether the model supports quality parameter */
+  supportsQuality?: boolean;
+  /** Whether the model supports style parameter */
+  supportsStyle?: boolean;
+  /** Whether the model supports seed parameter */
+  supportsSeed?: boolean;
+  /** Model type: 'image' for pure image models, 'language' for multimodal LLMs */
+  modelType: 'image' | 'language';
+  /** Tags for additional capabilities */
+  tags?: string[];
+  /** Additional notes */
+  notes?: string;
+}
diff --git a/packages/openapi/src/base/get.ts b/packages/openapi/src/base/get.ts
index b72bd32800..b46f674fb2 100644
--- a/packages/openapi/src/base/get.ts
+++ b/packages/openapi/src/base/get.ts
@@ -7,6 +7,23 @@ import { z } from '../zod';
 
 export const GET_BASE = '/base/{baseId}';
 
+export const v2ReasonSchema = z.enum([
+  'env_force_v2_all',
+  'config_force_v2_all',
+  'new_base',
+  'header_override',
+  'space_feature',
+  'unsupported_feature',
+  'disabled',
+  'feature_not_enabled',
+  'no_feature',
+]);
+
+export const baseV2StatusSchema = z.object({
+  useV2: z.boolean(),
+  reason: v2ReasonSchema,
+});
+
 export const getBaseItemSchema = z.object({
   id: z.string(),
   name: z.string(),
@@ -33,11 +50,13 @@ export const getBaseItemSchema = z.object({
     })
     .optional(),
   isCanary: z.boolean().optional(),
+  v2Status: baseV2StatusSchema.optional(),
   isShared: z.boolean().optional(),
 });
 
 export const getBaseVoSchema = getBaseItemSchema;
 
+export type IBaseV2StatusVo = z.infer<typeof baseV2StatusSchema>;
 export type IGetBaseVo = z.infer<typeof getBaseVoSchema>;
 
 export const GetBaseRoute: RouteConfig = registerRoute({
diff --git a/packages/openapi/src/integrity/link-check.ts b/packages/openapi/src/integrity/link-check.ts
index 5145d48b2b..32abc79861 100644
--- a/packages/openapi/src/integrity/link-check.ts
+++ b/packages/openapi/src/integrity/link-check.ts
@@ -18,6 +18,9 @@ export enum IntegrityIssueType {
   UniqueIndexNotFound = 'UniqueIndexNotFound',
   EmptyString = 'EmptyString',
   InvalidFilterOperator = 'InvalidFilterOperator',
+  InvalidPrimaryLookup = 'InvalidPrimaryLookup',
+  InvalidPrimaryType = 'InvalidPrimaryType',
+  MissingPrimary = 'MissingPrimary',
 }
 
 // Define the schema for a single issue
diff --git a/packages/openapi/src/integrity/schema-v2.ts b/packages/openapi/src/integrity/schema-v2.ts
index f4eaa439db..b7dea4ba47 100644
--- a/packages/openapi/src/integrity/schema-v2.ts
+++ b/packages/openapi/src/integrity/schema-v2.ts
@@ -64,6 +64,14 @@ export const v2SchemaIntegrityDetailsSchema = z.object({
     )
     .optional(),
   statementCount: z.number().optional(),
+  statements: z
+    .array(
+      z.object({
+        sql: z.string(),
+        parameters: z.array(z.unknown()).optional(),
+      })
+    )
+    .optional(),
 });
 
 export const v2SchemaIntegrityI18nMessageSchema = z.object({
@@ -138,6 +146,7 @@ export const v2SchemaIntegrityCheckStatusSchema = z.enum([
 
 export const v2SchemaIntegrityCheckResultSchema = z.object({
   id: z.string(),
+  baseId: z.string().optional(),
   tableId: z.string().optional(),
   tableName: z.string().optional(),
   fieldId: z.string(),
@@ -174,6 +183,7 @@ export const v2SchemaIntegrityRepairOutcomeSchema = z.enum([
 
 export const v2SchemaIntegrityRepairResultSchema = z.object({
   id: z.string(),
+  baseId: z.string().optional(),
   tableId: z.string().optional(),
   tableName: z.string().optional(),
   fieldId: z.string(),
diff --git a/packages/sdk/src/components/ReadOnlyTip.tsx b/packages/sdk/src/components/ReadOnlyTip.tsx
index d51260e52c..ca101253b5 100644
--- a/packages/sdk/src/components/ReadOnlyTip.tsx
+++ b/packages/sdk/src/components/ReadOnlyTip.tsx
@@ -1,4 +1,4 @@
-import { Button, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@teable/ui-lib';
+import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@teable/ui-lib';
 
 import { Trans } from '../context/app/i18n';
 import { usePersonalView, useView } from '../hooks';
@@ -19,17 +19,16 @@ export const ReadOnlyTip = () => {
         <TooltipTrigger asChild>
           <div className={'absolute inset-0 z-50 cursor-not-allowed'} />
         </TooltipTrigger>
-        <TooltipContent>
-          <span className="text-xs">
+        <TooltipContent className="max-w-[360px]">
+          <span className="whitespace-normal break-words text-xs leading-normal">
             <Trans
               i18nKey="common.readOnlyTip"
               components={{
                 button: (
-                  <Button
-                    className="pl-1 text-xs text-secondary underline"
-                    size="xs"
+                  <button
+                    type="button"
+                    className="inline px-1 text-xs leading-normal text-secondary underline"
                     onClick={openPersonalView}
-                    variant="link"
                   />
                 ),
               }}
diff --git a/packages/sdk/src/components/editor/attachment/upload-attachment/AttachmentItem.tsx b/packages/sdk/src/components/editor/attachment/upload-attachment/AttachmentItem.tsx
index adea37e567..fbf731baf4 100644
--- a/packages/sdk/src/components/editor/attachment/upload-attachment/AttachmentItem.tsx
+++ b/packages/sdk/src/components/editor/attachment/upload-attachment/AttachmentItem.tsx
@@ -1,7 +1,7 @@
 import { useSortable } from '@dnd-kit/sortable';
 import { CSS } from '@dnd-kit/utilities';
 import type { IAttachmentItem } from '@teable/core';
-import { Download, Pencil, X } from '@teable/icons';
+import { Download, X } from '@teable/icons';
 import { Button, cn, FilePreviewItem, isImage } from '@teable/ui-lib';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { EllipsisFileName } from '../../../upload/EllipsisFileName';
@@ -99,46 +99,35 @@ function AttachmentItem(props: IUploadAttachment) {
               />
             )}
           </FilePreviewItem>
-          {!readonly && (
+          <div className="absolute inset-x-0 top-0 z-10 hidden items-center gap-1 rounded-t-lg bg-black/60 px-1.5 py-1 text-white group-hover:flex">
+            <span
+              className="mr-auto min-w-0 truncate text-xs"
+              title={formatFileSize(attachment.size)}
+            >
+              {formatFileSize(attachment.size)}
+            </span>
             <Button
               variant={'ghost'}
-              className="absolute right-1 top-1 z-10 hidden size-auto rounded-full bg-white/30 p-0.5 text-white hover:bg-white/50 focus-visible:ring-transparent focus-visible:ring-offset-0 group-hover:flex"
+              className="size-auto shrink-0 p-0 text-white hover:bg-white/20 hover:text-white focus-visible:ring-transparent focus-visible:ring-offset-0"
               onClick={(e) => {
                 e.stopPropagation();
-                onDelete(attachment.id);
+                downloadFile(attachment);
               }}
             >
-              <X className="size-3 shrink-0" />
+              <Download className="size-4 shrink-0" />
             </Button>
-          )}
-          <div className="pointer-events-none absolute inset-0 hidden flex-col items-center justify-center rounded-lg bg-black/70 group-hover:flex">
-            <div className="pointer-events-auto flex gap-4">
-              {!readonly && (
-                <Button
-                  variant={'ghost'}
-                  className="size-auto p-0 text-white hover:bg-white/20 hover:text-white focus-visible:ring-transparent focus-visible:ring-offset-0"
-                  onClick={(e) => {
-                    e.stopPropagation();
-                    handleStartEdit();
-                  }}
-                >
-                  <Pencil className="size-5 shrink-0" />
-                </Button>
-              )}
+            {!readonly && (
               <Button
                 variant={'ghost'}
-                className="size-auto p-0 text-white hover:bg-white/20 hover:text-white focus-visible:ring-transparent focus-visible:ring-offset-0"
+                className="size-auto shrink-0 p-0 text-white hover:bg-white/20 hover:text-white focus-visible:ring-transparent focus-visible:ring-offset-0"
                 onClick={(e) => {
                   e.stopPropagation();
-                  downloadFile(attachment);
+                  onDelete(attachment.id);
                 }}
               >
-                <Download className="size-5 shrink-0" />
+                <X className="size-4 shrink-0" />
               </Button>
-            </div>
-            <span className="absolute bottom-1 text-xs text-white/70">
-              {formatFileSize(attachment.size)}
-            </span>
+            )}
           </div>
         </div>
         {isEditing ? (
@@ -161,8 +150,8 @@ function AttachmentItem(props: IUploadAttachment) {
         ) : (
           <button
             type="button"
-            className={cn(!readonly && 'cursor-text')}
-            onClick={(e) => {
+            className={cn('w-full border border-transparent', !readonly && 'cursor-text')}
+            onDoubleClick={(e) => {
               e.stopPropagation();
               handleStartEdit();
             }}
diff --git a/packages/sdk/src/components/editor/attachment/utils.ts b/packages/sdk/src/components/editor/attachment/utils.ts
index 8f85406d0a..3829f65932 100644
--- a/packages/sdk/src/components/editor/attachment/utils.ts
+++ b/packages/sdk/src/components/editor/attachment/utils.ts
@@ -20,8 +20,8 @@ export const isSystemFileIcon = (mimetype: string) => {
 
 export function formatFileSize(bytes: number): string {
   if (bytes === 0) return '0B';
-  const units = ['B', 'k', 'M', 'G', 'T'];
-  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  const units = ['B', 'k', 'M', 'G', 'T', 'P', 'E'];
+  const i = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
   const value = bytes / Math.pow(1024, i);
   const formatted = value < 10 ? value.toFixed(1) : Math.round(value).toString();
   return `${formatted}${units[i]}`;
diff --git a/packages/sdk/src/components/editor/long-text/ExpandMarkdownEditor.spec.tsx b/packages/sdk/src/components/editor/long-text/ExpandMarkdownEditor.spec.tsx
new file mode 100644
index 0000000000..3f12ca32a5
--- /dev/null
+++ b/packages/sdk/src/components/editor/long-text/ExpandMarkdownEditor.spec.tsx
@@ -0,0 +1,69 @@
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+import { ExpandMarkdownEditor } from './ExpandMarkdownEditor';
+
+const openTextEditor = async () => {
+  fireEvent.click(screen.getByTitle('Expand editor'));
+  return screen.findByRole('textbox');
+};
+
+describe('ExpandMarkdownEditor', () => {
+  it('does not submit null when an unchanged blank editor blurs', async () => {
+    const onChange = vi.fn();
+
+    render(<ExpandMarkdownEditor value="" initialMode="text" onChange={onChange} />);
+
+    const editor = await openTextEditor();
+    fireEvent.blur(editor);
+
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  it('syncs an external value change while the expanded text editor is clean', async () => {
+    const onChange = vi.fn();
+    const { rerender } = render(
+      <ExpandMarkdownEditor value="" initialMode="text" onChange={onChange} />
+    );
+
+    const editor = await openTextEditor();
+    expect(editor).toHaveValue('');
+
+    rerender(<ExpandMarkdownEditor value="generated" initialMode="text" onChange={onChange} />);
+
+    await waitFor(() => {
+      expect(screen.getByRole('textbox')).toHaveValue('generated');
+    });
+
+    fireEvent.blur(screen.getByRole('textbox'));
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  it('submits null when a non-empty expanded text value is cleared', async () => {
+    const onChange = vi.fn();
+
+    render(<ExpandMarkdownEditor value="generated" initialMode="text" onChange={onChange} />);
+
+    const editor = await openTextEditor();
+    fireEvent.change(editor, { target: { value: '' } });
+    fireEvent.blur(editor);
+
+    expect(onChange).toHaveBeenCalledWith(null);
+  });
+
+  it('does not remount after its own committed value is reflected by the parent', async () => {
+    const onChange = vi.fn();
+    const { rerender } = render(
+      <ExpandMarkdownEditor value="" initialMode="text" onChange={onChange} />
+    );
+
+    const editor = await openTextEditor();
+    fireEvent.change(editor, { target: { value: 'manual' } });
+    fireEvent.blur(editor);
+
+    expect(onChange).toHaveBeenCalledWith('manual');
+
+    rerender(<ExpandMarkdownEditor value="manual" initialMode="text" onChange={onChange} />);
+
+    expect(screen.getByRole('textbox')).toBe(editor);
+  });
+});
diff --git a/packages/sdk/src/components/editor/long-text/ExpandMarkdownEditor.tsx b/packages/sdk/src/components/editor/long-text/ExpandMarkdownEditor.tsx
index 83d2a9f67f..538d5404a2 100644
--- a/packages/sdk/src/components/editor/long-text/ExpandMarkdownEditor.tsx
+++ b/packages/sdk/src/components/editor/long-text/ExpandMarkdownEditor.tsx
@@ -10,6 +10,16 @@ import { getEditorMarkdown, normalizeMarkdownValue } from './utils';
 
 type EditorMode = 'markdown' | 'text';
 
+const toCommitValue = (value: string): string | null => {
+  const trimmed = value.trim();
+  return trimmed || null;
+};
+
+const getChangedCommitValue = (value: string, initialValue: string): string | null | undefined => {
+  const nextValue = toCommitValue(value);
+  return nextValue === toCommitValue(initialValue) ? undefined : nextValue;
+};
+
 interface IExpandMarkdownEditorProps {
   value: string | null;
   field?: Field;
@@ -23,16 +33,34 @@ interface IExpandMarkdownEditorProps {
 const ExpandedEditorInner = ({
   value,
   onChange,
+  onDirtyChange,
   open,
 }: {
   value: string;
   onChange?: (value: string | null) => void;
+  onDirtyChange?: (dirty: boolean) => void;
   open: boolean;
 }) => {
+  const initialValueRef = useRef(value);
   const latestValueRef = useRef(value);
   const wrapperRef = useRef<HTMLDivElement>(null);
 
-  useEditor((root) => createMilkdownEditor(root, { value, latestValueRef }), []);
+  const handleMarkdownUpdated = useCallback(
+    (markdown: string) => {
+      onDirtyChange?.(getChangedCommitValue(markdown, initialValueRef.current) !== undefined);
+    },
+    [onDirtyChange]
+  );
+
+  useEditor(
+    (root) =>
+      createMilkdownEditor(root, {
+        value,
+        latestValueRef,
+        onMarkdownUpdated: handleMarkdownUpdated,
+      }),
+    []
+  );
 
   const [loading, getEditor] = useInstance();
 
@@ -43,9 +71,15 @@ const ExpandedEditorInner = ({
         latestValueRef.current = markdown;
       }
     }
-    const trimmed = latestValueRef.current.trim();
-    onChange?.(trimmed || null);
-  }, [onChange, loading, getEditor]);
+    const nextValue = getChangedCommitValue(latestValueRef.current, initialValueRef.current);
+    if (nextValue !== undefined) {
+      onChange?.(nextValue);
+      initialValueRef.current = latestValueRef.current;
+      onDirtyChange?.(false);
+      return;
+    }
+    onDirtyChange?.(false);
+  }, [onChange, onDirtyChange, loading, getEditor]);
 
   useEffect(() => {
     if (!open) return;
@@ -85,6 +119,7 @@ const ExpandedEditorInner = ({
       ref={wrapperRef}
       className="milkdown-editor-wrap flex-1 overflow-auto text-sm"
       onBlur={handleBlur}
+      onInput={() => onDirtyChange?.(true)}
       onKeyDown={(e) => {
         if (e.key === 'Escape') {
           (document.activeElement as HTMLElement)?.blur();
@@ -99,13 +134,16 @@ const ExpandedEditorInner = ({
 const ExpandedTextEditorInner = ({
   value,
   onChange,
+  onDirtyChange,
   open,
 }: {
   value: string;
   onChange?: (value: string | null) => void;
+  onDirtyChange?: (dirty: boolean) => void;
   open: boolean;
 }) => {
   const textareaRef = useRef<HTMLTextAreaElement>(null);
+  const initialValueRef = useRef(value);
   const latestValueRef = useRef(value);
 
   useEffect(() => {
@@ -121,9 +159,15 @@ const ExpandedTextEditorInner = ({
   }, [open]);
 
   const handleBlur = useCallback(() => {
-    const trimmed = latestValueRef.current.trim();
-    onChange?.(trimmed || null);
-  }, [onChange]);
+    const nextValue = getChangedCommitValue(latestValueRef.current, initialValueRef.current);
+    if (nextValue !== undefined) {
+      onChange?.(nextValue);
+      initialValueRef.current = latestValueRef.current;
+      onDirtyChange?.(false);
+      return;
+    }
+    onDirtyChange?.(false);
+  }, [onChange, onDirtyChange]);
 
   return (
     <textarea
@@ -132,6 +176,9 @@ const ExpandedTextEditorInner = ({
       defaultValue={value}
       onChange={(e) => {
         latestValueRef.current = e.target.value;
+        onDirtyChange?.(
+          getChangedCommitValue(e.target.value, initialValueRef.current) !== undefined
+        );
       }}
       onBlur={handleBlur}
       onKeyDown={(e) => {
@@ -346,8 +393,11 @@ export const ExpandMarkdownEditor = ({
   const [open, setOpen] = useState(false);
   const [mode, setMode] = useState<EditorMode>(initialMode);
   const [converting, setConverting] = useState(false);
+  const [editorKey, setEditorKey] = useState(0);
   const triggerRef = useRef<HTMLButtonElement>(null);
   const contentRef = useRef<HTMLDivElement>(null);
+  const dirtyRef = useRef(false);
+  const syncedValueRef = useRef(normalizeMarkdownValue(value));
   const { offset, setOffset, offsetRef, initOffset, onPointerDown, onPointerMove, onPointerUp } =
     useDrag();
 
@@ -361,8 +411,39 @@ export const ExpandMarkdownEditor = ({
 
   const { size, onResizePointerDown } = useResize(open, scheduleClamp);
 
+  const normalized = normalizeMarkdownValue(value);
+
+  useEffect(() => {
+    if (!open) {
+      dirtyRef.current = false;
+      syncedValueRef.current = normalized;
+      return;
+    }
+
+    if (dirtyRef.current || syncedValueRef.current === normalized) {
+      return;
+    }
+
+    syncedValueRef.current = normalized;
+    setEditorKey((key) => key + 1);
+  }, [normalized, open]);
+
+  const handleDirtyChange = useCallback((dirty: boolean) => {
+    dirtyRef.current = dirty;
+  }, []);
+
+  const handleEditorChange = useCallback(
+    (nextValue: string | null) => {
+      syncedValueRef.current = normalizeMarkdownValue(nextValue);
+      onChange?.(nextValue);
+    },
+    [onChange]
+  );
+
   const handleExpandClick = useCallback(() => {
     onExpandOpen?.();
+    dirtyRef.current = false;
+    syncedValueRef.current = normalizeMarkdownValue(value);
     const el = triggerRef.current;
     if (el) {
       const saved = getSavedSize();
@@ -374,7 +455,7 @@ export const ExpandMarkdownEditor = ({
       initOffset({ x: 0, y: 0 });
     }
     setOpen(true);
-  }, [onExpandOpen, initOffset]);
+  }, [onExpandOpen, initOffset, value]);
 
   const handleOpenChange = (isOpen: boolean) => {
     if (converting) return;
@@ -392,11 +473,20 @@ export const ExpandMarkdownEditor = ({
     }
     setConverting(true);
     try {
+      const nextOptions = {
+        ...(field.options as ILongTextFieldOptions),
+        showAs: nextMode === 'markdown' ? { type: 'markdown' as const } : null,
+      } as ILongTextFieldOptions;
       await field.convert({
         type: FieldType.LongText,
-        options: (nextMode === 'markdown'
-          ? { showAs: { type: 'markdown' } }
-          : { showAs: null }) as ILongTextFieldOptions,
+        name: field.name,
+        dbFieldName: field.dbFieldName,
+        description: field.description,
+        isLookup: field.isLookup,
+        isConditionalLookup: field.isConditionalLookup,
+        lookupOptions: field.lookupOptions,
+        aiConfig: field.aiConfig,
+        options: nextOptions,
       });
       setMode(nextMode);
     } finally {
@@ -404,8 +494,6 @@ export const ExpandMarkdownEditor = ({
     }
   };
 
-  const normalized = normalizeMarkdownValue(value);
-
   const renderEditor = () => {
     if (readonly) {
       return (
@@ -420,12 +508,26 @@ export const ExpandMarkdownEditor = ({
     }
 
     if (mode === 'text') {
-      return <ExpandedTextEditorInner value={normalized} onChange={onChange} open={open} />;
+      return (
+        <ExpandedTextEditorInner
+          key={`text-${editorKey}`}
+          value={normalized}
+          onChange={handleEditorChange}
+          onDirtyChange={handleDirtyChange}
+          open={open}
+        />
+      );
     }
 
     return (
       <MilkdownProvider>
-        <ExpandedEditorInner value={normalized} onChange={onChange} open={open} />
+        <ExpandedEditorInner
+          key={`markdown-${editorKey}`}
+          value={normalized}
+          onChange={handleEditorChange}
+          onDirtyChange={handleDirtyChange}
+          open={open}
+        />
       </MilkdownProvider>
     );
   };
diff --git a/packages/sdk/src/components/editor/long-text/MarkdownEditor.tsx b/packages/sdk/src/components/editor/long-text/MarkdownEditor.tsx
index cf7d3a9a63..fedaf268aa 100644
--- a/packages/sdk/src/components/editor/long-text/MarkdownEditor.tsx
+++ b/packages/sdk/src/components/editor/long-text/MarkdownEditor.tsx
@@ -77,7 +77,8 @@ const MarkdownEditorInner = ({
     <div className="relative">
       <div
         className={cn(
-          'milkdown-editor-wrap w-full max-h-64 overflow-auto rounded-md border bg-background dark:bg-[color-mix(in_oklab,white_5%,hsl(var(--background)))] hover:border-primary/30 text-sm focus-within:border-primary',
+          'milkdown-editor-wrap w-full max-h-64 overflow-auto rounded-md border bg-background hover:border-primary/30 text-sm focus-within:border-primary',
+          !gridMode && 'dark:bg-[color-mix(in_oklab,white_5%,hsl(var(--background)))]',
           className
         )}
         onBlur={handleBlur}
@@ -89,7 +90,7 @@ const MarkdownEditorInner = ({
           <ExpandMarkdownEditor value={latestValueRef.current} onChange={onChange} />
         </div>
       )}
-      {hideExpand && (
+      {hideExpand && !gridMode && (
         <span
           className="absolute bottom-1.5 right-2 select-none rounded-sm bg-foreground/80 px-1 py-px text-[9px] font-semibold tracking-wide text-background backdrop-blur-sm"
           title="Markdown enabled"
diff --git a/packages/sdk/src/components/editor/long-text/utils.spec.ts b/packages/sdk/src/components/editor/long-text/utils.spec.ts
new file mode 100644
index 0000000000..830a337e24
--- /dev/null
+++ b/packages/sdk/src/components/editor/long-text/utils.spec.ts
@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import { stripMarkdown } from './utils';
+
+const url = 'http://example.com/base/table/view';
+
+describe('long text markdown utils', () => {
+  it('keeps autolink URLs visible when stripping markdown', () => {
+    expect(stripMarkdown(`123<${url}>`)).toBe(`123${url}`);
+  });
+
+  it('keeps escaped autolink URLs visible when stripping markdown', () => {
+    expect(stripMarkdown(`123\\<${url.replace(':', '\\:')}>`)).toBe(`123${url}`);
+  });
+
+  it('keeps angle-wrapped markdown link URLs visible when stripping markdown', () => {
+    expect(stripMarkdown(`123<[${url}](${url})>`)).toBe(`123${url}`);
+  });
+
+  it('keeps escaped angle-wrapped markdown link URLs visible when stripping markdown', () => {
+    expect(stripMarkdown(`123\\<[${url}](${url})>`)).toBe(`123${url}`);
+  });
+});
diff --git a/packages/sdk/src/components/editor/long-text/utils.ts b/packages/sdk/src/components/editor/long-text/utils.ts
index 3c7016f827..63b9f68778 100644
--- a/packages/sdk/src/components/editor/long-text/utils.ts
+++ b/packages/sdk/src/components/editor/long-text/utils.ts
@@ -2,6 +2,10 @@ import type { Editor } from '@milkdown/core';
 import { editorViewCtx, serializerCtx } from '@milkdown/core';
 import removeMd from 'remove-markdown';
 
+const escapedAutolinkRegExp = /\\<(https?\\?:\/\/[^>]+)>/g;
+
+const normalizeEscapedAutolinkUrl = (url: string) => url.replace(/\\:/g, ':');
+
 export const isMarkdownShowAs = (options: unknown): boolean =>
   (options as { showAs?: { type?: string } } | undefined)?.showAs?.type === 'markdown';
 
@@ -20,6 +24,8 @@ export const normalizeMarkdownValue = (value: unknown): string => {
 export const stripMarkdown = (text: string): string => {
   // Preserve URLs from empty-label links [](url) and autolinks <url> before stripping
   const normalized = text
+    .replace(/\\?<(\[[^\]]*\]\([^)]+\))>/g, '$1')
+    .replace(escapedAutolinkRegExp, (_, url) => normalizeEscapedAutolinkUrl(url))
     .replace(/\[([^\]]*)\]\(([^)]+)\)/g, (_, label, url) =>
       label.trim() ? `[${label}](${url})` : url
     )
diff --git a/packages/sdk/src/components/expand-record/ExpandRecordHeader.tsx b/packages/sdk/src/components/expand-record/ExpandRecordHeader.tsx
index b950a6586e..447d5f78dc 100644
--- a/packages/sdk/src/components/expand-record/ExpandRecordHeader.tsx
+++ b/packages/sdk/src/components/expand-record/ExpandRecordHeader.tsx
@@ -188,23 +188,23 @@ export const ExpandRecordHeader = (props: IExpandRecordHeader) => {
               <DropdownMenuContent>
                 {!!onDuplicate && (
                   <DropdownMenuItem
-                    className="flex cursor-pointer items-center gap-2 px-4 py-2 text-sm outline-none"
+                    className="flex cursor-pointer items-center gap-2 text-sm outline-none"
                     onClick={async () => {
                       await onDuplicate();
                       setTimeout(() => onClose?.(), 100);
                     }}
                   >
-                    <CopyPlus /> {t('expandRecord.duplicateRecord')}
+                    <CopyPlus className="size-4 shrink-0" /> {t('expandRecord.duplicateRecord')}
                   </DropdownMenuItem>
                 )}
                 <DropdownMenuItem
-                  className="flex cursor-pointer items-center gap-2 px-4 py-2 text-sm text-red-500 outline-none hover:text-red-500 focus:text-red-500 aria-selected:text-red-500"
+                  className="flex cursor-pointer items-center gap-2 text-sm text-red-500 outline-none hover:text-red-500 focus:text-red-500 aria-selected:text-red-500"
                   onClick={async () => {
                     await onDelete?.();
                     setTimeout(() => onClose?.(), 100);
                   }}
                 >
-                  <Trash /> {t('expandRecord.deleteRecord')}
+                  <Trash className="size-4 shrink-0" /> {t('expandRecord.deleteRecord')}
                 </DropdownMenuItem>
               </DropdownMenuContent>
             </DropdownMenu>
diff --git a/packages/sdk/src/components/expand-record/RecordEditorItem.tsx b/packages/sdk/src/components/expand-record/RecordEditorItem.tsx
index eb43275f6a..0d1dffae23 100644
--- a/packages/sdk/src/components/expand-record/RecordEditorItem.tsx
+++ b/packages/sdk/src/components/expand-record/RecordEditorItem.tsx
@@ -1,6 +1,6 @@
 import type { IAttachmentCellValue } from '@teable/core';
+import { Info } from '@teable/icons';
 import { cn } from '@teable/ui-lib';
-import { AlertCircle } from 'lucide-react';
 import { useContext } from 'react';
 import { TaskStatusCollectionContext } from '../../context';
 import type { IButtonClickStatusHook } from '../../hooks';
@@ -58,7 +58,9 @@ export const RecordEditorItem = (props: {
           </span>
           {field.description && (
             <TooltipWrap description={field.description}>
-              <AlertCircle className="ml-0.5 mt-[3px] size-4 shrink-0 cursor-pointer text-muted-foreground" />
+              <span className="ml-0.5 mt-[3px] inline-flex shrink-0 cursor-pointer text-muted-foreground">
+                <Info className="size-4" />
+              </span>
             </TooltipWrap>
           )}
         </div>
diff --git a/packages/sdk/src/components/filter/condition/condition-item/ConditionItem.tsx b/packages/sdk/src/components/filter/condition/condition-item/ConditionItem.tsx
index fd89759300..45aae02f1b 100644
--- a/packages/sdk/src/components/filter/condition/condition-item/ConditionItem.tsx
+++ b/packages/sdk/src/components/filter/condition/condition-item/ConditionItem.tsx
@@ -1,11 +1,20 @@
-import { Trash } from '@teable/icons';
-import { Button } from '@teable/ui-lib';
+import { AlertTriangle, Trash } from '@teable/icons';
+import {
+  Button,
+  Tooltip,
+  TooltipContent,
+  TooltipPortal,
+  TooltipProvider,
+  TooltipTrigger,
+} from '@teable/ui-lib';
+import { useTranslation } from '../../../../context/app/i18n';
 import { useCrud } from '../../hooks';
 import type {
   IConditionItemProperty,
   IBaseConditionProps,
   IBaseFilterComponentProps,
 } from '../../types';
+import { useFilterItemError } from '../../view-filter/hooks';
 import { FieldSelect } from './base-component/FieldSelect';
 import { FieldValue } from './base-component/FieldValue';
 import { OperatorSelect } from './base-component/OperatorSelect';
@@ -19,9 +28,11 @@ interface IConditionItemProps<T extends IConditionItemProperty = IConditionItemP
 export const ConditionItem = <T extends IConditionItemProperty>(props: IConditionItemProps<T>) => {
   const { path, value, index } = props;
   const { onDelete } = useCrud();
+  const { t } = useTranslation();
+  const itemError = useFilterItemError(path);
 
   return (
-    <div className="flex items-center gap-2 self-center">
+    <div className="flex items-center gap-2 self-center rounded-md">
       <FieldSelect path={[...path, 'field']} value={value.field} item={value} />
       <OperatorSelect path={[...path, 'operator']} value={value.operator} item={value} />
       <FieldValue path={[...path, 'value']} value={value.value} item={value} />
@@ -36,6 +47,22 @@ export const ConditionItem = <T extends IConditionItemProperty>(props: IConditio
       >
         <Trash className="size-4" />
       </Button>
+      {itemError && (
+        <TooltipProvider>
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <span className="flex size-4 shrink-0 cursor-help items-center">
+                <AlertTriangle className="size-4 text-yellow-500" />
+              </span>
+            </TooltipTrigger>
+            <TooltipPortal>
+              <TooltipContent side="top" className="max-w-xs">
+                {t('filter.invalidConditionTip')}
+              </TooltipContent>
+            </TooltipPortal>
+          </Tooltip>
+        </TooltipProvider>
+      )}
     </div>
   );
 };
diff --git a/packages/sdk/src/components/filter/view-filter/ViewFilter.tsx b/packages/sdk/src/components/filter/view-filter/ViewFilter.tsx
index 69f59275b1..be2faf9399 100644
--- a/packages/sdk/src/components/filter/view-filter/ViewFilter.tsx
+++ b/packages/sdk/src/components/filter/view-filter/ViewFilter.tsx
@@ -1,13 +1,18 @@
-import { FieldType, type IFilter } from '@teable/core';
+import {
+  FieldType,
+  analyzeFilterValidationIssues,
+  type IFilter,
+  type IFilterValidationFieldMeta,
+} from '@teable/core';
 import { Popover, PopoverTrigger, PopoverContent, cn } from '@teable/ui-lib';
 import { isEqual } from 'lodash';
-import { useRef, useState } from 'react';
+import { useMemo, useRef, useState } from 'react';
 import { useDebounce, useUpdateEffect } from 'react-use';
 import { useFields, useTableId, useViewId } from '../../../hooks';
 import { ReadOnlyTip } from '../../ReadOnlyTip';
 import type { IFilterBaseComponent } from '../types';
 import { BaseViewFilter } from './BaseViewFilter';
-import { useFilterNode, useViewFilterLinkContext } from './hooks';
+import { FilterValidationContext, useFilterNode, useViewFilterLinkContext } from './hooks';
 import type { IViewFilterConditionItem, IViewFilterLinkContext } from './types';
 
 export interface IViewFilterProps {
@@ -25,6 +30,20 @@ export const ViewFilter = (props: IViewFilterProps) => {
   const fields = defaultFields.filter((f) => f.type !== FieldType.Button);
   const { text, isActive, hasWarning } = useFilterNode(filters, fields);
   const [filter, setFilter] = useState(filters);
+
+  // Validation errors against the local (editing) filter — lets the popover highlight
+  // invalid rows in real time as the user fixes them.
+  const validationErrors = useMemo(() => {
+    const fieldMetaMap = fields.reduce<Record<string, IFilterValidationFieldMeta>>((acc, f) => {
+      acc[f.id] = {
+        type: f.type as FieldType,
+        cellValueType: f.cellValueType,
+        isMultipleCellValue: f.isMultipleCellValue,
+      };
+      return acc;
+    }, {});
+    return analyzeFilterValidationIssues(filter, fieldMetaMap);
+  }, [filter, fields]);
   const [popoverOpen, setPopoverOpen] = useState(false);
 
   // Track local edit version to prevent stale server responses from overwriting local state
@@ -69,27 +88,29 @@ export const ViewFilter = (props: IViewFilterProps) => {
   );
 
   return (
-    <Popover open={popoverOpen} onOpenChange={setPopoverOpen}>
-      <PopoverTrigger asChild>
-        {children?.(text, isActive || popoverOpen, hasWarning)}
-      </PopoverTrigger>
-      <PopoverContent
-        side="bottom"
-        align="start"
-        className={cn(
-          'flex max-h-96 w-min min-w-[498px] max-w-screen-md flex-col overflow-hidden rounded-lg p-4 pr-2 relative'
-        )}
-      >
-        <ReadOnlyTip />
-        {contentHeader}
-        <BaseViewFilter<IViewFilterConditionItem>
-          fields={fields}
-          value={filter}
-          onChange={onChangeHandler}
-          customValueComponent={props.customValueComponent}
-          viewFilterLinkContext={finalViewFilterLinkContext}
-        />
-      </PopoverContent>
-    </Popover>
+    <FilterValidationContext.Provider value={validationErrors}>
+      <Popover open={popoverOpen} onOpenChange={setPopoverOpen}>
+        <PopoverTrigger asChild>
+          {children?.(text, isActive || popoverOpen, hasWarning)}
+        </PopoverTrigger>
+        <PopoverContent
+          side="bottom"
+          align="start"
+          className={cn(
+            'flex max-h-96 w-min min-w-[498px] max-w-screen-md flex-col overflow-hidden rounded-lg p-4 pr-2 relative'
+          )}
+        >
+          <ReadOnlyTip />
+          {contentHeader}
+          <BaseViewFilter<IViewFilterConditionItem>
+            fields={fields}
+            value={filter}
+            onChange={onChangeHandler}
+            customValueComponent={props.customValueComponent}
+            viewFilterLinkContext={finalViewFilterLinkContext}
+          />
+        </PopoverContent>
+      </Popover>
+    </FilterValidationContext.Provider>
   );
 };
diff --git a/packages/sdk/src/components/filter/view-filter/hooks/index.ts b/packages/sdk/src/components/filter/view-filter/hooks/index.ts
index 03035a2552..6987abba42 100644
--- a/packages/sdk/src/components/filter/view-filter/hooks/index.ts
+++ b/packages/sdk/src/components/filter/view-filter/hooks/index.ts
@@ -5,3 +5,4 @@ export * from './useDateI18nMap';
 export * from './useOperatorI18nMap';
 export * from './useViewFilterContext';
 export * from './useFieldFilterLinkContext';
+export * from './useFilterValidationContext';
diff --git a/packages/sdk/src/components/filter/view-filter/hooks/useFilterNode.ts b/packages/sdk/src/components/filter/view-filter/hooks/useFilterNode.ts
index 74ac1c880c..e7b1842dc9 100644
--- a/packages/sdk/src/components/filter/view-filter/hooks/useFilterNode.ts
+++ b/packages/sdk/src/components/filter/view-filter/hooks/useFilterNode.ts
@@ -1,5 +1,5 @@
-import type { FieldType, IFilter } from '@teable/core';
-import { validateFilterOperatorModeCompatibility } from '@teable/core';
+import type { FieldType, IFilter, IFilterValidationFieldMeta } from '@teable/core';
+import { analyzeFilterValidationIssues } from '@teable/core';
 import { Filter as FilterIcon } from '@teable/icons';
 import { keyBy } from 'lodash';
 import { useCallback, useMemo } from 'react';
@@ -44,20 +44,23 @@ export const useFilterNode = (filters: IFilter | null | undefined, fields: IFiel
     return generateFilterButtonText(filteredIds, fields);
   }, [fields, filters, generateFilterButtonText]);
 
-  // Check if filter has any validation errors (e.g., invalid operator+mode combination)
+  // Show a compact warning state when stored filters contain ignored conditions.
   const hasWarning = useMemo(() => {
     if (!filters || !fields.length) return false;
 
-    const fieldTypeMap = fields.reduce(
+    const fieldMetaMap = fields.reduce(
       (acc, field) => {
-        acc[field.id] = field.type as FieldType;
+        acc[field.id] = {
+          type: field.type as FieldType,
+          cellValueType: field.cellValueType,
+          isMultipleCellValue: field.isMultipleCellValue,
+        };
         return acc;
       },
-      {} as Record<string, FieldType>
+      {} as Record<string, IFilterValidationFieldMeta>
     );
 
-    const errors = validateFilterOperatorModeCompatibility(filters, fieldTypeMap);
-    return errors.length > 0;
+    return analyzeFilterValidationIssues(filters, fieldMetaMap).length > 0;
   }, [filters, fields]);
 
   return {
diff --git a/packages/sdk/src/components/filter/view-filter/hooks/useFilterValidationContext.ts b/packages/sdk/src/components/filter/view-filter/hooks/useFilterValidationContext.ts
new file mode 100644
index 0000000000..dd6531efff
--- /dev/null
+++ b/packages/sdk/src/components/filter/view-filter/hooks/useFilterValidationContext.ts
@@ -0,0 +1,23 @@
+import type { IFilterValidationError } from '@teable/core';
+import { createContext, useContext } from 'react';
+import type { IFilterPath } from '../../types';
+
+export const FilterValidationContext = createContext<IFilterValidationError[]>([]);
+
+const normalizeFilterPath = (path: IFilterPath | number[]): number[] => {
+  return path.reduce<number[]>((acc, segment) => {
+    if (typeof segment === 'number') {
+      acc.push(segment);
+    }
+    return acc;
+  }, []);
+};
+
+const isSamePath = (path1: number[], path2: number[]) =>
+  path1.length === path2.length && path1.every((segment, index) => segment === path2[index]);
+
+export const useFilterItemError = (path: IFilterPath) => {
+  const errors = useContext(FilterValidationContext);
+  const normalizedPath = normalizeFilterPath(path);
+  return errors.find((error) => isSamePath(error.path, normalizedPath));
+};
diff --git a/packages/sdk/src/components/grid-enhancements/hooks/use-grid-columns.tsx b/packages/sdk/src/components/grid-enhancements/hooks/use-grid-columns.tsx
index c840bbc443..ad8dba0bc4 100644
--- a/packages/sdk/src/components/grid-enhancements/hooks/use-grid-columns.tsx
+++ b/packages/sdk/src/components/grid-enhancements/hooks/use-grid-columns.tsx
@@ -61,6 +61,7 @@ interface IGenerateColumnsProps {
   sortFieldIds?: Set<string>;
   groupFieldIds?: Set<string>;
   filterFieldIds?: Set<string>;
+  highlightedFieldId?: string | null;
 }
 
 const getColumnThemeByField = ({
@@ -69,7 +70,11 @@ const getColumnThemeByField = ({
   sortFieldIds,
   groupFieldIds,
   filterFieldIds,
-}: Pick<IGenerateColumnsProps, 'theme' | 'sortFieldIds' | 'groupFieldIds' | 'filterFieldIds'> & {
+  highlightedFieldId,
+}: Pick<
+  IGenerateColumnsProps,
+  'theme' | 'sortFieldIds' | 'groupFieldIds' | 'filterFieldIds' | 'highlightedFieldId'
+> & {
   field: IFieldInstance;
 }) => {
   const { id, isPending, hasError } = field;
@@ -116,6 +121,13 @@ const getColumnThemeByField = ({
     };
   }
 
+  if (highlightedFieldId === id) {
+    customTheme = {
+      ...customTheme,
+      ...getHighlightedColumnTheme(theme),
+    };
+  }
+
   if (hasError || isPending) {
     const c = hasError
       ? { light: [rose[100], rose[200]] as const, dark: [rose[500], rose[400]] as const }
@@ -132,6 +144,21 @@ const getColumnThemeByField = ({
   return customTheme;
 };
 
+const getHighlightedColumnTheme = (theme: string | undefined) => {
+  const isDark = theme === 'dark';
+  const { blue } = colors;
+
+  return isDark
+    ? {
+        cellBg: hexToRGBA(blue[500], 0.1),
+        columnHeaderBg: hexToRGBA(blue[500], 0.1),
+      }
+    : {
+        cellBg: blue[50],
+        columnHeaderBg: blue[50],
+      };
+};
+
 const useGenerateColumns = () => {
   const { t } = useTranslation();
   return useCallback(
@@ -143,6 +170,7 @@ const useGenerateColumns = () => {
       sortFieldIds,
       groupFieldIds,
       filterFieldIds,
+      highlightedFieldId,
     }: IGenerateColumnsProps): (IGridColumn & { id: string })[] => {
       return fields
         .map((field, i) => {
@@ -156,6 +184,7 @@ const useGenerateColumns = () => {
             sortFieldIds,
             groupFieldIds,
             filterFieldIds,
+            highlightedFieldId,
           });
 
           return {
@@ -562,7 +591,11 @@ export const useCreateCellValue2GridDisplay = (
   );
 };
 
-export function useGridColumns(hasMenu?: boolean, hiddenFieldIds?: string[]) {
+export function useGridColumns(
+  hasMenu?: boolean,
+  hiddenFieldIds?: string[],
+  highlightedFieldId?: string | null
+) {
   const view = useView() as GridView | undefined;
   const originFields = useFields();
   const totalFields = useFields({ withHidden: true, withDenied: true });
@@ -616,6 +649,7 @@ export function useGridColumns(hasMenu?: boolean, hiddenFieldIds?: string[]) {
         sortFieldIds,
         groupFieldIds,
         filterFieldIds,
+        highlightedFieldId,
       }),
       cellValue2GridDisplay: createCellValue2GridDisplay(fields),
     }),
@@ -628,6 +662,7 @@ export function useGridColumns(hasMenu?: boolean, hiddenFieldIds?: string[]) {
       sortFieldIds,
       groupFieldIds,
       filterFieldIds,
+      highlightedFieldId,
       createCellValue2GridDisplay,
     ]
   );
diff --git a/packages/sdk/src/components/grid/components/ErrorIndicator.tsx b/packages/sdk/src/components/grid/components/ErrorIndicator.tsx
index 728b92eae3..c85520b4d5 100644
--- a/packages/sdk/src/components/grid/components/ErrorIndicator.tsx
+++ b/packages/sdk/src/components/grid/components/ErrorIndicator.tsx
@@ -23,7 +23,7 @@ export const ErrorIndicator = (props: IErrorIndicatorProps) => {
 
   return (
     <TooltipProvider delayDuration={100}>
-      <div className="pointer-events-none absolute left-0 top-0 z-10">
+      <div className="pointer-events-none absolute left-0 top-0">
         {cellErrors.map(({ cellItem, errorMsg, onRetry, onDismiss }) => {
           const [columnIndex, rowIndex] = cellItem;
           const rowHeight = coordInstance.getRowHeight(rowIndex);
diff --git a/packages/sdk/src/components/grid/components/LoadingIndicator.tsx b/packages/sdk/src/components/grid/components/LoadingIndicator.tsx
index 2f1fcb987f..23b1c17862 100644
--- a/packages/sdk/src/components/grid/components/LoadingIndicator.tsx
+++ b/packages/sdk/src/components/grid/components/LoadingIndicator.tsx
@@ -34,7 +34,7 @@ export const LoadingIndicator = (props: ILoadingIndicatorProps) => {
     coordInstance;
 
   return (
-    <div className="pointer-events-none absolute left-0 top-0 z-10">
+    <div className="pointer-events-none absolute left-0 top-0">
       {columnLoadings.map(({ index, progress, onCancel }) => {
         const columnWidth = coordInstance.getColumnWidth(index);
         const columnOffset = coordInstance.getColumnRelativeOffset(index, scrollLeft);
diff --git a/packages/sdk/src/components/grid/managers/sprite-manager/sprites.tsx b/packages/sdk/src/components/grid/managers/sprite-manager/sprites.tsx
index d8aa4e7699..a5d8b8135b 100644
--- a/packages/sdk/src/components/grid/managers/sprite-manager/sprites.tsx
+++ b/packages/sdk/src/components/grid/managers/sprite-manager/sprites.tsx
@@ -1,5 +1,4 @@
 import {
-  AlertCircle,
   DraggableHandle,
   Maximize2,
   Plus,
@@ -8,6 +7,7 @@ import {
   ChevronRight,
   Lock,
   EyeOff,
+  Info,
 } from '@teable/icons';
 import { renderToString } from 'react-dom/server';
 
@@ -33,7 +33,7 @@ const add = (props: ISpriteProps) => {
 
 const description = (props: ISpriteProps) => {
   const { fgColor } = props;
-  return renderToString(<AlertCircle style={{ color: fgColor }} />);
+  return renderToString(<Info style={{ color: fgColor }} />);
 };
 
 const close = (props: ISpriteProps) => {
diff --git a/packages/sdk/src/components/grid/renderers/cell-renderer/buttonCellRenderer.ts b/packages/sdk/src/components/grid/renderers/cell-renderer/buttonCellRenderer.ts
index 0c707dcb52..d8710c4805 100644
--- a/packages/sdk/src/components/grid/renderers/cell-renderer/buttonCellRenderer.ts
+++ b/packages/sdk/src/components/grid/renderers/cell-renderer/buttonCellRenderer.ts
@@ -100,7 +100,7 @@ const calcPosition = (
   const { fieldOptions } = data;
   const { width, ctx, theme, height } = props;
   const { fontSizeXS, fontFamily } = theme;
-  const cacheKey = `${fieldOptions.label}-${width}`;
+  const cacheKey = `${fieldOptions.label}-${width}-${height}`;
   if (!flush) {
     const cachedRect = positionCache.get(cacheKey);
     if (cachedRect) return cachedRect;
@@ -187,10 +187,10 @@ export const buttonCellRenderer: IInternalCellRenderer<IButtonCell> = {
   checkRegion: (cell: IButtonCell, props: ICellClickProps, _shouldCalculate?: boolean) => {
     const { data } = cell;
     const { fieldOptions } = data;
-    const { hoverCellPosition, width } = props;
+    const { hoverCellPosition, width, height } = props;
     const [x, y] = hoverCellPosition;
 
-    const cacheKey = `${fieldOptions.label}-${width}`;
+    const cacheKey = `${fieldOptions.label}-${width}-${height}`;
     const rect = positionCache.get(cacheKey);
     if (
       rect &&
diff --git a/packages/sdk/src/components/hide-fields/HideFields.tsx b/packages/sdk/src/components/hide-fields/HideFields.tsx
index 17e7b8857e..99fc55a3cb 100644
--- a/packages/sdk/src/components/hide-fields/HideFields.tsx
+++ b/packages/sdk/src/components/hide-fields/HideFields.tsx
@@ -9,8 +9,9 @@ import { HideFieldsBase } from './HideFieldsBase';
 
 export const HideFields: React.FC<{
   footer?: React.ReactNode;
+  onFieldClick?: (field: IFieldInstance) => void;
   children: (text: string, isActive: boolean) => React.ReactNode;
-}> = ({ footer, children }) => {
+}> = ({ footer, onFieldClick, children }) => {
   const activeViewId = useViewId();
   const fields = useFields({ withHidden: true, withDenied: true });
   const view = useView() as GridView | undefined;
@@ -79,6 +80,7 @@ export const HideFields: React.FC<{
       hidden={hiddenFieldIds}
       onChange={onChange}
       onOrderChange={onOrderChange}
+      onFieldClick={onFieldClick}
     >
       {children(
         hiddenCount ? t('hidden.configLabel_other', { count: hiddenCount }) : t('hidden.label'),
diff --git a/packages/sdk/src/components/hide-fields/HideFieldsBase.tsx b/packages/sdk/src/components/hide-fields/HideFieldsBase.tsx
index 119dd489e8..ac071e4542 100644
--- a/packages/sdk/src/components/hide-fields/HideFieldsBase.tsx
+++ b/packages/sdk/src/components/hide-fields/HideFieldsBase.tsx
@@ -34,10 +34,11 @@ interface IHideFieldsBaseProps {
   children: React.ReactNode;
   onChange: (hidden: string[]) => void;
   onOrderChange?: (fieldId: string, fromIndex: number, toIndex: number) => void;
+  onFieldClick?: (field: IFieldInstance) => void;
 }
 
 export const HideFieldsBase = (props: IHideFieldsBaseProps) => {
-  const { fields, hidden, footer, children, onChange, onOrderChange } = props;
+  const { fields, hidden, footer, children, onChange, onOrderChange, onFieldClick } = props;
   const { t } = useTranslation();
   const fieldStaticGetter = useFieldStaticGetter();
 
@@ -129,6 +130,15 @@ export const HideFieldsBase = (props: IHideFieldsBaseProps) => {
                   hasAiConfig: Boolean(aiConfig),
                   deniedReadRecord: !canReadFieldRecord,
                 });
+                const handleFieldClick = () => {
+                  if (onFieldClick) {
+                    onFieldClick(field);
+                    return;
+                  }
+                  if (!isPrimary) {
+                    switchChange(id, !statusMap[id]);
+                  }
+                };
                 return (
                   <Draggable key={id} id={id} disabled={!dragEnabled}>
                     {({ setNodeRef, listeners, attributes, style, isDragging }) => (
@@ -150,7 +160,7 @@ export const HideFieldsBase = (props: IHideFieldsBaseProps) => {
                                   <div className="flex flex-1 cursor-pointer items-center truncate p-0">
                                     <Label
                                       htmlFor={id}
-                                      className="flex flex-1 cursor-pointer items-center truncate p-2"
+                                      className="flex cursor-pointer items-center p-2"
                                     >
                                       <Switch
                                         id={id}
@@ -161,11 +171,17 @@ export const HideFieldsBase = (props: IHideFieldsBaseProps) => {
                                         }}
                                         disabled={isPrimary}
                                       />
-                                      <Icon className="ml-2 size-4 shrink-0" />
+                                    </Label>
+                                    <button
+                                      type="button"
+                                      className="flex min-w-0 flex-1 items-center truncate py-2 pr-2 text-left"
+                                      onClick={handleFieldClick}
+                                    >
+                                      <Icon className="size-4 shrink-0" />
                                       <span className="h-full flex-1 cursor-pointer truncate pl-1 text-sm">
                                         {name}
                                       </span>
-                                    </Label>
+                                    </button>
                                     {/* forbid drag when search */}
                                     {dragEnabled && (
                                       <div {...attributes} {...listeners} className="pr-2">
@@ -175,8 +191,10 @@ export const HideFieldsBase = (props: IHideFieldsBaseProps) => {
                                   </div>
                                 </TooltipTrigger>
                                 {isPrimary ? (
-                                  <TooltipContent>
-                                    <pre>{t('hidden.primaryKey')}</pre>
+                                  <TooltipContent className="max-w-[360px]">
+                                    <span className="whitespace-normal break-words">
+                                      {t('hidden.primaryKey')}
+                                    </span>
                                   </TooltipContent>
                                 ) : null}
                               </Tooltip>
diff --git a/packages/sdk/src/components/index.ts b/packages/sdk/src/components/index.ts
index 05802178e8..89a72b80b0 100644
--- a/packages/sdk/src/components/index.ts
+++ b/packages/sdk/src/components/index.ts
@@ -13,6 +13,7 @@ export * from './select-field-dialog';
 export * from './search';
 export * from './record-list';
 export * from './create-record';
+export * from './ReadOnlyTip';
 export * from './collaborator';
 export * from './color';
 export * from './base-query';
diff --git a/packages/sdk/src/components/select-field-dialog/FieldCreateOrSelectModal.tsx b/packages/sdk/src/components/select-field-dialog/FieldCreateOrSelectModal.tsx
index cc34b7878f..727c5107c9 100644
--- a/packages/sdk/src/components/select-field-dialog/FieldCreateOrSelectModal.tsx
+++ b/packages/sdk/src/components/select-field-dialog/FieldCreateOrSelectModal.tsx
@@ -22,6 +22,7 @@ import { forwardRef, useEffect, useImperativeHandle, useMemo, useState } from 'r
 import { useTranslation } from '../../context/app/i18n';
 import { useFieldOperations, useFieldStaticGetter, useFields, useTableId } from '../../hooks';
 import type { IFieldInstance } from '../../model';
+import { ReadOnlyTip } from '../ReadOnlyTip';
 import { FieldCreator } from './FieldCreator';
 
 interface IFieldCreateOrSelectModalProps {
@@ -30,6 +31,7 @@ interface IFieldCreateOrSelectModalProps {
   description?: ReactNode;
   selectedFieldId?: string;
   isCreatable?: boolean;
+  readOnly?: boolean;
   getCreateBtnText: (fieldName: string) => ReactNode;
   children: (isActive: boolean) => React.ReactNode;
   onConfirm?: (field: IFieldVo | IFieldInstance) => void;
@@ -51,6 +53,7 @@ export const FieldCreateOrSelectModal = forwardRef<
     selectedFieldId: _selectedFieldId,
     children,
     onConfirm,
+    readOnly,
   } = props;
   const tableId = useTableId();
   const totalFields = useFields({ withHidden: true, withDenied: true });
@@ -71,10 +74,12 @@ export const FieldCreateOrSelectModal = forwardRef<
   }, [_selectedFieldId]);
 
   const onFieldSelect = (value: string) => {
+    if (readOnly) return;
     setSelectedFieldId(value);
   };
 
   const onConfirmInner = async () => {
+    if (readOnly) return;
     if (newField != null) {
       if (tableId == null) return setNewField(undefined);
       const result = createFieldRoSchema.safeParse(newField);
@@ -115,7 +120,8 @@ export const FieldCreateOrSelectModal = forwardRef<
           {description && <DialogDescription className="text-xs">{description}</DialogDescription>}
         </DialogHeader>
 
-        <div className="rounded-md bg-muted p-4 pr-0">
+        <div className="relative rounded-md bg-muted p-4 pr-0">
+          {readOnly && <ReadOnlyTip />}
           <ScrollArea className="h-52 w-full" type="always">
             {newField ? (
               <FieldCreator field={newField} setField={setNewField} />
@@ -131,8 +137,14 @@ export const FieldCreateOrSelectModal = forwardRef<
                   });
                   return (
                     <div key={id} className="flex items-center space-x-2">
-                      <RadioGroupItem value={id} id={id} />
-                      <Label className="flex cursor-pointer items-center space-x-1" htmlFor={id}>
+                      <RadioGroupItem value={id} id={id} disabled={readOnly} />
+                      <Label
+                        className={cn(
+                          'flex items-center space-x-1',
+                          readOnly ? 'cursor-not-allowed' : 'cursor-pointer'
+                        )}
+                        htmlFor={id}
+                      >
                         <Icon className="size-4" />
                         <span>{name}</span>
                       </Label>
@@ -144,17 +156,20 @@ export const FieldCreateOrSelectModal = forwardRef<
           </ScrollArea>
         </div>
 
-        {content}
+        <div className="relative">
+          {readOnly && <ReadOnlyTip />}
+          {content}
+        </div>
 
         <DialogFooter className={cn(newField && 'justify-between sm:justify-between')}>
           {newField && (
-            <Button variant={'ghost'} onClick={() => setNewField(undefined)}>
+            <Button variant={'ghost'} disabled={readOnly} onClick={() => setNewField(undefined)}>
               <ArrowLeft className="size-4 shrink-0" />
               {t('common.back')}
             </Button>
           )}
           <DialogClose asChild>
-            <Button disabled={!selectedFieldId && !newField} onClick={onConfirmInner}>
+            <Button disabled={!readOnly && !selectedFieldId && !newField} onClick={onConfirmInner}>
               {t('common.done')}
             </Button>
           </DialogClose>
diff --git a/packages/sdk/src/components/table/InfiniteTable.tsx b/packages/sdk/src/components/table/InfiniteTable.tsx
index 73ac6568fb..807f18d971 100644
--- a/packages/sdk/src/components/table/InfiniteTable.tsx
+++ b/packages/sdk/src/components/table/InfiniteTable.tsx
@@ -12,12 +12,22 @@ interface IInfiniteTableProps<T> {
   sorting?: SortingState;
   onSortingChange?: OnChangeFn<SortingState>;
   emptyText?: string;
+  density?: 'default' | 'compact';
 }
 
 export const InfiniteTable = <T extends { [key: string]: unknown }>(
   props: IInfiniteTableProps<T>
 ) => {
-  const { rows, columns, className, fetchNextPage, sorting, onSortingChange, emptyText } = props;
+  const {
+    rows,
+    columns,
+    className,
+    fetchNextPage,
+    sorting,
+    onSortingChange,
+    emptyText,
+    density = 'default',
+  } = props;
 
   const { t } = useTranslation();
   const listRef = useRef<HTMLDivElement>(null);
@@ -51,13 +61,15 @@ export const InfiniteTable = <T extends { [key: string]: unknown }>(
     fetchMoreOnBottomReached(listRef.current);
   }, [fetchMoreOnBottomReached]);
 
+  const cellPaddingClass = density === 'compact' ? 'px-2.5' : 'px-4';
+
   return (
     <div
       ref={listRef}
       className={cn('relative size-full overflow-auto', className)}
       onScroll={(e) => fetchMoreOnBottomReached(e.target as HTMLDivElement)}
     >
-      <Table className="relative scroll-smooth">
+      <Table className="relative w-full scroll-smooth">
         <TableHeader className="sticky top-0 z-10 bg-muted">
           {table.getHeaderGroups().map((headerGroup) => (
             <TableRow
@@ -70,7 +82,11 @@ export const InfiniteTable = <T extends { [key: string]: unknown }>(
                 return (
                   <TableHead
                     key={header.id}
-                    className={cn('flex items-center px-4', isAutoSize ? 'flex-1' : 'truncate')}
+                    className={cn(
+                      'flex items-center',
+                      cellPaddingClass,
+                      isAutoSize ? 'min-w-0 flex-1' : 'truncate'
+                    )}
                     style={{
                       minWidth: header.column.columnDef.minSize,
                       width: isAutoSize ? undefined : width,
@@ -96,8 +112,9 @@ export const InfiniteTable = <T extends { [key: string]: unknown }>(
                     <TableCell
                       key={cell.id}
                       className={cn(
-                        'flex min-h-[40px] items-center px-4 overflow-hidden',
-                        isAutoSize && 'flex-1'
+                        'flex min-h-[40px] items-center overflow-hidden',
+                        cellPaddingClass,
+                        isAutoSize && 'min-w-0 flex-1'
                       )}
                       style={{
                         minWidth: cell.column.columnDef.minSize,
diff --git a/packages/sdk/src/model/base.ts b/packages/sdk/src/model/base.ts
index 93f0cbf6d1..e438d1f55b 100644
--- a/packages/sdk/src/model/base.ts
+++ b/packages/sdk/src/model/base.ts
@@ -1,5 +1,10 @@
 import type { IRole } from '@teable/core';
-import type { IGetBaseVo, ICreateTableRo, CollaboratorType } from '@teable/openapi';
+import type {
+  IGetBaseVo,
+  ICreateTableRo,
+  CollaboratorType,
+  IBaseV2StatusVo,
+} from '@teable/openapi';
 import { createTable, deleteTable, permanentDeleteTable } from '@teable/openapi';
 
 export class Base implements IGetBaseVo {
@@ -13,6 +18,7 @@ export class Base implements IGetBaseVo {
   enabledAuthority?: boolean;
   createdBy: string;
   isCanary?: boolean;
+  v2Status?: IBaseV2StatusVo;
 
   constructor(base: IGetBaseVo) {
     const {
@@ -26,6 +32,7 @@ export class Base implements IGetBaseVo {
       enabledAuthority,
       createdBy,
       isCanary,
+      v2Status,
     } = base;
     this.id = id;
     this.name = name;
@@ -37,6 +44,7 @@ export class Base implements IGetBaseVo {
     this.enabledAuthority = enabledAuthority;
     this.createdBy = createdBy;
     this.isCanary = isCanary;
+    this.v2Status = v2Status;
   }
 
   async createTable(tableRo?: ICreateTableRo) {
diff --git a/packages/v2/adapter-repository-postgres/src/repositories/PostgresTableRepository.helpers.spec.ts b/packages/v2/adapter-repository-postgres/src/repositories/PostgresTableRepository.helpers.spec.ts
index b4065c400b..5efd6bb2fc 100644
--- a/packages/v2/adapter-repository-postgres/src/repositories/PostgresTableRepository.helpers.spec.ts
+++ b/packages/v2/adapter-repository-postgres/src/repositories/PostgresTableRepository.helpers.spec.ts
@@ -39,12 +39,16 @@ describe('PostgresTableRepository helpers', () => {
     expect(legacy.choices[0].name).toBe('Todo');
 
     const modern = repo.normalizeSelectOptions({
-      choices: [{ id: '', name: 'Ready', color: 'invalid' }],
+      choices: [
+        { id: '', name: 'Ready', color: 'invalid' },
+        { id: 'choReadyTrimmed', name: ' Ready ', color: 'blue' },
+      ],
       defaultValue: 'ready',
       preventAutoNewOptions: true,
     });
     expect(modern.defaultValue).toBe('ready');
     expect(modern.preventAutoNewOptions).toBe(true);
+    expect(modern.choices).toHaveLength(1);
     expect(modern.choices[0].id).toMatch(/^cho/);
 
     expect(repo.resolveSortColumn({ toString: () => 'name' })).toBe('name');
diff --git a/packages/v2/adapter-repository-postgres/src/repositories/PostgresTableRepository.ts b/packages/v2/adapter-repository-postgres/src/repositories/PostgresTableRepository.ts
index c2c5b004f8..a0af079074 100644
--- a/packages/v2/adapter-repository-postgres/src/repositories/PostgresTableRepository.ts
+++ b/packages/v2/adapter-repository-postgres/src/repositories/PostgresTableRepository.ts
@@ -35,6 +35,22 @@ const formatSpecDetails = (specInfo: TableWhereSpecInfo): string => {
   return parts.join(' ');
 };
 
+type SelectChoiceDto = { id: string; name: string; color: string };
+
+const deduplicateSelectChoices = (
+  choices: ReadonlyArray<SelectChoiceDto>
+): ReadonlyArray<SelectChoiceDto> => {
+  const seen = new Set<string>();
+  const deduped: SelectChoiceDto[] = [];
+  for (const choice of choices) {
+    const normalizedName = choice.name.trim();
+    if (seen.has(normalizedName)) continue;
+    seen.add(normalizedName);
+    deduped.push(choice);
+  }
+  return deduped;
+};
+
 const v1SymbolOperatorMap: Record<string, string> = {
   '=': 'is',
   '!=': 'isNot',
@@ -1904,7 +1920,7 @@ export class PostgresTableRepository implements core.ITableRepository {
   }
 
   private normalizeSelectOptions(raw: Record<string, unknown>): {
-    choices: ReadonlyArray<{ id: string; name: string; color: string }>;
+    choices: ReadonlyArray<SelectChoiceDto>;
     defaultValue?: string | ReadonlyArray<string>;
     preventAutoNewOptions?: boolean;
   } {
@@ -1921,7 +1937,7 @@ export class PostgresTableRepository implements core.ITableRepository {
         name: String(name),
         color: normalizeColor(undefined, index),
       }));
-      return { choices };
+      return { choices: deduplicateSelectChoices(choices) };
     }
 
     const choices = Array.isArray(raw.choices)
@@ -1943,7 +1959,7 @@ export class PostgresTableRepository implements core.ITableRepository {
       typeof raw.preventAutoNewOptions === 'boolean' ? raw.preventAutoNewOptions : undefined;
 
     return {
-      choices: choices as ReadonlyArray<{ id: string; name: string; color: string }>,
+      choices: deduplicateSelectChoices(choices),
       ...(defaultValue !== undefined ? { defaultValue: defaultValue as string | string[] } : {}),
       ...(preventAutoNewOptions !== undefined ? { preventAutoNewOptions } : {}),
     };
diff --git a/packages/v2/adapter-table-repository-postgres/src/integration/commands/RecordSearchExplain.db.spec.ts b/packages/v2/adapter-table-repository-postgres/src/integration/commands/RecordSearchExplain.db.spec.ts
new file mode 100644
index 0000000000..dd17a65f7d
--- /dev/null
+++ b/packages/v2/adapter-table-repository-postgres/src/integration/commands/RecordSearchExplain.db.spec.ts
@@ -0,0 +1,237 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { v2PostgresDbTokens } from '@teable/v2-adapter-db-postgres-pg';
+import { createV2NodeTestContainer } from '@teable/v2-container-node-test';
+import {
+  ActorId,
+  CreateFieldCommand,
+  CreateRecordCommand,
+  CreateTableCommand,
+  type CreateFieldResult,
+  type CreateRecordResult,
+  type CreateTableResult,
+  type Field,
+  type ICommandBus,
+  RecordSearch,
+  type Table,
+  v2CoreTokens,
+} from '@teable/v2-core';
+import type { V1TeableDatabase } from '@teable/v2-postgres-schema';
+import type { CompiledQuery, Expression, Kysely, SqlBool } from 'kysely';
+import { sql } from 'kysely';
+import { beforeEach, describe, expect, it } from 'vitest';
+
+import { buildRecordSearchWhereClause } from '../../record/repository/RecordSearchWhereBuilder';
+import { getV2NodeTestContainer, setV2NodeTestContainer } from '../testkit/v2NodeTestContainer';
+
+type ExplainNode = {
+  'Node Type'?: string;
+  Plans?: ExplainNode[];
+};
+
+type ExplainOutput = {
+  Plan: ExplainNode;
+};
+
+const createContext = () => {
+  const actorIdResult = ActorId.create('system');
+  return { actorId: actorIdResult._unsafeUnwrap() };
+};
+
+const getDbTableLocation = (table: Table, defaultSchema: string) => {
+  const dbTableName = table.dbTableName()._unsafeUnwrap().split({ defaultSchema })._unsafeUnwrap();
+  return {
+    schemaName: dbTableName.schema ?? defaultSchema,
+    tableName: dbTableName.tableName,
+    fullTableName: `${dbTableName.schema ?? defaultSchema}.${dbTableName.tableName}`,
+  };
+};
+
+const getFieldByName = (table: Table, name: string): Field => {
+  return table.getField((candidate) => candidate.name().toString() === name)._unsafeUnwrap();
+};
+
+const compileDateSearchQuery = ({
+  db,
+  table,
+  fullTableName,
+  fieldId,
+  value,
+}: {
+  db: Kysely<V1TeableDatabase>;
+  table: Table;
+  fullTableName: string;
+  fieldId: string;
+  value: string;
+}): CompiledQuery => {
+  const whereClause = buildRecordSearchWhereClause(
+    table,
+    {
+      search: RecordSearch.fromTuple([value, fieldId, true]),
+    },
+    {
+      tableAlias: 't',
+    }
+  )._unsafeUnwrap();
+
+  let query = db.selectFrom(`${fullTableName} as t`).select('t.__id as id');
+  if (whereClause != null) {
+    query = query.where(whereClause as Expression<SqlBool>);
+  }
+
+  return query.compile();
+};
+
+const findMatchingRecordIds = async ({
+  db,
+  compiled,
+}: {
+  db: Kysely<V1TeableDatabase>;
+  compiled: CompiledQuery;
+}) => {
+  const rows = await db.executeQuery<{ id: string }>({
+    ...compiled,
+    parameters: [...compiled.parameters],
+  });
+
+  return rows.rows.map((row) => row.id);
+};
+
+const explainQueryPlan = async ({
+  db,
+  compiled,
+}: {
+  db: Kysely<V1TeableDatabase>;
+  compiled: CompiledQuery;
+}): Promise<ExplainOutput> => {
+  const rows = await db.transaction().execute(async (trx) => {
+    await trx.executeQuery(sql.raw('SET LOCAL enable_seqscan = off').compile(trx));
+    const explainQuery = sql`EXPLAIN (FORMAT JSON) ${sql.raw(compiled.sql)}`.compile(trx);
+    return trx.executeQuery<{ 'QUERY PLAN': string | object }>({
+      ...explainQuery,
+      parameters: [...compiled.parameters],
+    });
+  });
+
+  const rawPlan = rows.rows[0]?.['QUERY PLAN'];
+  if (rawPlan == null) {
+    throw new Error('Missing EXPLAIN output');
+  }
+
+  if (typeof rawPlan === 'object') {
+    return (Array.isArray(rawPlan) ? rawPlan[0] : rawPlan) as ExplainOutput;
+  }
+
+  return (JSON.parse(rawPlan) as ExplainOutput[])[0] as ExplainOutput;
+};
+
+const flattenNodeTypes = (node: ExplainNode): string[] => {
+  const nodeType = node['Node Type'] ? [node['Node Type']] : [];
+  const childTypes = node.Plans?.flatMap(flattenNodeTypes) ?? [];
+  return [...nodeType, ...childTypes];
+};
+
+describe('RecordSearch EXPLAIN (db)', () => {
+  beforeEach(async () => {
+    setV2NodeTestContainer(await createV2NodeTestContainer());
+  });
+
+  it('uses the datetime search index for field-specific date search', async () => {
+    const { container, baseId } = getV2NodeTestContainer();
+    const commandBus = container.resolve<ICommandBus>(v2CoreTokens.commandBus);
+    const db = container.resolve<Kysely<V1TeableDatabase>>(v2PostgresDbTokens.db);
+    const context = createContext();
+
+    const createTableResult = CreateTableCommand.create({
+      baseId: baseId.toString(),
+      name: 'Search Explain',
+      fields: [{ type: 'singleLineText', name: 'Title', isPrimary: true }],
+      views: [{ type: 'grid' }],
+    })._unsafeUnwrap();
+
+    const createdTableResult = await commandBus.execute<CreateTableCommand, CreateTableResult>(
+      context,
+      createTableResult
+    );
+    const createdTable = createdTableResult._unsafeUnwrap().table;
+    const titleField = getFieldByName(createdTable, 'Title');
+    const titleDbFieldName = titleField.dbFieldName()._unsafeUnwrap().value()._unsafeUnwrap();
+    const { schemaName, tableName, fullTableName } = getDbTableLocation(
+      createdTable,
+      baseId.toString()
+    );
+
+    await sql
+      .raw(
+        `CREATE INDEX "idx_trgm_bootstrap_date_search" ON "${schemaName}"."${tableName}" USING btree ("${titleDbFieldName}")`
+      )
+      .execute(db);
+
+    const createFieldResult = CreateFieldCommand.create({
+      baseId: baseId.toString(),
+      tableId: createdTable.id().toString(),
+      field: {
+        type: 'date',
+        name: 'Due',
+      },
+    })._unsafeUnwrap();
+
+    const updatedTableResult = await commandBus.execute<CreateFieldCommand, CreateFieldResult>(
+      context,
+      createFieldResult
+    );
+    const updatedTable = updatedTableResult._unsafeUnwrap().table;
+    const dueField = getFieldByName(updatedTable, 'Due');
+    const dueFieldId = dueField.id().toString();
+    const dueDbFieldName = dueField.dbFieldName()._unsafeUnwrap().value()._unsafeUnwrap();
+
+    const dateIndexRows = await sql<{ indexdef: string }>`
+      SELECT indexdef
+      FROM pg_indexes
+      WHERE schemaname = ${schemaName}
+        AND tablename = ${tableName}
+        AND indexname LIKE 'idx_trgm%'
+        AND indexdef LIKE ${`%USING btree ("${dueDbFieldName}")%`}
+    `.execute(db);
+
+    expect(dateIndexRows.rows).toHaveLength(1);
+
+    const records = [
+      { title: 'Alpha', due: '2026-02-23T00:00:00.000Z' },
+      { title: 'Bravo', due: '2026-02-24T00:00:00.000Z' },
+      { title: 'Charlie', due: '2026-02-25T00:00:00.000Z' },
+    ];
+
+    for (const record of records) {
+      const createRecordResult = CreateRecordCommand.create({
+        tableId: updatedTable.id().toString(),
+        fields: {
+          [titleField.id().toString()]: record.title,
+          [dueFieldId]: record.due,
+        },
+      })._unsafeUnwrap();
+
+      const execResult = await commandBus.execute<CreateRecordCommand, CreateRecordResult>(
+        context,
+        createRecordResult
+      );
+      execResult._unsafeUnwrap();
+    }
+
+    const compiled = compileDateSearchQuery({
+      db,
+      table: updatedTable,
+      fullTableName,
+      fieldId: dueFieldId,
+      value: '2026-02-24',
+    });
+
+    const matchingIds = await findMatchingRecordIds({ db, compiled });
+    expect(matchingIds).toHaveLength(1);
+
+    const explain = await explainQueryPlan({ db, compiled });
+    const nodeTypes = flattenNodeTypes(explain.Plan);
+
+    expect(nodeTypes.some((nodeType) => nodeType.includes('Index'))).toBe(true);
+    expect(nodeTypes.every((nodeType) => nodeType !== 'Seq Scan')).toBe(true);
+  });
+});
diff --git a/packages/v2/adapter-table-repository-postgres/src/meta/MetaChecker.spec.ts b/packages/v2/adapter-table-repository-postgres/src/meta/MetaChecker.spec.ts
index db274bf34a..91ead5ed83 100644
--- a/packages/v2/adapter-table-repository-postgres/src/meta/MetaChecker.spec.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/meta/MetaChecker.spec.ts
@@ -25,10 +25,12 @@ const createField = (params: {
   name: string;
   type: string;
   accept: () => ReturnType<typeof ok> | ReturnType<typeof err>;
+  hasError?: boolean;
 }) => ({
   id: () => asId(params.id),
   name: () => asId(params.name),
   type: () => asId(params.type),
+  hasError: () => ({ isError: () => params.hasError === true }),
   accept: params.accept,
 });
 
@@ -188,4 +190,35 @@ describe('MetaChecker', () => {
     expect(standaloneIssues).toEqual([{ fieldId: 'fld9', message: 'healthy' }]);
     expect(standaloneWithTablesIssues).toEqual([{ fieldId: 'fld9', message: 'healthy' }]);
   });
+
+  it('skips fields already marked hasError in standalone table checks', async () => {
+    const { checkTableMetaWithTables } = await loadMetaCheckerModule();
+    const accept = vi.fn(() => ok([{ fieldId: 'fldBroken', message: 'should not emit' }]));
+    const table = createTable({
+      id: 'tblHasError',
+      name: 'Stories',
+      fields: [
+        createField({
+          id: 'fldBroken',
+          name: 'Broken Lookup',
+          type: 'lookup',
+          hasError: true,
+          accept,
+        }),
+      ],
+    });
+
+    mocks.createMetaValidationContextFromTables.mockReturnValue({ table });
+
+    const issues = await collect(
+      checkTableMetaWithTables(
+        table as never,
+        BaseId.create(`bse${'f'.repeat(16)}`)._unsafeUnwrap(),
+        [table as never]
+      )
+    );
+
+    expect(issues).toEqual([]);
+    expect(accept).not.toHaveBeenCalled();
+  });
 });
diff --git a/packages/v2/adapter-table-repository-postgres/src/meta/MetaChecker.ts b/packages/v2/adapter-table-repository-postgres/src/meta/MetaChecker.ts
index 2145687d35..1d26a9aa87 100644
--- a/packages/v2/adapter-table-repository-postgres/src/meta/MetaChecker.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/meta/MetaChecker.ts
@@ -97,6 +97,11 @@ export class MetaChecker {
     const visitor = new MetaValidationVisitor(ctx);
 
     for (const field of table.getFields()) {
+      const hasError = typeof field.hasError === 'function' ? field.hasError().isError() : false;
+      if (hasError) {
+        continue;
+      }
+
       try {
         const issuesResult = field.accept(visitor);
 
@@ -224,6 +229,11 @@ export async function* checkTableMetaWithTables(
   const visitor = new MetaValidationVisitor(ctx);
 
   for (const field of table.getFields()) {
+    const hasError = typeof field.hasError === 'function' ? field.hasError().isError() : false;
+    if (hasError) {
+      continue;
+    }
+
     try {
       const issuesResult = field.accept(visitor);
       if (issuesResult.isErr()) {
diff --git a/packages/v2/adapter-table-repository-postgres/src/meta/MetaRepairer.spec.ts b/packages/v2/adapter-table-repository-postgres/src/meta/MetaRepairer.spec.ts
new file mode 100644
index 0000000000..20cfeb19da
--- /dev/null
+++ b/packages/v2/adapter-table-repository-postgres/src/meta/MetaRepairer.spec.ts
@@ -0,0 +1,144 @@
+import { ok } from 'neverthrow';
+import { describe, expect, it, vi } from 'vitest';
+
+import { createMetaRepairer, getMetaRuleId, type MetaValidationIssue } from './index';
+
+const metaFieldId = 'fldMetaRepair0001';
+
+const asId = (value: string) => ({
+  toString: () => value,
+});
+
+const createMetaIssue = (): MetaValidationIssue => ({
+  fieldId: metaFieldId,
+  fieldName: 'Status',
+  fieldType: 'lookup',
+  category: 'reference',
+  severity: 'error',
+  message: 'Link field not found: fldMissing',
+  details: {
+    relatedFieldId: 'fldMissing',
+  },
+});
+
+const createField = (issue: MetaValidationIssue) => {
+  let hasError = false;
+
+  return {
+    id: () => asId(issue.fieldId),
+    name: () => asId(issue.fieldName),
+    type: () => asId(issue.fieldType),
+    hasError: () => ({ isError: () => hasError }),
+    setHasError: () => {
+      hasError = true;
+    },
+    getHasError: () => hasError,
+    accept: () => ok([issue]),
+  };
+};
+
+const createTable = (fields: ReturnType<typeof createField>[]) =>
+  ({
+    id: () => asId('tblMetaRepair0001'),
+    name: () => asId('Tasks'),
+    baseId: () => asId('bseMetaRepair0001'),
+    getFields: () => fields,
+  }) as never;
+
+const createFakeDb = () => {
+  const execute = vi.fn().mockResolvedValue([]);
+  const compile = vi.fn(() => ({
+    sql: 'update "field" set "has_error" = $1 where "id" = $2',
+    parameters: [true, metaFieldId],
+  }));
+  const where = vi.fn(() => ({ compile, execute }));
+  const set = vi.fn(() => ({ where }));
+  const updateTable = vi.fn(() => ({ set }));
+
+  return {
+    compile,
+    db: { updateTable },
+    execute,
+    set,
+    updateTable,
+    where,
+  };
+};
+
+const collect = async <T>(stream: AsyncGenerator<T, void, unknown>): Promise<T[]> => {
+  const results: T[] = [];
+  for await (const result of stream) {
+    results.push(result);
+  }
+  return results;
+};
+
+describe('MetaRepairer', () => {
+  it('repairs metadata reference issues by setting field has_error', async () => {
+    const issue = createMetaIssue();
+    const field = createField(issue);
+    const table = createTable([field]);
+    const fakeDb = createFakeDb();
+    const repairer = createMetaRepairer({ db: fakeDb.db as never });
+
+    const results = await collect(
+      repairer.repairRule(table, [table], issue.fieldId, getMetaRuleId(issue), {
+        targetStatuses: ['error'],
+      })
+    );
+
+    expect(results.map((result) => result.status)).toEqual(['running', 'success']);
+    expect(results[0]).toMatchObject({
+      fieldId: issue.fieldId,
+      ruleId: 'meta:reference',
+      repair: {
+        available: true,
+        mode: 'auto',
+      },
+    });
+    expect(results[1]).toMatchObject({
+      fieldId: issue.fieldId,
+      ruleId: 'meta:reference',
+      outcome: 'repaired',
+      message: 'Field marked hasError',
+      details: {
+        missing: ['fldMissing'],
+      },
+    });
+    expect(fakeDb.updateTable).toHaveBeenCalledWith('field');
+    expect(fakeDb.set).toHaveBeenCalledWith({ has_error: true });
+    expect(fakeDb.where).toHaveBeenCalledWith('id', '=', issue.fieldId);
+    expect(field.getHasError()).toBe(true);
+  });
+
+  it('supports dry run without mutating field has_error', async () => {
+    const issue = createMetaIssue();
+    const field = createField(issue);
+    const table = createTable([field]);
+    const fakeDb = createFakeDb();
+    const repairer = createMetaRepairer({ db: fakeDb.db as never });
+
+    const results = await collect(
+      repairer.repairField(table, [table], issue.fieldId, {
+        dryRun: true,
+      })
+    );
+
+    expect(results.map((result) => result.status)).toEqual(['running', 'success']);
+    expect(results[1]).toMatchObject({
+      outcome: 'repaired',
+      message: 'Dry run: field will be marked hasError',
+      details: {
+        statementCount: 1,
+        statements: [
+          {
+            sql: 'update "field" set "has_error" = $1 where "id" = $2',
+            parameters: [true, metaFieldId],
+          },
+        ],
+      },
+    });
+    expect(fakeDb.execute).not.toHaveBeenCalled();
+    expect(field.getHasError()).toBe(false);
+  });
+});
diff --git a/packages/v2/adapter-table-repository-postgres/src/meta/MetaRepairer.ts b/packages/v2/adapter-table-repository-postgres/src/meta/MetaRepairer.ts
new file mode 100644
index 0000000000..b8b167035a
--- /dev/null
+++ b/packages/v2/adapter-table-repository-postgres/src/meta/MetaRepairer.ts
@@ -0,0 +1,232 @@
+import { FieldHasError, type Table } from '@teable/v2-core';
+import type { V1TeableDatabase } from '@teable/v2-postgres-schema';
+import type { Kysely } from 'kysely';
+
+import type { SchemaRuleRepairHint } from '../schema/rules/core/ISchemaRule';
+import type { SchemaRepairOptions } from '../schema/rules/repairer/SchemaRepairer';
+import {
+  errorResult,
+  pendingResult,
+  runningResult,
+  skippedResult,
+  successResult,
+  type SchemaRepairDetails,
+  type SchemaRepairResult,
+} from '../schema/rules/repairer/SchemaRepairResult';
+import { checkTableMetaWithTables } from './MetaChecker';
+import type { MetaValidationIssue, MetaValidationSeverity } from './MetaValidationResult';
+
+export const metaRuleDescription = 'Metadata reference validation';
+export const metaRuleIdPrefix = 'meta:';
+
+export interface MetaRepairerParams {
+  readonly db: Kysely<V1TeableDatabase>;
+}
+
+export interface MetaRepairTarget {
+  readonly fieldId?: string;
+  readonly ruleId?: string;
+}
+
+export type MetaRepairOptions = Pick<SchemaRepairOptions, 'dryRun' | 'targetStatuses'>;
+
+export const getMetaRuleId = (issue: Pick<MetaValidationIssue, 'category'>): string =>
+  `${metaRuleIdPrefix}${issue.category}`;
+
+export const isMetaRuleId = (ruleId: string | undefined): ruleId is string =>
+  Boolean(ruleId?.startsWith(metaRuleIdPrefix));
+
+export const getMetaIssueDetails = (
+  issue: MetaValidationIssue
+): SchemaRepairDetails | undefined => {
+  const missing = [
+    issue.details?.relatedTableId,
+    issue.details?.relatedFieldId,
+    issue.details?.path,
+  ].filter((value): value is string => Boolean(value));
+
+  return missing.length ? { missing } : undefined;
+};
+
+export const getMetaRepairHint = (issue: MetaValidationIssue): SchemaRuleRepairHint => ({
+  available: true,
+  mode: 'auto',
+  reason: {
+    fallback: `Automatic repair will mark "${issue.fieldName}" as hasError.`,
+  },
+  description: {
+    fallback:
+      'This keeps the broken computed field from participating in computed SQL until its metadata references are fixed manually.',
+  },
+});
+
+export class MetaRepairer {
+  constructor(private readonly params: MetaRepairerParams) {}
+
+  async *repairTable(
+    table: Table,
+    allTables: ReadonlyArray<Table>,
+    options: MetaRepairOptions = {}
+  ): AsyncGenerator<SchemaRepairResult, void, unknown> {
+    yield* this.repairInternal(table, allTables, {}, options);
+  }
+
+  async *repairField(
+    table: Table,
+    allTables: ReadonlyArray<Table>,
+    fieldId: string,
+    options: MetaRepairOptions = {}
+  ): AsyncGenerator<SchemaRepairResult, void, unknown> {
+    yield* this.repairInternal(table, allTables, { fieldId }, options);
+  }
+
+  async *repairRule(
+    table: Table,
+    allTables: ReadonlyArray<Table>,
+    fieldId: string,
+    ruleId: string,
+    options: MetaRepairOptions = {}
+  ): AsyncGenerator<SchemaRepairResult, void, unknown> {
+    yield* this.repairInternal(table, allTables, { fieldId, ruleId }, options);
+  }
+
+  private async *repairInternal(
+    table: Table,
+    allTables: ReadonlyArray<Table>,
+    target: MetaRepairTarget,
+    options: MetaRepairOptions
+  ): AsyncGenerator<SchemaRepairResult, void, unknown> {
+    const repairedFieldIds = new Set<string>();
+
+    for await (const issue of checkTableMetaWithTables(table, table.baseId(), allTables)) {
+      const currentStatus = toRepairableMetaStatus(issue.severity);
+      if (!currentStatus || !matchesMetaRepairTarget(issue, target)) {
+        continue;
+      }
+
+      const pending = createMetaRepairPending(issue);
+      const details = getMetaIssueDetails(issue);
+      const repair = getMetaRepairHint(issue);
+
+      yield withRepair(runningResult(pending), repair);
+
+      if (shouldSkipRepairStatus(currentStatus, options.targetStatuses)) {
+        yield withRepair(
+          skippedResult(pending, 'Skipped: status not selected for repair', details),
+          repair
+        );
+        continue;
+      }
+
+      if (repairedFieldIds.has(issue.fieldId)) {
+        yield withRepair(
+          successResult(pending, 'Field already marked hasError', 'unchanged', details),
+          repair
+        );
+        continue;
+      }
+
+      if (options.dryRun) {
+        repairedFieldIds.add(issue.fieldId);
+        const compiled = this.createMarkFieldHasErrorQuery(issue).compile();
+        yield withRepair(
+          successResult(pending, 'Dry run: field will be marked hasError', 'repaired', {
+            ...details,
+            statementCount: 1,
+            statements: [
+              {
+                sql: compiled.sql,
+                parameters: compiled.parameters,
+              },
+            ],
+          }),
+          repair
+        );
+        continue;
+      }
+
+      const repairResult = await this.markFieldHasError(table, issue, pending, details, repair);
+      yield repairResult;
+      if (repairResult.status === 'success') {
+        repairedFieldIds.add(issue.fieldId);
+      }
+    }
+  }
+
+  private async markFieldHasError(
+    table: Table,
+    issue: MetaValidationIssue,
+    pending: SchemaRepairResult,
+    details: SchemaRepairDetails | undefined,
+    repair: SchemaRuleRepairHint
+  ): Promise<SchemaRepairResult> {
+    try {
+      await this.createMarkFieldHasErrorQuery(issue).execute();
+
+      table
+        .getFields()
+        .find((field) => field.id().toString() === issue.fieldId)
+        ?.setHasError(FieldHasError.error());
+
+      return withRepair(
+        successResult(pending, 'Field marked hasError', 'repaired', {
+          ...details,
+          statementCount: 1,
+        }),
+        repair
+      );
+    } catch (error) {
+      return withRepair(
+        errorResult(
+          pending,
+          error instanceof Error ? error.message : 'Unknown error during meta repair',
+          details
+        ),
+        repair
+      );
+    }
+  }
+
+  private createMarkFieldHasErrorQuery(issue: MetaValidationIssue) {
+    return this.params.db
+      .updateTable('field')
+      .set({ has_error: true })
+      .where('id', '=', issue.fieldId);
+  }
+}
+
+export const createMetaRepairer = (params: MetaRepairerParams): MetaRepairer =>
+  new MetaRepairer(params);
+
+const createMetaRepairPending = (issue: MetaValidationIssue): SchemaRepairResult =>
+  pendingResult(issue.fieldId, issue.fieldName, getMetaRuleId(issue), metaRuleDescription, true);
+
+const toRepairableMetaStatus = (severity: MetaValidationSeverity): 'warn' | 'error' | undefined => {
+  if (severity === 'error') {
+    return 'error';
+  }
+  if (severity === 'warning') {
+    return 'warn';
+  }
+};
+
+const matchesMetaRepairTarget = (issue: MetaValidationIssue, target: MetaRepairTarget): boolean => {
+  if (target.fieldId && issue.fieldId !== target.fieldId) {
+    return false;
+  }
+
+  return !target.ruleId || getMetaRuleId(issue) === target.ruleId;
+};
+
+const shouldSkipRepairStatus = (
+  status: 'warn' | 'error',
+  targetStatuses?: ReadonlyArray<'warn' | 'error'>
+): boolean => Boolean(targetStatuses?.length && !targetStatuses.includes(status));
+
+const withRepair = (
+  result: SchemaRepairResult,
+  repair: SchemaRuleRepairHint
+): SchemaRepairResult => ({
+  ...result,
+  repair,
+});
diff --git a/packages/v2/adapter-table-repository-postgres/src/meta/index.ts b/packages/v2/adapter-table-repository-postgres/src/meta/index.ts
index b0779e6814..129655c3c2 100644
--- a/packages/v2/adapter-table-repository-postgres/src/meta/index.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/meta/index.ts
@@ -11,6 +11,20 @@ export {
   type IMetaValidationContext,
 } from './MetaValidationContext';
 
+export {
+  createMetaRepairer,
+  getMetaIssueDetails,
+  getMetaRepairHint,
+  getMetaRuleId,
+  isMetaRuleId,
+  MetaRepairer,
+  metaRuleDescription,
+  metaRuleIdPrefix,
+  type MetaRepairerParams,
+  type MetaRepairOptions,
+  type MetaRepairTarget,
+} from './MetaRepairer';
+
 export type {
   MetaValidationCategory,
   MetaValidationSeverity,
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/attachments/attachmentTableMutations.ts b/packages/v2/adapter-table-repository-postgres/src/record/attachments/attachmentTableMutations.ts
new file mode 100644
index 0000000000..1ef287bd19
--- /dev/null
+++ b/packages/v2/adapter-table-repository-postgres/src/record/attachments/attachmentTableMutations.ts
@@ -0,0 +1,94 @@
+import { generatePrefixedId } from '@teable/v2-core';
+import type { CompiledQuery, Kysely } from 'kysely';
+
+import type { DynamicDB } from '../query-builder';
+
+const ATTACHMENT_TABLE_ROW_ID_PREFIX = 'attt';
+const ATTACHMENT_TABLE_ROW_ID_LENGTH = 16;
+
+type AttachmentItemLike = {
+  id?: string;
+  token?: string;
+  name?: string;
+};
+
+const normalizeAttachmentItems = (value: unknown): AttachmentItemLike[] => {
+  if (Array.isArray(value)) {
+    return value as AttachmentItemLike[];
+  }
+  if (value && typeof value === 'object') {
+    return [value as AttachmentItemLike];
+  }
+  return [];
+};
+
+const toAttachmentTableRows = (params: {
+  actorId: string;
+  tableId: string;
+  recordId: string;
+  fieldId: string;
+  value: unknown;
+}) => {
+  const { actorId, tableId, recordId, fieldId, value } = params;
+
+  return normalizeAttachmentItems(value)
+    .map((item) => {
+      const attachmentId = item.id ? String(item.id) : '';
+      const token = item.token ? String(item.token) : '';
+      if (!attachmentId || !token) {
+        return null;
+      }
+
+      return {
+        id: generatePrefixedId(ATTACHMENT_TABLE_ROW_ID_PREFIX, ATTACHMENT_TABLE_ROW_ID_LENGTH),
+        attachment_id: attachmentId,
+        token,
+        name: item.name ? String(item.name) : '',
+        table_id: tableId,
+        record_id: recordId,
+        field_id: fieldId,
+        created_by: actorId,
+      };
+    })
+    .filter((row): row is NonNullable<typeof row> => row !== null);
+};
+
+export const buildAttachmentTableInsertQuery = (
+  db: Kysely<DynamicDB>,
+  params: {
+    actorId: string;
+    tableId: string;
+    recordId: string;
+    fieldId: string;
+    value: unknown;
+  }
+): CompiledQuery | undefined => {
+  const rows = toAttachmentTableRows(params);
+  if (rows.length === 0) {
+    return undefined;
+  }
+
+  return db.insertInto('attachments_table').values(rows).compile();
+};
+
+export const buildAttachmentTableReplaceQueries = (
+  db: Kysely<DynamicDB>,
+  params: {
+    actorId: string;
+    tableId: string;
+    recordId: string;
+    fieldId: string;
+    value: unknown;
+  }
+): CompiledQuery[] => {
+  const deleteQuery = db
+    .deleteFrom('attachments_table')
+    .where('table_id', '=', params.tableId)
+    .where('record_id', '=', params.recordId)
+    .where('field_id', '=', params.fieldId)
+    .compile();
+
+  const insertQuery = buildAttachmentTableInsertQuery(db, params);
+
+  return insertQuery ? [deleteQuery, insertQuery] : [deleteQuery];
+};
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/computed/ComputedFieldUpdater.ts b/packages/v2/adapter-table-repository-postgres/src/record/computed/ComputedFieldUpdater.ts
index be573ce775..4828a8ff99 100644
--- a/packages/v2/adapter-table-repository-postgres/src/record/computed/ComputedFieldUpdater.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/record/computed/ComputedFieldUpdater.ts
@@ -1799,6 +1799,14 @@ type PreparedPropagationSelect = {
 const propagationQueryKey = (compiled: ReturnType<DirtySelectQuery['compile']>): string =>
   `${compiled.sql}::${JSON.stringify(compiled.parameters)}`;
 
+const toAffectedRowCount = (value: unknown): number | undefined => {
+  if (typeof value === 'bigint') {
+    return value > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(value);
+  }
+  if (typeof value === 'number') return value;
+  return undefined;
+};
+
 const propagateDirtyRecords = async (
   db: Kysely<DynamicDB>,
   edges: ReadonlyArray<ComputedDependencyEdge>,
@@ -1806,14 +1814,6 @@ const propagateDirtyRecords = async (
   context?: IExecutionContext
 ): Promise<Result<DirtyPropagationStats, DomainError>> => {
   try {
-    const countDirtyRecords = async (): Promise<number> => {
-      const result = await db
-        .selectFrom(DIRTY_TABLE)
-        .select(sql<number>`count(*)`.as('count'))
-        .executeTakeFirst();
-      return result ? Number(result.count) : 0;
-    };
-
     // Build trace info for all edges once
     const edgeTraceInfos = edges.map((edge, i) => buildEdgeTraceInfo(edge, i, tableById));
     const plannedAllTargetReasonCounts = countPlannedAllTargetReasonCounts(edges);
@@ -1852,7 +1852,6 @@ const propagateDirtyRecords = async (
 
     const selectQueries = [...preparedQueries.values()];
     const maxPasses = Math.max(selectQueries.length, 1);
-    let previousCount = await countDirtyRecords();
 
     for (let pass = 0; pass < maxPasses; pass += 1) {
       if (selectQueries.length === 0) {
@@ -1902,7 +1901,7 @@ const propagateDirtyRecords = async (
         );
       }
 
-      const executeBatchWork = async (): Promise<void> => {
+      const executeBatchWork = async (): Promise<number | undefined> => {
         // Build UNION ALL query from all SELECT queries
         if (selectQueries.length === 1) {
           // Single edge - no need for UNION ALL
@@ -1914,7 +1913,8 @@ const propagateDirtyRecords = async (
             .compile();
 
           batchSpan?.setAttribute('batch.sql', compiled.sql);
-          await db.executeQuery(compiled);
+          const result = await db.executeQuery(compiled);
+          return toAffectedRowCount(result.numAffectedRows);
         } else {
           // Multiple edges - use UNION ALL
           // Start with first query, then chain unionAll for the rest
@@ -1931,26 +1931,29 @@ const propagateDirtyRecords = async (
             .compile();
 
           batchSpan?.setAttribute('batch.sql', compiled.sql);
-          await db.executeQuery(compiled);
+          const result = await db.executeQuery(compiled);
+          return toAffectedRowCount(result.numAffectedRows);
         }
       };
 
+      let insertedRowCount: number | undefined;
       try {
         // Use withSpan to set batchSpan as active context so pg queries become children
         if (batchSpan && context?.tracer) {
-          await context.tracer.withSpan(batchSpan, executeBatchWork);
+          insertedRowCount = await context.tracer.withSpan(batchSpan, executeBatchWork);
         } else {
-          await executeBatchWork();
+          insertedRowCount = await executeBatchWork();
         }
       } finally {
+        if (insertedRowCount !== undefined) {
+          batchSpan?.setAttribute('batch.insertedRowCount', insertedRowCount);
+        }
         batchSpan?.end();
       }
 
-      const nextCount = await countDirtyRecords();
-      if (nextCount === previousCount) {
+      if (insertedRowCount === 0) {
         break;
       }
-      previousCount = nextCount;
     }
     return ok({
       plannedAllTargetReasonCounts,
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/computed/ComputedUpdatePlanner.ts b/packages/v2/adapter-table-repository-postgres/src/record/computed/ComputedUpdatePlanner.ts
index 77d14e61a4..87fe421e76 100644
--- a/packages/v2/adapter-table-repository-postgres/src/record/computed/ComputedUpdatePlanner.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/record/computed/ComputedUpdatePlanner.ts
@@ -241,7 +241,12 @@ export class ComputedUpdatePlanner {
   ): Promise<Result<ComputedBeforeImageRequirements, DomainError>> {
     return safeTry<ComputedBeforeImageRequirements, DomainError>(
       async function* (this: ComputedUpdatePlanner) {
-        if (context.changeType === 'insert' || context.changedFieldIds.length === 0) {
+        const impactSeedFieldIds = collectImpactSeedFieldIds(
+          context.changedFieldIds,
+          context.impact
+        );
+
+        if (context.changeType === 'insert' || impactSeedFieldIds.length === 0) {
           return ok({
             needsBeforeImage: false,
             requiredFieldIds: [],
@@ -249,12 +254,12 @@ export class ComputedUpdatePlanner {
         }
 
         const graphData = yield* await this.graph.load(context.baseId, executionContext, {
-          requiredFieldIds: context.changedFieldIds,
+          requiredFieldIds: impactSeedFieldIds,
         });
         const { fieldsById, edges } = graphData;
 
         const impactResult = resolveUpdateImpact(fieldsById, {
-          changedFieldIds: context.changedFieldIds,
+          changedFieldIds: impactSeedFieldIds,
           changeType: context.changeType,
           impact: context.impact,
         });
@@ -266,7 +271,7 @@ export class ComputedUpdatePlanner {
             edges: collectRelevantEdgesForImpact(edges, impact),
             fieldsById,
             seedTableId: context.seedTableId,
-            changedFieldIds: context.changedFieldIds,
+            changedFieldIds: impactSeedFieldIds,
             changeType: context.changeType,
           })
         );
@@ -285,10 +290,14 @@ export class ComputedUpdatePlanner {
         // For INSERT, we need initial values for all stored computed fields, including those
         // that depend on "unprovided" (implicitly null) inputs, or have no dependencies at all.
         // Seed planning with all table fields so the incremental graph can include every computed field.
+        const impactSeedFieldIds = collectImpactSeedFieldIds(
+          context.changedFieldIds,
+          context.impact
+        );
         const planningSeedFieldIds =
           context.changeType === 'insert' && context.table
             ? context.table.getFields().map((field) => field.id())
-            : context.changedFieldIds;
+            : impactSeedFieldIds;
 
         const graphData = yield* await this.graph.load(context.baseId, executionContext, {
           requiredFieldIds: planningSeedFieldIds,
@@ -296,7 +305,10 @@ export class ComputedUpdatePlanner {
         const { fieldsById, edges } = graphData;
 
         const impactResult = resolveUpdateImpact(fieldsById, {
-          changedFieldIds: planningSeedFieldIds,
+          changedFieldIds:
+            context.changeType === 'insert' && context.table
+              ? planningSeedFieldIds
+              : impactSeedFieldIds,
           changeType: context.changeType,
           impact: context.impact,
         });
@@ -761,7 +773,7 @@ export class ComputedUpdatePlanner {
               .filter((group) => group.recordIds.length > 0)
               .map((group) => group.tableId.toString())
           ),
-          context.changedFieldIds,
+          impactSeedFieldIds,
           context.changeType,
           countSeedRecords(context.seedRecordIds, context.extraSeedRecords) > 0,
           beforeImageRecords
@@ -834,6 +846,26 @@ export class ComputedUpdatePlanner {
   }
 }
 
+const collectImpactSeedFieldIds = (
+  changedFieldIds: ReadonlyArray<FieldId>,
+  impact?: UpdateImpactHint
+): ReadonlyArray<FieldId> => {
+  if (!impact) return changedFieldIds;
+
+  const fieldIds = new Map<string, FieldId>();
+  for (const fieldId of changedFieldIds) {
+    fieldIds.set(fieldId.toString(), fieldId);
+  }
+  for (const fieldId of impact.valueFieldIds) {
+    fieldIds.set(fieldId.toString(), fieldId);
+  }
+  for (const fieldId of impact.linkFieldIds) {
+    fieldIds.set(fieldId.toString(), fieldId);
+  }
+
+  return [...fieldIds.values()];
+};
+
 const resolveUpdateImpact = (
   fieldsById: Map<string, FieldMeta>,
   context: UpdateImpactContext
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/computed/__tests__/ComputedFieldUpdater.spec.ts b/packages/v2/adapter-table-repository-postgres/src/record/computed/__tests__/ComputedFieldUpdater.spec.ts
index 8240acabd7..96edb79bcf 100644
--- a/packages/v2/adapter-table-repository-postgres/src/record/computed/__tests__/ComputedFieldUpdater.spec.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/record/computed/__tests__/ComputedFieldUpdater.spec.ts
@@ -49,7 +49,7 @@ class RecordingConnection implements DatabaseConnection {
 
   async executeQuery<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>> {
     this.queries.push(compiledQuery);
-    return { rows: [] };
+    return { rows: [], numAffectedRows: BigInt(0) };
   }
 
   async *streamQuery<R>(): AsyncIterableIterator<QueryResult<R>> {
@@ -717,20 +717,12 @@ describe('ComputedFieldUpdater', () => {
           ],
           "sql": "insert into "tmp_computed_dirty" ("table_id", "record_id") values ($1, $2) on conflict ("table_id", "record_id") do nothing",
         },
-        {
-          "parameters": [],
-          "sql": "select count(*) as "count" from "tmp_computed_dirty"",
-        },
         {
           "parameters": [
             "tblcccccccccccccccc",
           ],
           "sql": "insert into "tmp_computed_dirty" ("table_id", "record_id") select distinct 'tblbbbbbbbbbbbbbbbb' as "table_id", "j"."__fk_fldffffffffffffffff" as "record_id" from "bseaaaaaaaaaaaaaaaa"."junction_fldeeeeeeeeeeeeeeee_fldffffffffffffffff" as "j" inner join "tmp_computed_dirty" as "d" on "d"."record_id" = "j"."__fk_fldeeeeeeeeeeeeeeee" where "d"."table_id" = $1 on conflict ("table_id", "record_id") do nothing",
         },
-        {
-          "parameters": [],
-          "sql": "select count(*) as "count" from "tmp_computed_dirty"",
-        },
         {
           "parameters": [],
           "sql": "select "table_id" as "tableId", count(*) as "recordCount" from "tmp_computed_dirty" group by "table_id"",
@@ -1122,10 +1114,6 @@ describe('ComputedFieldUpdater', () => {
           ],
           "sql": "insert into "tmp_computed_dirty" ("table_id", "record_id") values ($1, $2) on conflict ("table_id", "record_id") do nothing",
         },
-        {
-          "parameters": [],
-          "sql": "select count(*) as "count" from "tmp_computed_dirty"",
-        },
         {
           "parameters": [
             "tblkkkkkkkkkkkkkkkk",
@@ -1133,10 +1121,6 @@ describe('ComputedFieldUpdater', () => {
           ],
           "sql": "insert into "tmp_computed_dirty" ("table_id", "record_id") select distinct 'tblllllllllllllllll' as "table_id", "t"."__id" as "record_id" from "bseaaaaaaaaaaaaaaaa"."tblllllllllllllllll" as "t" inner join "tmp_computed_dirty" as "d" on "d"."record_id" = "t"."__fk_fldpppppppppppppppp" where "d"."table_id" = $1 union all select distinct 'tblmmmmmmmmmmmmmmmm' as "table_id", "t"."__id" as "record_id" from "bseaaaaaaaaaaaaaaaa"."tblmmmmmmmmmmmmmmmm" as "t" inner join "tmp_computed_dirty" as "d" on "d"."record_id" = "t"."__fk_fldtttttttttttttttt" where "d"."table_id" = $2 on conflict ("table_id", "record_id") do nothing",
         },
-        {
-          "parameters": [],
-          "sql": "select count(*) as "count" from "tmp_computed_dirty"",
-        },
         {
           "parameters": [],
           "sql": "select "table_id" as "tableId", count(*) as "recordCount" from "tmp_computed_dirty" group by "table_id"",
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/computed/__tests__/ComputedUpdatePlanner.spec.ts b/packages/v2/adapter-table-repository-postgres/src/record/computed/__tests__/ComputedUpdatePlanner.spec.ts
index 31a50a5b33..60b26d691b 100644
--- a/packages/v2/adapter-table-repository-postgres/src/record/computed/__tests__/ComputedUpdatePlanner.spec.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/record/computed/__tests__/ComputedUpdatePlanner.spec.ts
@@ -160,6 +160,142 @@ describe('ComputedUpdatePlanner', () => {
     expect(plannedFieldIds).not.toContain(lookupNumberFieldId.toString());
   });
 
+  it('plans symmetric link updates from impact link fields when changed fields are empty', async () => {
+    const baseId = BaseId.create(`bse${'a'.repeat(15)}1`)._unsafeUnwrap();
+    const hostTableId = TableId.create(`tbl${'b'.repeat(15)}1`)._unsafeUnwrap();
+    const foreignTableId = TableId.create(`tbl${'c'.repeat(15)}1`)._unsafeUnwrap();
+    const hostPrimaryFieldId = FieldId.create(`fld${'d'.repeat(15)}1`)._unsafeUnwrap();
+    const foreignPrimaryFieldId = FieldId.create(`fld${'e'.repeat(15)}1`)._unsafeUnwrap();
+    const hostLinkFieldId = FieldId.create(`fld${'f'.repeat(15)}1`)._unsafeUnwrap();
+    const symmetricLinkFieldId = FieldId.create(`fld${'g'.repeat(15)}1`)._unsafeUnwrap();
+    const recordId = RecordId.create(`rec${'h'.repeat(15)}1`)._unsafeUnwrap();
+
+    const fields: FieldMeta[] = [
+      {
+        id: hostPrimaryFieldId,
+        tableId: hostTableId,
+        type: 'singleLineText',
+        isComputed: false,
+        options: null,
+        lookupOptions: null,
+        conditionalOptions: null,
+      },
+      {
+        id: foreignPrimaryFieldId,
+        tableId: foreignTableId,
+        type: 'singleLineText',
+        isComputed: false,
+        options: null,
+        lookupOptions: null,
+        conditionalOptions: null,
+      },
+      {
+        id: hostLinkFieldId,
+        tableId: hostTableId,
+        type: 'link',
+        isComputed: true,
+        options: {
+          foreignTableId: foreignTableId.toString(),
+          lookupFieldId: foreignPrimaryFieldId.toString(),
+          symmetricFieldId: symmetricLinkFieldId.toString(),
+          relationship: 'manyMany',
+        },
+        lookupOptions: null,
+        conditionalOptions: null,
+      },
+      {
+        id: symmetricLinkFieldId,
+        tableId: foreignTableId,
+        type: 'link',
+        isComputed: true,
+        options: {
+          foreignTableId: hostTableId.toString(),
+          lookupFieldId: hostPrimaryFieldId.toString(),
+          symmetricFieldId: hostLinkFieldId.toString(),
+          relationship: 'manyMany',
+        },
+        lookupOptions: null,
+        conditionalOptions: null,
+      },
+    ];
+
+    const edges: FieldDependencyEdge[] = [
+      {
+        fromFieldId: foreignPrimaryFieldId,
+        toFieldId: hostLinkFieldId,
+        fromTableId: foreignTableId,
+        toTableId: hostTableId,
+        kind: 'cross_record',
+        linkFieldId: hostLinkFieldId,
+        semantic: 'link_title',
+      },
+      {
+        fromFieldId: hostPrimaryFieldId,
+        toFieldId: symmetricLinkFieldId,
+        fromTableId: hostTableId,
+        toTableId: foreignTableId,
+        kind: 'cross_record',
+        linkFieldId: symmetricLinkFieldId,
+        semantic: 'link_title',
+      },
+    ];
+
+    const graphData: FieldDependencyGraphData = {
+      fieldsById: new Map<string, FieldMeta>(fields.map((field) => [field.id.toString(), field])),
+      edges,
+    };
+    const graph = {
+      load: vi
+        .fn()
+        .mockImplementation(
+          (
+            _baseId: BaseId,
+            _executionContext: unknown,
+            options?: { requiredFieldIds?: ReadonlyArray<FieldId> }
+          ) => {
+            const requiredFieldIds = options?.requiredFieldIds ?? [];
+            if (!requiredFieldIds.some((fieldId) => fieldId.equals(hostLinkFieldId))) {
+              return Promise.resolve(ok({ fieldsById: new Map<string, FieldMeta>(), edges: [] }));
+            }
+            return Promise.resolve(ok(graphData));
+          }
+        ),
+    };
+    const planner = new ComputedUpdatePlanner(graph as never);
+
+    const planResult = await planner.planStage({
+      baseId,
+      seedTableId: hostTableId,
+      seedRecordIds: [recordId],
+      extraSeedRecords: [],
+      changedFieldIds: [],
+      changeType: 'update',
+      impact: {
+        valueFieldIds: [],
+        linkFieldIds: [hostLinkFieldId],
+      },
+    });
+
+    expect(planResult.isOk()).toBe(true);
+    expect(graph.load).toHaveBeenCalledWith(baseId, undefined, {
+      requiredFieldIds: [hostLinkFieldId],
+    });
+    const plan = planResult._unsafeUnwrap();
+    const plannedFieldIds = plan.steps.flatMap((step) => step.fieldIds.map((id) => id.toString()));
+
+    expect(plannedFieldIds).toEqual(
+      expect.arrayContaining([hostLinkFieldId.toString(), symmetricLinkFieldId.toString()])
+    );
+
+    const symmetricEdge = plan.edges.find(
+      (edge) =>
+        edgeTargetsField(edge, symmetricLinkFieldId) &&
+        edge.fromTableId.equals(hostTableId) &&
+        edge.toTableId.equals(foreignTableId)
+    );
+    expect(symmetricEdge?.linkFieldId?.equals(symmetricLinkFieldId)).toBe(true);
+  });
+
   it('skips cycle fields for delete while keeping ordered updates', async () => {
     const baseId = BaseId.create(`bse${'j'.repeat(16)}`)._unsafeUnwrap();
     const seedTableId = TableId.create(`tbl${'k'.repeat(16)}`)._unsafeUnwrap();
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/computed/outbox/ComputedUpdateOutbox.ts b/packages/v2/adapter-table-repository-postgres/src/record/computed/outbox/ComputedUpdateOutbox.ts
index 8faedcc6a3..79dee66c7e 100644
--- a/packages/v2/adapter-table-repository-postgres/src/record/computed/outbox/ComputedUpdateOutbox.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/record/computed/outbox/ComputedUpdateOutbox.ts
@@ -527,18 +527,8 @@ export class ComputedUpdateOutbox implements IComputedUpdateOutbox {
                   .selectAll('o')
                   .where('o.status', '=', DEFAULT_STATUS)
                   .where('o.next_run_at', '<=', now)
-                  .where(
-                    sql<boolean>`not exists (
-                    select 1
-                    from computed_update_outbox active
-                    where active.base_id = o.base_id
-                      and active.seed_table_id = o.seed_table_id
-                      and active.status = 'processing'
-                      and active.locked_at is not null
-                      and active.locked_at > ${reclaimBefore}
-                  )`
-                  )
                   .where(buildComputedTaskNotPausedCondition('o', now))
+                  .orderBy('o.estimated_complexity', 'asc')
                   .orderBy('o.next_run_at', 'asc')
                   .orderBy('o.created_at', 'asc')
                   .limit(remaining)
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/computed/outbox/__tests__/ComputedUpdateOutbox.deadlock.pglite.spec.ts b/packages/v2/adapter-table-repository-postgres/src/record/computed/outbox/__tests__/ComputedUpdateOutbox.deadlock.pglite.spec.ts
index 624dd67108..555765ae20 100644
--- a/packages/v2/adapter-table-repository-postgres/src/record/computed/outbox/__tests__/ComputedUpdateOutbox.deadlock.pglite.spec.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/record/computed/outbox/__tests__/ComputedUpdateOutbox.deadlock.pglite.spec.ts
@@ -142,6 +142,7 @@ const insertOutboxRow = async (
     nextRunAt?: Date;
     createdAt?: Date;
     updatedAt?: Date;
+    estimatedComplexity?: number;
   }
 ) => {
   const now = params.createdAt ?? new Date('2026-01-05T12:00:00Z');
@@ -167,7 +168,7 @@ const insertOutboxRow = async (
       locked_at: params.lockedAt ?? null,
       locked_by: params.lockedBy ?? null,
       last_error: null,
-      estimated_complexity: 1,
+      estimated_complexity: params.estimatedComplexity ?? 1,
       plan_hash: `hash-${params.id}`,
       dirty_stats: JSON.stringify([]),
       affected_table_ids: params.affectedTableIds ?? [params.seedTableId ?? PRIMARY_SEED_TABLE_ID],
@@ -470,6 +471,48 @@ describe('ComputedUpdateOutbox deadlock (pglite integration)', () => {
     expect(claimed._unsafeUnwrap()).toHaveLength(0);
   });
 
+  it('claims lightweight pending work while another same-table task is processing', async () => {
+    const now = new Date('2026-01-05T12:00:10Z');
+
+    await insertOutboxRow(db, {
+      id: 'cuo-processing',
+      status: 'processing',
+      lockedAt: new Date(now.getTime() - 100),
+      lockedBy: 'worker-busy:cuc_busy',
+      createdAt: new Date(now.getTime() - 20_000),
+      updatedAt: new Date(now.getTime() - 100),
+      estimatedComplexity: 200,
+    });
+
+    await insertOutboxRow(db, {
+      id: 'cuo-heavy',
+      status: 'pending',
+      nextRunAt: new Date(now.getTime() - 10_000),
+      createdAt: new Date(now.getTime() - 10_000),
+      updatedAt: new Date(now.getTime() - 10_000),
+      estimatedComplexity: 100,
+    });
+
+    await insertOutboxRow(db, {
+      id: 'cuo-light',
+      status: 'pending',
+      nextRunAt: now,
+      createdAt: now,
+      updatedAt: now,
+      estimatedComplexity: 2,
+    });
+
+    const outbox = createTestOutbox(db);
+    const claimed = await outbox.claimBatch({
+      workerId: 'worker-new',
+      limit: 10,
+      now,
+    });
+
+    expect(claimed.isOk()).toBe(true);
+    expect(claimed._unsafeUnwrap().map((task) => task.id)).toEqual(['cuo-light']);
+  });
+
   it('a second worker does not reclaim the same task after the first reclaim commits', async () => {
     const now = new Date('2026-01-05T12:00:10Z');
     await insertOutboxRow(db, {
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 f5a72ac6a4..d848772261 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
@@ -549,7 +549,9 @@ export class ComputedFieldSelectExpressionVisitor
         return ok(sql.raw('NULL::jsonb').as(colAlias));
       }
       const linkFieldResult = field.linkField(this.table);
-      if (linkFieldResult.isErr()) return err(linkFieldResult.error);
+      if (linkFieldResult.isErr()) {
+        return ok(sql.raw('NULL::jsonb').as(colAlias));
+      }
       const linkField = linkFieldResult.value;
       if (linkField.foreignTableId().toString() !== field.foreignTableId().toString()) {
         return ok(sql.raw('NULL::jsonb').as(colAlias));
@@ -589,7 +591,9 @@ export class ComputedFieldSelectExpressionVisitor
       }
       const expression = field.expression().toString();
       const linkFieldResult = field.linkField(this.table);
-      if (linkFieldResult.isErr()) return err(linkFieldResult.error);
+      if (linkFieldResult.isErr()) {
+        return this.typedNullColumn(field, colAlias);
+      }
       const linkField = linkFieldResult.value;
       if (linkField.foreignTableId().toString() !== field.foreignTableId().toString()) {
         return ok(sql.raw('NULL').as(colAlias));
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 cc0a24b7e6..5145b831dc 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
@@ -1318,6 +1318,82 @@ describe('ComputedTableRecordQueryBuilder', () => {
       expect(sql).not.toContain('jsonb_array_elements');
     });
 
+    test('formula reference to link uses stored link title snapshot', () => {
+      const baseId = BaseId.create(BASE_ID)._unsafeUnwrap();
+      const mainTableId = TableId.create(MAIN_TABLE_ID)._unsafeUnwrap();
+      const foreignTableId = TableId.create(FOREIGN_TABLE_ID)._unsafeUnwrap();
+      const linkFieldId = FieldId.create(LINK_FIELD_ID)._unsafeUnwrap();
+      const foreignTitleFieldId = FieldId.create(`fld${'p'.repeat(16)}`)._unsafeUnwrap();
+      const formulaFieldId = FieldId.create(`fld${'z'.repeat(16)}`)._unsafeUnwrap();
+
+      const foreignBuilder = Table.builder()
+        .withId(foreignTableId)
+        .withBaseId(baseId)
+        .withName(TableName.create('ForeignTable')._unsafeUnwrap());
+      foreignBuilder
+        .field()
+        .singleLineText()
+        .withId(foreignTitleFieldId)
+        .withName(FieldName.create('Title')._unsafeUnwrap())
+        .done();
+      foreignBuilder.view().defaultGrid().done();
+
+      const foreignTable = foreignBuilder.build()._unsafeUnwrap();
+      foreignTable
+        .getFields()[0]
+        .setDbFieldName(DbFieldName.rehydrate('col_title')._unsafeUnwrap())
+        ._unsafeUnwrap();
+
+      const linkConfig = LinkFieldConfig.create({
+        relationship: 'manyOne',
+        foreignTableId: foreignTableId.toString(),
+        lookupFieldId: foreignTitleFieldId.toString(),
+        symmetricFieldId: SYMMETRIC_FIELD_ID,
+      })._unsafeUnwrap();
+
+      const mainBuilder = Table.builder()
+        .withId(mainTableId)
+        .withBaseId(baseId)
+        .withName(TableName.create('MainTable')._unsafeUnwrap());
+      mainBuilder
+        .field()
+        .link()
+        .withId(linkFieldId)
+        .withName(FieldName.create('Link')._unsafeUnwrap())
+        .withConfig(linkConfig)
+        .done();
+      mainBuilder
+        .field()
+        .formula()
+        .withId(formulaFieldId)
+        .withName(FieldName.create('LinkTitleFormula')._unsafeUnwrap())
+        .withExpression(FormulaExpression.create(`{${linkFieldId.toString()}}`)._unsafeUnwrap())
+        .done();
+      mainBuilder.view().defaultGrid().done();
+
+      const mainTable = mainBuilder.build({ foreignTables: [foreignTable] })._unsafeUnwrap();
+      mainTable
+        .getFields()[0]
+        .setDbFieldName(DbFieldName.rehydrate('col_link')._unsafeUnwrap())
+        ._unsafeUnwrap();
+      mainTable
+        .getFields()[1]
+        .setDbFieldName(DbFieldName.rehydrate('col_link_title_formula')._unsafeUnwrap())
+        ._unsafeUnwrap();
+
+      const db = createTestDb();
+      const foreignTables = new Map([[foreignTableId.toString(), foreignTable]]);
+      const { sql } = compileQuery(
+        db,
+        new ComputedTableRecordQueryBuilder(db, { foreignTables, typeValidationStrategy })
+          .from(mainTable)
+          .select([formulaFieldId])
+      );
+
+      expect(sql).toContain(`COALESCE(("t"."col_link")::jsonb->>'title'`);
+      expect(sql).not.toContain('"f"."col_title"');
+    });
+
     test('shares LATERAL JOIN between link and lookup on same link', () => {
       const db = createTestDb();
       const { mainTable, foreignTable, foreignTableId } = createLookupTable();
@@ -1394,6 +1470,27 @@ describe('ComputedTableRecordQueryBuilder', () => {
       expect(sql).not.toContain('inner join lateral');
     });
 
+    test('returns NULL lookup when lookup link field is missing', () => {
+      const db = createTestDb();
+      const { mainTable, foreignTable, foreignTableId } = createLookupTable();
+      const lookupField = mainTable.getFields()[2];
+      const tableWithoutLink = Object.create(mainTable) as Table;
+      (tableWithoutLink as unknown as { getField: () => { isErr(): true } }).getField = () => ({
+        isErr: () => true,
+      });
+
+      const foreignTables = new Map([[foreignTableId.toString(), foreignTable]]);
+      const { sql } = compileQuery(
+        db,
+        new ComputedTableRecordQueryBuilder(db, { foreignTables, typeValidationStrategy })
+          .from(tableWithoutLink)
+          .select([lookupField.id()])
+      );
+
+      expect(sql).toContain('NULL::jsonb as "col_lookup"');
+      expect(sql).not.toContain('inner join lateral');
+    });
+
     test('uses single-level flattening for lookup-of-lookup chains without inner filters', () => {
       const db = createTestDb();
       const { hostTable, middleTable, middleTableId } = createNestedLookupChain();
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/FieldReferenceSqlVisitor.spec.ts b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/FieldReferenceSqlVisitor.spec.ts
index 5e2bb9d9ec..0c62a36e4d 100644
--- a/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/FieldReferenceSqlVisitor.spec.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/FieldReferenceSqlVisitor.spec.ts
@@ -620,6 +620,32 @@ describe('FieldReferenceSqlVisitor', () => {
       expect(mockLateral.calls).toEqual([]);
     });
 
+    it('should short-circuit lookup fields with missing link field without registering laterals', () => {
+      const { table, lookupField } = createLookupErrorTable();
+      const tableWithoutLink = Object.create(table) as Table;
+      (tableWithoutLink as unknown as { getField: () => { isErr(): true } }).getField = () => ({
+        isErr: () => true,
+      });
+      lookupField.setHasError(FieldHasError.ok());
+      mockLateral.clear();
+      const visitor = new FieldReferenceSqlVisitor({
+        table: tableWithoutLink,
+        tableAlias: 't',
+        lateral: mockLateral,
+      });
+
+      const result = lookupField.accept(visitor);
+
+      expect(result.isOk()).toBe(true);
+      const expr = result._unsafeUnwrap();
+
+      expect(expr.valueSql).toBe('NULL::text');
+      expect(expr.valueType).toBe('string');
+      expect(expr.errorConditionSql).toBe('TRUE');
+      expect(expr.errorMessageSql).toContain('#ERROR:REF:errored_field');
+      expect(mockLateral.calls).toEqual([]);
+    });
+
     it('should short-circuit errored conditional lookup fields without registering laterals', () => {
       const { table, conditionalLookupField } = createConditionalLookupErrorTable();
       mockLateral.clear();
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/FieldReferenceSqlVisitor.ts b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/FieldReferenceSqlVisitor.ts
index 20d989994b..5f4a9c826e 100644
--- a/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/FieldReferenceSqlVisitor.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/FieldReferenceSqlVisitor.ts
@@ -385,25 +385,13 @@ export class FieldReferenceSqlVisitor implements IFieldVisitor<SqlExpr> {
       if (field.hasError().isError()) {
         return this.erroredFieldExpr(field, { isArray: isMultiValue, storageKind: 'json' });
       }
-      const orderByResult = this.getLinkOrderBy(field);
-      if (orderByResult.isErr()) return err(orderByResult.error);
-      const lateralAlias = this.lateral.addColumn(
-        field.id(),
-        field.foreignTableId().toString(),
-        colAlias,
-        {
-          type: 'link',
-          lookupFieldId: field.lookupFieldId(),
-          isMultiValue,
-          orderBy: orderByResult.value,
-        }
-      );
-      // Return the raw lateral reference - JSON extraction handled by visitFormulaField
+      // Use the stored link snapshot for formula references. Recomputing the link through the
+      // foreign display field can drop title when the foreign primary is itself stale/empty.
       return ok(
         makeExpr(
-          this.qualify(lateralAlias, colAlias),
+          this.qualify(this.tableAlias, colAlias),
           'unknown',
-          false,
+          isMultiValue,
           undefined,
           undefined,
           field,
@@ -430,7 +418,7 @@ export class FieldReferenceSqlVisitor implements IFieldVisitor<SqlExpr> {
       }
       const condition = field.lookupOptions().condition();
       const linkFieldResult = field.linkField(this.table);
-      if (linkFieldResult.isErr()) return err(linkFieldResult.error);
+      if (linkFieldResult.isErr()) return this.erroredFieldExpr(field, exprOptions);
       const linkField = linkFieldResult.value;
       const orderByResult = this.getLinkOrderBy(linkField);
       if (orderByResult.isErr()) return err(orderByResult.error);
@@ -472,10 +460,10 @@ export class FieldReferenceSqlVisitor implements IFieldVisitor<SqlExpr> {
         return this.erroredFieldExpr(field);
       }
       const expression = field.expression().toString();
-      const linkFieldResult = field
-        .linkField(this.table)
-        .andThen((linkField) => this.getLinkOrderBy(linkField));
-      if (linkFieldResult.isErr()) return err(linkFieldResult.error);
+      const linkFieldResult = field.linkField(this.table);
+      if (linkFieldResult.isErr()) return this.erroredFieldExpr(field);
+      const orderByResult = this.getLinkOrderBy(linkFieldResult.value);
+      if (orderByResult.isErr()) return err(orderByResult.error);
       const lateralAlias = this.lateral.addColumn(
         field.linkFieldId(),
         field.foreignTableId().toString(),
@@ -484,7 +472,7 @@ export class FieldReferenceSqlVisitor implements IFieldVisitor<SqlExpr> {
           type: 'rollup',
           foreignFieldId: field.lookupFieldId(),
           expression,
-          orderBy: linkFieldResult.value,
+          orderBy: orderByResult.value,
         }
       );
       return ok(makeExpr(this.qualify(lateralAlias, colAlias), 'unknown', false));
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/SameTableBatchQueryBuilder.spec.ts b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/SameTableBatchQueryBuilder.spec.ts
index 0cc947a939..92b498ce96 100644
--- a/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/SameTableBatchQueryBuilder.spec.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/SameTableBatchQueryBuilder.spec.ts
@@ -6,6 +6,7 @@ import {
   FieldId,
   FieldName,
   FormulaExpression,
+  LinkFieldConfig,
   Table,
   TableId,
   TableName,
@@ -209,6 +210,77 @@ const createChainedFormulaTable = () => {
   return { table, plusOneId, plusOneDoubleId };
 };
 
+const createLinkFormulaTable = () => {
+  const baseId = BaseId.create(`bse${'a'.repeat(16)}`)._unsafeUnwrap();
+  const mainTableId = TableId.create(`tbl${'l'.repeat(16)}`)._unsafeUnwrap();
+  const foreignTableId = TableId.create(`tbl${'r'.repeat(16)}`)._unsafeUnwrap();
+  const lookupFieldId = createFieldId(`fld${'p'.repeat(16)}`);
+  const linkFieldId = createFieldId(`fld${'q'.repeat(16)}`);
+  const formulaFieldId = createFieldId(`fld${'r'.repeat(16)}`);
+
+  const foreignBuilder = Table.builder()
+    .withId(foreignTableId)
+    .withBaseId(baseId)
+    .withName(TableName.create('ForeignTable')._unsafeUnwrap());
+  foreignBuilder
+    .field()
+    .singleLineText()
+    .withId(lookupFieldId)
+    .withName(createFieldName('Title'))
+    .done();
+  foreignBuilder.view().defaultGrid().done();
+
+  const foreignTable = foreignBuilder.build()._unsafeUnwrap();
+  foreignTable
+    .getFields()[0]
+    .setDbFieldName(DbFieldName.rehydrate('Title')._unsafeUnwrap())
+    ._unsafeUnwrap();
+
+  const linkConfig = LinkFieldConfig.create({
+    relationship: 'manyOne',
+    foreignTableId: foreignTableId.toString(),
+    lookupFieldId: lookupFieldId.toString(),
+    symmetricFieldId: `fld${'s'.repeat(16)}`,
+  })._unsafeUnwrap();
+
+  const mainBuilder = Table.builder()
+    .withId(mainTableId)
+    .withBaseId(baseId)
+    .withName(TableName.create('MainTable')._unsafeUnwrap());
+  mainBuilder.field().singleLineText().withName(createFieldName('Name')).done();
+  mainBuilder
+    .field()
+    .link()
+    .withId(linkFieldId)
+    .withName(createFieldName('Link'))
+    .withConfig(linkConfig)
+    .done();
+  mainBuilder
+    .field()
+    .formula()
+    .withId(formulaFieldId)
+    .withName(createFieldName('LinkTitleFormula'))
+    .withExpression(FormulaExpression.create(`{${linkFieldId.toString()}}`)._unsafeUnwrap())
+    .done();
+  mainBuilder.view().defaultGrid().done();
+
+  const table = mainBuilder.build({ foreignTables: [foreignTable] })._unsafeUnwrap();
+  table
+    .getFields()[0]
+    .setDbFieldName(DbFieldName.rehydrate('Name')._unsafeUnwrap())
+    ._unsafeUnwrap();
+  table
+    .getFields()[1]
+    .setDbFieldName(DbFieldName.rehydrate('Link')._unsafeUnwrap())
+    ._unsafeUnwrap();
+  table
+    .getFields()[2]
+    .setDbFieldName(DbFieldName.rehydrate('LinkTitleFormula')._unsafeUnwrap())
+    ._unsafeUnwrap();
+
+  return { table, formulaFieldId };
+};
+
 const createIsErrorFormulaChainTable = () => {
   const baseId = BaseId.create(`bse${'e'.repeat(16)}`)._unsafeUnwrap();
   const tableId = TableId.create(`tbl${'e'.repeat(16)}`)._unsafeUnwrap();
@@ -493,6 +565,30 @@ describe('SameTableBatchQueryBuilder', () => {
       expect(sqlText).toContain(`"level_0"."AlwaysError" LIKE '#ERROR:%'`);
       expect(sqlText).toContain('TRUE OR');
     });
+
+    it('extracts link title when a same-table formula directly references a link field', () => {
+      const db = createMockKysely();
+      const builder = new SameTableBatchQueryBuilder(db, typeValidationStrategy);
+      const { table, formulaFieldId } = createLinkFormulaTable();
+
+      const result = builder.build({
+        table,
+        fieldLevels: [{ level: 0, fieldIds: [formulaFieldId] }],
+      });
+
+      expect(result.isOk()).toBe(true);
+      const updateBuilder = new UpdateFromSelectBuilder(db);
+      const compiled = updateBuilder.build({
+        table,
+        fieldIds: [formulaFieldId],
+        selectQuery: result._unsafeUnwrap().selectQuery,
+      });
+      expect(compiled.isOk()).toBe(true);
+
+      const sqlText = compiled._unsafeUnwrap().sql;
+      expect(sqlText).toContain(`COALESCE(("t"."Link")::jsonb->>'title'`);
+      expect(sqlText).not.toContain(`"t"."Link" as "LinkTitleFormula"`);
+    });
   });
 
   describe('field mappings', () => {
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/SameTableBatchQueryBuilder.ts b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/SameTableBatchQueryBuilder.ts
index 0f21f2b437..a73ef64a19 100644
--- a/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/SameTableBatchQueryBuilder.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/SameTableBatchQueryBuilder.ts
@@ -9,9 +9,11 @@ import type {
   Table,
 } from '@teable/v2-core';
 import {
+  extractJsonScalarText,
   FormulaSqlPgTranslator,
   guardValueSql,
   makeExpr,
+  normalizeToJsonArrayWithStrategy,
   type IPgTypeValidationStrategy,
   type SqlExpr,
   type SqlValueType,
@@ -248,10 +250,47 @@ export class SameTableBatchQueryBuilder {
     }
 
     const expr = translated.value;
-    const typedSql = guardValueSql(expr.valueSql, expr.errorConditionSql);
+    const valueSql = this.normalizeFormulaValueSql(formulaField, expr);
+    const typedSql = guardValueSql(valueSql, expr.errorConditionSql);
     return ok(sql.raw(typedSql));
   }
 
+  private normalizeFormulaValueSql(formulaField: FormulaField, expr: SqlExpr): string {
+    if (expr.storageKind !== 'json' || !this.shouldExtractJsonDisplay(expr)) {
+      return expr.valueSql;
+    }
+
+    const formulaIsMultiple = formulaField
+      .isMultipleCellValue()
+      .map((multiplicity) => multiplicity.isMultiple())
+      .unwrapOr(false);
+
+    if (formulaIsMultiple || expr.isArray) {
+      const normalized = normalizeToJsonArrayWithStrategy(
+        expr.valueSql,
+        this.typeValidationStrategy
+      );
+      return `(
+        SELECT jsonb_agg(to_jsonb(${extractJsonScalarText('elem')}) ORDER BY ord)
+        FROM jsonb_array_elements(${normalized}) WITH ORDINALITY AS _jae(elem, ord)
+      )`;
+    }
+
+    return extractJsonScalarText(`(${expr.valueSql})::jsonb`);
+  }
+
+  private shouldExtractJsonDisplay(expr: SqlExpr): boolean {
+    const referenced = expr.field;
+    if (!referenced) return false;
+
+    const type = referenced.type();
+    return (
+      type.equals(FieldType.link()) ||
+      type.equals(FieldType.button()) ||
+      type.equals(FieldType.user())
+    );
+  }
+
   /**
    * Resolve a field reference to SQL, checking if it should come from a previous CTE.
    */
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/__snapshots__/FieldReferenceSqlVisitor.spec.ts.snap b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/__snapshots__/FieldReferenceSqlVisitor.spec.ts.snap
index 46bf77a48a..52ec0cd430 100644
--- a/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/__snapshots__/FieldReferenceSqlVisitor.spec.ts.snap
+++ b/packages/v2/adapter-table-repository-postgres/src/record/query-builder/computed/__snapshots__/FieldReferenceSqlVisitor.spec.ts.snap
@@ -38,28 +38,10 @@ exports[`FieldReferenceSqlVisitor > JSON fields with display value extraction >
 
 exports[`FieldReferenceSqlVisitor > link fields > should aggregate titles from multi-value link field 1`] = `
 {
-  "isArray": false,
-  "lateralCalls": [
-    {
-      "columnType": {
-        "isMultiValue": true,
-        "lookupFieldId": FieldId {
-          "value": "fldtttttttttttttttt",
-        },
-        "orderBy": {
-          "column": "__fk_fldyyyyyyyyyyyyyyyy_order",
-          "source": "foreign",
-        },
-        "type": "link",
-      },
-      "foreignTableId": "tblffffffffffffffff",
-      "linkFieldId": "fldllllllllllllllll",
-      "outputAlias": "col_link_multiple",
-      "type": "addColumn",
-    },
-  ],
+  "isArray": true,
+  "lateralCalls": [],
   "storageKind": "json",
-  "valueSql": ""lat_0"."col_link_multiple"",
+  "valueSql": ""t"."col_link_multiple"",
   "valueType": "unknown",
 }
 `;
@@ -67,24 +49,9 @@ exports[`FieldReferenceSqlVisitor > link fields > should aggregate titles from m
 exports[`FieldReferenceSqlVisitor > link fields > should extract title from single-value link field 1`] = `
 {
   "isArray": false,
-  "lateralCalls": [
-    {
-      "columnType": {
-        "isMultiValue": false,
-        "lookupFieldId": FieldId {
-          "value": "fldtttttttttttttttt",
-        },
-        "orderBy": undefined,
-        "type": "link",
-      },
-      "foreignTableId": "tblffffffffffffffff",
-      "linkFieldId": "fldkkkkkkkkkkkkkkkk",
-      "outputAlias": "col_link_single",
-      "type": "addColumn",
-    },
-  ],
+  "lateralCalls": [],
   "storageKind": "json",
-  "valueSql": ""lat_0"."col_link_single"",
+  "valueSql": ""t"."col_link_single"",
   "valueType": "unknown",
 }
 `;
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 ad9acf0f6c..4e992b25e9 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
@@ -9,6 +9,7 @@ import type { Result } from 'neverthrow';
 import { buildFilledLinkValueExpression } from '../../buildFilledLinkValueExpression';
 import { isPersistedAsGeneratedColumn } from '../../computed/isPersistedAsGeneratedColumn';
 import { normalizeStoredLinkItems } from '../../normalizeLinkItems';
+import { buildAttachmentTableInsertQuery } from '../../attachments/attachmentTableMutations';
 
 import { FieldInsertValueVisitor, type FieldInsertResult } from '../../visitors';
 import type { DynamicDB } from '../ITableRecordQueryBuilder';
@@ -379,6 +380,23 @@ export class RecordInsertBuilder {
               }
             }
           }
+
+          if (field.type().equals(FieldType.attachment())) {
+            const insertQuery = buildAttachmentTableInsertQuery(builder.db, {
+              actorId: context.actorId,
+              tableId: table.id().toString(),
+              recordId: context.recordId,
+              fieldId: fieldIdStr,
+              value: rawValue,
+            });
+
+            if (insertQuery) {
+              additionalStatements.push({
+                description: `Insert attachment index rows for field ${fieldIdStr}`,
+                compiled: insertQuery,
+              });
+            }
+          }
         } else {
           // Fallback: just use raw value
           values[dbFieldName] = rawValue;
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 3935126dc1..d2405b2fe5 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
@@ -1720,7 +1720,7 @@ export class PostgresTableRecordRepository implements core.ITableRecordRepositor
           if (changedFieldColumns.length > 0 && !updatedRow) {
             await snapshotCaptureSession.abort();
             snapshotCaptureSession = undefined;
-            return ok({});
+            return ok({ mutationApplied: false });
           }
 
           // Acquire advisory locks for linked records to prevent deadlocks
@@ -1765,7 +1765,7 @@ export class PostgresTableRecordRepository implements core.ITableRecordRepositor
           await this.touchTableMeta(db, table.id().toString(), actorId);
           const computedChanges = extractChangesForRecord(computedResult, recordIdStr);
           const changedFields = toChangedFieldsMap(updatedRow, changedFieldColumns);
-          return ok({ changedFields, computedChanges, updateSnapshot });
+          return ok({ mutationApplied: true, changedFields, computedChanges, updateSnapshot });
         } catch (error) {
           await snapshotCaptureSession?.abort();
           return err(
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/repository/RecordSearchWhereBuilder.pglite.spec.ts b/packages/v2/adapter-table-repository-postgres/src/record/repository/RecordSearchWhereBuilder.pglite.spec.ts
index ddaa973e9a..fd0b3619e3 100644
--- a/packages/v2/adapter-table-repository-postgres/src/record/repository/RecordSearchWhereBuilder.pglite.spec.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/record/repository/RecordSearchWhereBuilder.pglite.spec.ts
@@ -36,6 +36,10 @@ class PGliteDialect implements Dialect {
           };
         },
         streamQuery: async function* () {
+          // eslint-disable-next-line no-constant-condition
+          if (false) {
+            yield undefined as never;
+          }
           throw new Error('PGlite does not support streaming');
         },
       }),
@@ -292,6 +296,38 @@ const findMatchingRecordIds = async ({
   return rows.map((row) => row.id as string);
 };
 
+const compileSearchQuery = ({
+  db,
+  table,
+  fullTableName,
+  search,
+  visibleFieldIds,
+}: {
+  db: Kysely<V1TeableDatabase>;
+  table: Table;
+  fullTableName: string;
+  search: RecordSearch;
+  visibleFieldIds?: ReadonlyArray<FieldId>;
+}) => {
+  const whereClause = buildRecordSearchWhereClause(
+    table,
+    {
+      search,
+      visibleFieldIds,
+    },
+    {
+      tableAlias: 't',
+    }
+  )._unsafeUnwrap();
+
+  let query = db.selectFrom(`${fullTableName} as t`).select('t.__id as id');
+  if (whereClause != null) {
+    query = query.where(whereClause);
+  }
+
+  return query.compile();
+};
+
 describe('RecordSearchWhereBuilder (pglite)', () => {
   let client: PGlite;
   let db: Kysely<V1TeableDatabase>;
@@ -411,6 +447,20 @@ describe('RecordSearchWhereBuilder (pglite)', () => {
     ).resolves.toEqual([fixture.recordIds.alpha]);
   });
 
+  it('compiles date-like searches to range predicates instead of TO_CHAR matches', async () => {
+    const fixture = await setupSearchFixture({ db, createdSchemas, seed: 'date-range-sql' });
+
+    const compiled = compileSearchQuery({
+      db,
+      table: fixture.table,
+      fullTableName: fixture.fullTableName,
+      search: RecordSearch.fromTuple(['2026-02-24', fixture.fieldIds.due.toString(), true]),
+    });
+
+    expect(compiled.sql.toLowerCase()).toContain('"t"."col_due" >=');
+    expect(compiled.sql.toLowerCase()).toContain('"t"."col_due" <');
+    expect(compiled.sql.toLowerCase()).not.toContain('to_char(');
+  });
   it('does not filter rows for checkbox field-specific visible-row search', async () => {
     const fixture = await setupSearchFixture({ db, createdSchemas, seed: 'checkbox' });
 
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/repository/RecordSearchWhereBuilder.ts b/packages/v2/adapter-table-repository-postgres/src/record/repository/RecordSearchWhereBuilder.ts
index 1a2bcee1a9..55e8fd4595 100644
--- a/packages/v2/adapter-table-repository-postgres/src/record/repository/RecordSearchWhereBuilder.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/record/repository/RecordSearchWhereBuilder.ts
@@ -21,10 +21,9 @@ import {
 import { sql, type Expression, type SqlBool } from 'kysely';
 import { ok, safeTry } from 'neverthrow';
 import type { Result } from 'neverthrow';
+import { getDateSearchRange } from './dateSearchRange';
 
 const fieldValueTypeVisitor = new FieldValueTypeVisitor();
-const DEFAULT_DATE_TIME_FORMAT = 'YYYY-MM-DD HH24:MI';
-
 const escapeLikeWildcards = (input: string): string => {
   return input.replace(/\\/g, '\\\\').replace(/%/g, '\\%').replace(/_/g, '\\_');
 };
@@ -106,20 +105,20 @@ const buildNumberMultipleCondition = (
 const buildDateMultipleCondition = (
   columnRef: Expression<unknown>,
   searchValue: string,
-  timeZone: string
+  formatting?: DateTimeFormatting
 ) => {
+  const range = getDateSearchRange(searchValue, formatting);
+  if (!range) {
+    return sql<SqlBool>`false`;
+  }
+
   const arrayExpr = normalizeToJsonArray(columnRef);
   return sql<SqlBool>`
     EXISTS (
       SELECT 1
-      FROM (
-        SELECT string_agg(
-          TO_CHAR(TIMEZONE(${timeZone}, CAST(elem.value AS timestamp with time zone)), ${DEFAULT_DATE_TIME_FORMAT}),
-          ', '
-        ) AS aggregated
-        FROM jsonb_array_elements_text(${arrayExpr}) AS elem(value)
-      ) AS sub
-      WHERE sub.aggregated ILIKE ${`%${escapeLikeWildcards(searchValue)}%`} ESCAPE '\\'
+      FROM jsonb_array_elements_text(${arrayExpr}) AS elem(value)
+      WHERE CAST(elem.value AS timestamp with time zone) >= ${range.start}
+        AND CAST(elem.value AS timestamp with time zone) < ${range.end}
     )
   `;
 };
@@ -231,10 +230,6 @@ const resolveNumberPrecision = (field: Field): number => {
   return resolveNumberFormatting(field)?.precision().toNumber() ?? 0;
 };
 
-const resolveSearchTimeZone = (field: Field): string => {
-  return resolveDateTimeFormatting(field)?.timeZone().toString() ?? 'UTC';
-};
-
 const resolveColumnRef = (
   field: Field,
   tableAlias: string
@@ -282,11 +277,16 @@ const buildFieldSearchCondition = (
     }
 
     if (cellValueType.equals(CellValueType.dateTime())) {
-      const timeZone = resolveSearchTimeZone(field);
+      const formatting = resolveDateTimeFormatting(field);
+      const range = getDateSearchRange(search.value, formatting);
+      if (!range) {
+        return ok(sql<SqlBool>`false`);
+      }
+
       return ok(
         isMultiple
-          ? buildDateMultipleCondition(columnRef, search.value, timeZone)
-          : sql<SqlBool>`TO_CHAR(TIMEZONE(${timeZone}, ${columnRef}), ${DEFAULT_DATE_TIME_FORMAT}) ILIKE ${`%${escapeLikeWildcards(search.value)}%`} ESCAPE '\\'`
+          ? buildDateMultipleCondition(columnRef, search.value, formatting)
+          : sql<SqlBool>`${columnRef} >= ${range.start} AND ${columnRef} < ${range.end}`
       );
     }
 
diff --git a/packages/v2/adapter-table-repository-postgres/src/record/repository/dateSearchRange.ts b/packages/v2/adapter-table-repository-postgres/src/record/repository/dateSearchRange.ts
new file mode 100644
index 0000000000..ac578990e8
--- /dev/null
+++ b/packages/v2/adapter-table-repository-postgres/src/record/repository/dateSearchRange.ts
@@ -0,0 +1,76 @@
+import { DateFormattingPreset, type DateTimeFormatting, TimeFormatting } from '@teable/v2-core';
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+import timezone from 'dayjs/plugin/timezone';
+import utc from 'dayjs/plugin/utc';
+
+dayjs.extend(utc);
+dayjs.extend(timezone);
+dayjs.extend(customParseFormat);
+
+type IDateSearchUnit = 'year' | 'month' | 'day' | 'minute';
+
+export interface IDateSearchRange {
+  start: string;
+  end: string;
+}
+
+const dateSearchPatterns: Array<{ pattern: RegExp; format: string; unit: IDateSearchUnit }> = [
+  { pattern: /^\d{4}$/, format: 'YYYY', unit: 'year' },
+  { pattern: /^\d{4}-\d{2}$/, format: 'YYYY-MM', unit: 'month' },
+  { pattern: /^\d{4}-\d{2}-\d{2}$/, format: 'YYYY-MM-DD', unit: 'day' },
+  { pattern: /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}$/, format: 'YYYY-MM-DD HH:mm', unit: 'minute' },
+];
+
+const isUnitAllowed = (unit: IDateSearchUnit, formatting?: DateTimeFormatting): boolean => {
+  const dateFormat = formatting?.date() ?? DateFormattingPreset.ISO;
+  const hasTime = formatting != null && formatting.time() !== TimeFormatting.None;
+
+  switch (unit) {
+    case 'year':
+      return true;
+    case 'month':
+      return dateFormat !== DateFormattingPreset.Y;
+    case 'day':
+      return dateFormat !== DateFormattingPreset.Y && dateFormat !== DateFormattingPreset.YM;
+    case 'minute':
+      return hasTime;
+    default:
+      return false;
+  }
+};
+
+export const getDateSearchRange = (
+  rawSearchValue: string,
+  formatting?: DateTimeFormatting
+): IDateSearchRange | null => {
+  const searchValue = rawSearchValue.trim();
+  if (!searchValue) {
+    return null;
+  }
+
+  const timeZone = formatting?.timeZone().toString() ?? 'UTC';
+
+  for (const candidate of dateSearchPatterns) {
+    if (!candidate.pattern.test(searchValue) || !isUnitAllowed(candidate.unit, formatting)) {
+      continue;
+    }
+
+    const normalizedSearchValue =
+      candidate.unit === 'minute' ? searchValue.replace('T', ' ') : searchValue;
+    const parsed = dayjs.tz(normalizedSearchValue, candidate.format, timeZone);
+    if (!parsed.isValid() || parsed.format(candidate.format) !== normalizedSearchValue) {
+      continue;
+    }
+
+    const start = parsed.startOf(candidate.unit);
+    const end = start.add(1, candidate.unit);
+
+    return {
+      start: start.toISOString(),
+      end: end.toISOString(),
+    };
+  }
+
+  return null;
+};
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 50ad750c9e..cb3b156254 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
@@ -8,7 +8,6 @@ import type {
   LastModifiedTimeField,
   LinkField,
   MultipleSelectField,
-  SetAttachmentValueSpec,
   SetCheckboxValueSpec,
   SetDateValueSpec,
   SetLinkValueByTitleSpec,
@@ -31,6 +30,7 @@ import {
   FieldId,
   FieldType,
   ok,
+  SetAttachmentValueSpec,
   SetLinkValueSpec as SetLinkValueSpecClass,
 } from '@teable/v2-core';
 import type { CompiledQuery, Kysely } from 'kysely';
@@ -38,6 +38,7 @@ import { sql } from 'kysely';
 import { err, safeTry } from 'neverthrow';
 import type { Result } from 'neverthrow';
 
+import { buildAttachmentTableReplaceQueries } from '../attachments/attachmentTableMutations';
 import { buildFilledLinkValueExpression } from '../buildFilledLinkValueExpression';
 import { isPersistedAsGeneratedColumn } from '../computed/isPersistedAsGeneratedColumn';
 import { normalizeStoredLinkItems } from '../normalizeLinkItems';
@@ -503,7 +504,22 @@ export class CellValueMutateVisitor implements ICellValueSpecVisitor {
   }
 
   visitSetAttachmentValue(spec: SetAttachmentValueSpec): Result<void, DomainError> {
-    return this.addJsonValue(spec.fieldId, spec.value.toValue());
+    const addResult = this.addJsonValue(spec.fieldId, spec.value.toValue());
+    if (addResult.isErr()) {
+      return addResult;
+    }
+
+    this.additionalStatements.push(
+      ...buildAttachmentTableReplaceQueries(this.db, {
+        actorId: this.ctx.actorId,
+        tableId: this.table.id().toString(),
+        recordId: this.ctx.recordId,
+        fieldId: spec.fieldId.toString(),
+        value: spec.value.toValue(),
+      })
+    );
+
+    return ok(undefined);
   }
 
   visitSetUserValue(spec: SetUserValueSpec): Result<void, DomainError> {
@@ -536,6 +552,11 @@ export class CellValueMutateVisitor implements ICellValueSpecVisitor {
       return this.visitSetLinkValue(nullSpec);
     }
 
+    if (field.type().equals(FieldType.attachment())) {
+      const nullSpec = new SetAttachmentValueSpec(field.id(), CellValue.null());
+      return this.visitSetAttachmentValue(nullSpec);
+    }
+
     // Non-link fields: directly SET col = NULL
     return this.addSimpleValue(field.id(), null);
   }
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
index 6645a7bfff..685a3cdce6 100644
--- 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
@@ -97,5 +97,9 @@ export const getRuleRepairHint = (
   return ok({
     available: true,
     mode: 'auto',
+    description: createMessage(
+      'table:table.integrity.v2.repairMeta.description.autoRule',
+      'The repair will execute the schema statements generated by this rule, then re-check the rule to confirm the schema is valid.'
+    ),
   });
 };
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/ColumnExistsRule.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/ColumnExistsRule.ts
index 9129013afe..06ff4fc5db 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/ColumnExistsRule.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/ColumnExistsRule.ts
@@ -14,6 +14,7 @@ import {
 import type { SchemaRuleContext } from '../context/SchemaRuleContext';
 import type {
   ISchemaRule,
+  SchemaRuleRepairHint,
   SchemaRuleValidationResult,
   TableSchemaStatementBuilder,
 } from '../core/ISchemaRule';
@@ -122,6 +123,23 @@ export class ColumnExistsRule implements ISchemaRule {
     });
   }
 
+  getRepairHint(
+    _ctx: SchemaRuleContext,
+    _validation: SchemaRuleValidationResult
+  ): Result<SchemaRuleRepairHint | undefined, DomainError> {
+    return ok({
+      available: true,
+      mode: 'auto',
+      reason: {
+        fallback: `Automatic repair will recreate the missing physical column for "${this.field.name().toString()}".`,
+      },
+      description: {
+        fallback:
+          'This repair only recreates the missing column structure. It does not recover historical cell values from another source, so affected records may still display empty values until data is backfilled separately.',
+      },
+    });
+  }
+
   up(ctx: SchemaRuleContext): Result<ReadonlyArray<TableSchemaStatementBuilder>, DomainError> {
     return safeTry<ReadonlyArray<TableSchemaStatementBuilder>, DomainError>(function* () {
       const columnName = yield* resolveColumnName(ctx.field);
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/FieldMetaRule.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/FieldMetaRule.ts
index f7256c7175..bab19ff72c 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/FieldMetaRule.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/FieldMetaRule.ts
@@ -1,10 +1,12 @@
 import type { DomainError, Field } from '@teable/v2-core';
+import { sql } from 'kysely';
 import { ok } from 'neverthrow';
 import type { Result } from 'neverthrow';
 
 import type { SchemaRuleContext } from '../context/SchemaRuleContext';
 import type {
   ISchemaRule,
+  SchemaRuleRepairHint,
   SchemaRuleValidationResult,
   TableSchemaStatementBuilder,
 } from '../core/ISchemaRule';
@@ -108,11 +110,31 @@ export class FieldMetaRule implements ISchemaRule {
     return ok({ valid: true });
   }
 
+  getRepairHint(
+    _ctx: SchemaRuleContext,
+    _validation: SchemaRuleValidationResult
+  ): Result<SchemaRuleRepairHint | undefined, DomainError> {
+    return ok({
+      available: true,
+      mode: 'auto',
+      reason: {
+        fallback: `Automatic repair will update metadata for "${this.field.name().toString()}".`,
+      },
+      description: {
+        fallback:
+          'This repair changes field metadata only and preserves unrelated meta keys. Record cell values are not rewritten, but field behavior or display can change immediately after the metadata update takes effect.',
+      },
+    });
+  }
+
   up(ctx: SchemaRuleContext): Result<ReadonlyArray<TableSchemaStatementBuilder>, DomainError> {
     const fieldId = this.field.id().toString();
+    const patch = JSON.stringify(this.meta);
     const updateMeta = ctx.db
       .updateTable('field')
-      .set({ meta: JSON.stringify(this.meta) })
+      .set({
+        meta: sql`(coalesce(meta::jsonb, '{}'::jsonb) || ${patch}::jsonb)::text`,
+      })
       .where('id', '=', fieldId);
 
     return ok([updateMeta]);
@@ -120,10 +142,16 @@ export class FieldMetaRule implements ISchemaRule {
 
   down(ctx: SchemaRuleContext): Result<ReadonlyArray<TableSchemaStatementBuilder>, DomainError> {
     const fieldId = this.field.id().toString();
-    // Clear metadata on down (set to empty object)
+    const keys = Object.keys(this.meta);
+    const quotedKeys = keys.map((key) => `'${key.replaceAll("'", "''")}'`).join(', ');
     const updateMeta = ctx.db
       .updateTable('field')
-      .set({ meta: JSON.stringify({}) })
+      .set({
+        meta:
+          keys.length === 0
+            ? sql`coalesce(meta::jsonb, '{}'::jsonb)::text`
+            : sql.raw(`(coalesce(meta::jsonb, '{}'::jsonb) - array[${quotedKeys}])::text`),
+      })
       .where('id', '=', fieldId);
 
     return ok([updateMeta]);
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/FieldSchemaRulesFactory.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/FieldSchemaRulesFactory.ts
index 7e1b376f03..515f55b637 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/FieldSchemaRulesFactory.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/FieldSchemaRulesFactory.ts
@@ -44,6 +44,7 @@ import { LinkValueColumnRule } from './LinkValueColumnRule';
 import { NotNullConstraintRule } from './NotNullConstraintRule';
 import { OrderColumnRule } from './OrderColumnRule';
 import { ReferenceRule } from './ReferenceRule';
+import { SelectOptionsMetaRule } from './SelectOptionsMetaRule';
 import { UniqueIndexRule } from './UniqueIndexRule';
 
 /**
@@ -156,13 +157,13 @@ export class FieldSchemaRulesVisitor extends AbstractFieldVisitor<ReadonlyArray<
   visitSingleSelectField(
     field: SingleSelectField
   ): Result<ReadonlyArray<ISchemaRule>, DomainError> {
-    return ok(ColumnExistsRule.createRulesFromField(field));
+    return ok([...ColumnExistsRule.createRulesFromField(field), new SelectOptionsMetaRule(field)]);
   }
 
   visitMultipleSelectField(
     field: MultipleSelectField
   ): Result<ReadonlyArray<ISchemaRule>, DomainError> {
-    return ok(ColumnExistsRule.createRulesFromField(field));
+    return ok([...ColumnExistsRule.createRulesFromField(field), new SelectOptionsMetaRule(field)]);
   }
 
   visitCheckboxField(field: CheckboxField): Result<ReadonlyArray<ISchemaRule>, DomainError> {
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/FkColumnRule.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/FkColumnRule.ts
index 61e2ba8347..af1917753a 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/FkColumnRule.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/FkColumnRule.ts
@@ -6,6 +6,7 @@ import { resolveColumnName } from '../../visitors/PostgresTableSchemaFieldColumn
 import type { SchemaRuleContext } from '../context/SchemaRuleContext';
 import type {
   ISchemaRule,
+  SchemaRuleRepairHint,
   SchemaRuleValidationResult,
   TableSchemaStatementBuilder,
 } from '../core/ISchemaRule';
@@ -82,6 +83,23 @@ export class FkColumnRule implements ISchemaRule {
     });
   }
 
+  getRepairHint(
+    _ctx: SchemaRuleContext,
+    _validation: SchemaRuleValidationResult
+  ): Result<SchemaRuleRepairHint | undefined, DomainError> {
+    return ok({
+      available: true,
+      mode: 'auto',
+      reason: {
+        fallback: `Automatic repair will recreate the FK helper column for "${this.field.name().toString()}".`,
+      },
+      description: {
+        fallback:
+          'This repair treats the current link-value column in the underlying table as the recovery source and only backfills rows where the FK helper column is still empty. Existing FK values are preserved. If the stored link values are already missing or stale, the missing relations cannot be fully reconstructed and linked displays may remain incomplete.',
+      },
+    });
+  }
+
   up(ctx: SchemaRuleContext): Result<ReadonlyArray<TableSchemaStatementBuilder>, DomainError> {
     const self = this;
     return safeTry<ReadonlyArray<TableSchemaStatementBuilder>, DomainError>(function* () {
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/GeneratedColumnMetaRule.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/GeneratedColumnMetaRule.ts
index 07136ae440..3962860ca9 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/GeneratedColumnMetaRule.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/GeneratedColumnMetaRule.ts
@@ -9,6 +9,7 @@ import {
 import type { SchemaRuleContext } from '../context/SchemaRuleContext';
 import type {
   ISchemaRule,
+  SchemaRuleRepairHint,
   SchemaRuleValidationResult,
   TableSchemaStatementBuilder,
 } from '../core/ISchemaRule';
@@ -64,6 +65,23 @@ export class GeneratedColumnMetaRule implements ISchemaRule {
     });
   }
 
+  getRepairHint(
+    _ctx: SchemaRuleContext,
+    _validation: SchemaRuleValidationResult
+  ): Result<SchemaRuleRepairHint | undefined, DomainError> {
+    return ok({
+      available: true,
+      mode: 'auto',
+      reason: {
+        fallback: `Automatic repair will convert "${this.field.name().toString()}" back to a normal stored column.`,
+      },
+      description: {
+        fallback:
+          'This repair drops the current generated column and recreates a plain stored column to match field metadata. The old generated display values in that physical column are discarded, so the recreated column starts empty until another process repopulates it.',
+      },
+    });
+  }
+
   up(ctx: SchemaRuleContext): Result<ReadonlyArray<TableSchemaStatementBuilder>, DomainError> {
     return safeTry<ReadonlyArray<TableSchemaStatementBuilder>, DomainError>(function* () {
       const columnName = yield* resolveColumnName(ctx.field);
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/GeneratedColumnRule.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/GeneratedColumnRule.ts
index 88e5e21e6d..6ce9c8ebc3 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/GeneratedColumnRule.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/GeneratedColumnRule.ts
@@ -7,6 +7,7 @@ import { resolveColumnName } from '../../visitors/PostgresTableSchemaFieldColumn
 import type { SchemaRuleContext } from '../context/SchemaRuleContext';
 import type {
   ISchemaRule,
+  SchemaRuleRepairHint,
   SchemaRuleValidationResult,
   TableSchemaStatementBuilder,
 } from '../core/ISchemaRule';
@@ -106,6 +107,23 @@ export class GeneratedColumnRule implements ISchemaRule {
     });
   }
 
+  getRepairHint(
+    _ctx: SchemaRuleContext,
+    _validation: SchemaRuleValidationResult
+  ): Result<SchemaRuleRepairHint | undefined, DomainError> {
+    return ok({
+      available: true,
+      mode: 'auto',
+      reason: {
+        fallback: `Automatic repair will rebuild the generated column for "${this.field.name().toString()}".`,
+      },
+      description: {
+        fallback:
+          'This repair drops and recreates the physical column from its system source column. User-visible values are recalculated from underlying system data, so ad-hoc values that had drifted in the physical column will be discarded.',
+      },
+    });
+  }
+
   up(ctx: SchemaRuleContext): Result<ReadonlyArray<TableSchemaStatementBuilder>, DomainError> {
     const sourceColumn = this.sourceColumn;
     const columnType = this.columnType;
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/JunctionTableRule.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/JunctionTableRule.ts
index 04b0de4f16..7bf4ab3fc6 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/JunctionTableRule.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/JunctionTableRule.ts
@@ -1,7 +1,7 @@
 import { domainError, type DomainError, type LinkField } from '@teable/v2-core';
+import { sql } from 'kysely';
 import { err, ok, safeTry } from 'neverthrow';
 import type { Result } from 'neverthrow';
-import { sql } from 'kysely';
 
 import { resolveColumnName } from '../../visitors/PostgresTableSchemaFieldColumn';
 import type { SchemaRuleContext } from '../context/SchemaRuleContext';
@@ -227,6 +227,23 @@ export class JunctionTableExistsRule implements ISchemaRule {
     });
   }
 
+  getRepairHint(
+    _ctx: SchemaRuleContext,
+    _validation: SchemaRuleValidationResult
+  ): Result<SchemaRuleRepairHint | undefined, DomainError> {
+    return ok({
+      available: true,
+      mode: 'auto',
+      reason: {
+        fallback: `Automatic repair will recreate the junction table for "${this.field.name().toString()}".`,
+      },
+      description: {
+        fallback:
+          'This repair treats the current link-value column in the underlying source table as the recovery source. It recreates only the relation rows that can still be derived from those stored link values. Missing historical links cannot be recovered, and rebuilt ordering/display may follow the stored link-value order.',
+      },
+    });
+  }
+
   up(ctx: SchemaRuleContext): Result<ReadonlyArray<TableSchemaStatementBuilder>, DomainError> {
     const self = this;
     return safeTry<ReadonlyArray<TableSchemaStatementBuilder>, DomainError>(function* () {
@@ -282,6 +299,7 @@ export class JunctionTableExistsRule implements ISchemaRule {
       statements.push(
         backfillJunctionTableFromLinkValueStatement({
           sourceTable: config.sourceTable,
+          sourceTableId: ctx.tableId,
           sourceLinkValueColumnName,
           junctionTable: config.junctionTable,
           selfKeyName: config.selfKeyName,
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/LinkValueColumnRule.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/LinkValueColumnRule.ts
index 19d9e47f45..3fbc1782e3 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/LinkValueColumnRule.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/LinkValueColumnRule.ts
@@ -6,6 +6,7 @@ import { resolveColumnName } from '../../visitors/PostgresTableSchemaFieldColumn
 import type { SchemaRuleContext } from '../context/SchemaRuleContext';
 import type {
   ISchemaRule,
+  SchemaRuleRepairHint,
   SchemaRuleValidationResult,
   TableSchemaStatementBuilder,
 } from '../core/ISchemaRule';
@@ -57,6 +58,23 @@ export class LinkValueColumnRule implements ISchemaRule {
     });
   }
 
+  getRepairHint(
+    _ctx: SchemaRuleContext,
+    _validation: SchemaRuleValidationResult
+  ): Result<SchemaRuleRepairHint | undefined, DomainError> {
+    return ok({
+      available: true,
+      mode: 'auto',
+      reason: {
+        fallback: `Automatic repair will recreate the stored link-value column for "${this.field.name().toString()}".`,
+      },
+      description: {
+        fallback:
+          'This repair restores the JSONB display-value column only. Underlying relation ids in FK or junction storage are not rewritten, but linked cells may still display empty or stale values until those display payloads are rebuilt.',
+      },
+    });
+  }
+
   up(ctx: SchemaRuleContext): Result<ReadonlyArray<TableSchemaStatementBuilder>, DomainError> {
     return safeTry<ReadonlyArray<TableSchemaStatementBuilder>, DomainError>(function* () {
       const columnName = yield* resolveColumnName(ctx.field);
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/OrderColumnRule.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/OrderColumnRule.ts
index 9c74432624..47e7f760f8 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/OrderColumnRule.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/OrderColumnRule.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';
@@ -69,6 +70,23 @@ export class OrderColumnRule implements ISchemaRule {
     });
   }
 
+  getRepairHint(
+    _ctx: SchemaRuleContext,
+    _validation: SchemaRuleValidationResult
+  ): Result<SchemaRuleRepairHint | undefined, DomainError> {
+    return ok({
+      available: true,
+      mode: 'auto',
+      reason: {
+        fallback: `Automatic repair will recreate the order column for "${this.field.name().toString()}".`,
+      },
+      description: {
+        fallback:
+          'This repair restores only the helper column that stores link display order. Relation data stays intact, but custom ordering may be lost until order values are repopulated.',
+      },
+    });
+  }
+
   up(ctx: SchemaRuleContext): Result<ReadonlyArray<TableSchemaStatementBuilder>, DomainError> {
     const columnName = this.columnName;
     const targetTable = this.targetTable;
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 51ce1b6059..0762bb8c5e 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
@@ -13,7 +13,9 @@ import {
   createConditionalLookupFieldPending,
   createCreatedTimeField,
   createLinkField,
+  createMultipleSelectField,
   createLookupFieldPending,
+  createSingleSelectField,
   createSingleLineTextField,
   ConditionalLookupOptions,
   DbFieldName,
@@ -26,10 +28,12 @@ import {
   FieldUnique,
   GeneratedColumnMeta,
   LookupOptions,
+  SelectOption,
   Table,
   TableId,
   TableName,
 } from '@teable/v2-core';
+import { Pg16TypeValidationStrategy } from '@teable/v2-formula-sql-pg';
 import type { V1TeableDatabase } from '@teable/v2-postgres-schema';
 import type { Dialect, QueryResult } from 'kysely';
 import {
@@ -44,6 +48,7 @@ import { err, ok } from 'neverthrow';
 import type { Result } from 'neverthrow';
 import { afterAll, afterEach, beforeAll, describe, expect, it } from 'vitest';
 
+import { ComputedFieldBackfillService } from '../../../record/computed/ComputedFieldBackfillService';
 import { createSchemaChecker } from '../checker/SchemaChecker';
 import type { SchemaCheckResult } from '../checker/SchemaCheckResult';
 import { PostgresSchemaIntrospector } from '../context/PostgresSchemaIntrospector';
@@ -73,6 +78,7 @@ import { LinkValueColumnRule } from './LinkValueColumnRule';
 import { NotNullConstraintRule } from './NotNullConstraintRule';
 import { OrderColumnRule } from './OrderColumnRule';
 import { ReferenceRule } from './ReferenceRule';
+import { SelectOptionsMetaRule } from './SelectOptionsMetaRule';
 import { UniqueIndexRule } from './UniqueIndexRule';
 
 const TEST_SCHEMA = 'test_schema';
@@ -202,6 +208,35 @@ const createRealField = (
   return fieldResult;
 };
 
+const createRealFieldWithFieldId = (
+  id: string,
+  name: string,
+  dbFieldName: string
+): Result<Field, DomainError> => {
+  const fieldIdResult = FieldId.create(id);
+  if (fieldIdResult.isErr()) return err(fieldIdResult.error);
+
+  const fieldNameResult = FieldName.create(name);
+  if (fieldNameResult.isErr()) return err(fieldNameResult.error);
+
+  const dbFieldResult = DbFieldName.rehydrate(dbFieldName);
+  if (dbFieldResult.isErr()) return err(dbFieldResult.error);
+
+  const fieldResult = createSingleLineTextField({
+    id: fieldIdResult.value,
+    name: fieldNameResult.value,
+    notNull: FieldNotNull.optional(),
+    unique: FieldUnique.disabled(),
+  });
+
+  if (fieldResult.isErr()) return err(fieldResult.error);
+
+  const setResult = fieldResult.value.setDbFieldName(dbFieldResult.value);
+  if (setResult.isErr()) return err(setResult.error);
+
+  return fieldResult;
+};
+
 const createCreatedTimeFieldWithGeneratedMeta = (
   id: string,
   name: string,
@@ -233,6 +268,84 @@ const createCreatedTimeFieldWithGeneratedMeta = (
   return fieldResult;
 };
 
+const createSelectOptions = (
+  choices: ReadonlyArray<{ id: string; name: string; color: string }>
+): Result<ReadonlyArray<SelectOption>, DomainError> => {
+  const options: SelectOption[] = [];
+
+  for (const choice of choices) {
+    const optionResult = SelectOption.create(choice);
+    if (optionResult.isErr()) {
+      return err(optionResult.error);
+    }
+    options.push(optionResult.value);
+  }
+
+  return ok(options);
+};
+
+const createRealSingleSelectField = (params: {
+  id: string;
+  name: string;
+  dbFieldName: string;
+  choices: ReadonlyArray<{ id: string; name: string; color: string }>;
+}): Result<Field, DomainError> => {
+  const fieldIdResult = FieldId.create(createValidFieldId(params.id));
+  if (fieldIdResult.isErr()) return err(fieldIdResult.error);
+
+  const fieldNameResult = FieldName.create(params.name);
+  if (fieldNameResult.isErr()) return err(fieldNameResult.error);
+
+  const dbFieldResult = DbFieldName.rehydrate(params.dbFieldName);
+  if (dbFieldResult.isErr()) return err(dbFieldResult.error);
+
+  const optionsResult = createSelectOptions(params.choices);
+  if (optionsResult.isErr()) return err(optionsResult.error);
+
+  const fieldResult = createSingleSelectField({
+    id: fieldIdResult.value,
+    name: fieldNameResult.value,
+    options: optionsResult.value,
+  });
+  if (fieldResult.isErr()) return err(fieldResult.error);
+
+  const setResult = fieldResult.value.setDbFieldName(dbFieldResult.value);
+  if (setResult.isErr()) return err(setResult.error);
+
+  return fieldResult;
+};
+
+const createRealMultipleSelectField = (params: {
+  id: string;
+  name: string;
+  dbFieldName: string;
+  choices: ReadonlyArray<{ id: string; name: string; color: string }>;
+}): Result<Field, DomainError> => {
+  const fieldIdResult = FieldId.create(createValidFieldId(params.id));
+  if (fieldIdResult.isErr()) return err(fieldIdResult.error);
+
+  const fieldNameResult = FieldName.create(params.name);
+  if (fieldNameResult.isErr()) return err(fieldNameResult.error);
+
+  const dbFieldResult = DbFieldName.rehydrate(params.dbFieldName);
+  if (dbFieldResult.isErr()) return err(dbFieldResult.error);
+
+  const optionsResult = createSelectOptions(params.choices);
+  if (optionsResult.isErr()) return err(optionsResult.error);
+
+  const fieldResult = createMultipleSelectField({
+    id: fieldIdResult.value,
+    name: fieldNameResult.value,
+    options: optionsResult.value,
+  });
+  if (fieldResult.isErr()) return err(fieldResult.error);
+
+  const setResult = fieldResult.value.setDbFieldName(dbFieldResult.value);
+  if (setResult.isErr()) return err(setResult.error);
+
+  return fieldResult;
+};
+
 const createLookupField = (
   id: string,
   name: string,
@@ -446,10 +559,12 @@ describe('Schema Rules Unit Tests with PGlite', () => {
       name TEXT,
       description TEXT,
       type TEXT,
-      options JSONB,
+      options TEXT,
       table_id TEXT,
       tableId TEXT,
-      meta JSONB
+      db_field_name TEXT,
+      deleted_time TIMESTAMPTZ,
+      meta TEXT
     )`.execute(db);
 
     await sql`CREATE TABLE IF NOT EXISTS table_meta (
@@ -551,6 +666,73 @@ describe('Schema Rules Unit Tests with PGlite', () => {
     return tableResult.value;
   };
 
+  const createTableAggregateWithId = (
+    tableId: string,
+    tableName: string,
+    fields: ReadonlyArray<Field>,
+    primaryFieldId = fields[0]?.id()
+  ): Table => {
+    const tableIdResult = TableId.create(tableId);
+    if (tableIdResult.isErr()) {
+      throw new Error(tableIdResult.error.message);
+    }
+
+    const baseIdSeed = sanitizeIdSeed(tableName).padEnd(16, '0').slice(0, 16);
+    const baseIdResult = BaseId.create(`bse${baseIdSeed}`);
+    if (baseIdResult.isErr()) {
+      throw new Error(baseIdResult.error.message);
+    }
+
+    const tableNameResult = TableName.create(tableName);
+    if (tableNameResult.isErr()) {
+      throw new Error(tableNameResult.error.message);
+    }
+
+    const dbTableNameResult = DbTableName.rehydrate(`${TEST_SCHEMA}.${tableName}`);
+    if (dbTableNameResult.isErr()) {
+      throw new Error(dbTableNameResult.error.message);
+    }
+
+    if (!primaryFieldId) {
+      throw new Error('primaryFieldId is required');
+    }
+
+    const tableResult = Table.rehydrate({
+      id: tableIdResult.value,
+      baseId: baseIdResult.value,
+      name: tableNameResult.value,
+      fields,
+      views: [],
+      primaryFieldId,
+      dbTableName: dbTableNameResult.value,
+    });
+
+    if (tableResult.isErr()) {
+      throw new Error(tableResult.error.message);
+    }
+
+    return tableResult.value;
+  };
+
+  const createComputedBackfillService = (foreignTables: ReadonlyArray<Table>) =>
+    new ComputedFieldBackfillService(
+      {
+        find: async () => ok(foreignTables),
+        findOne: async () => ok(foreignTables[0]),
+      } as never,
+      {
+        debug: () => {},
+        info: () => {},
+        warn: () => {},
+        error: () => {},
+      } as never,
+      { hash: () => 'hash' } as never,
+      db,
+      { enqueueFieldBackfill: async () => ok({ taskId: 'task' }) } as never,
+      { mode: 'sync', hybridThreshold: 5000 },
+      new Pg16TypeValidationStrategy()
+    );
+
   const collectFinalResults = async (
     generator: AsyncGenerator<SchemaCheckResult, void, unknown>
   ): Promise<SchemaCheckResult[]> => {
@@ -2174,127 +2356,522 @@ describe('Schema Rules Unit Tests with PGlite', () => {
       // After down, meta is set to {} which doesn't have hasOrderColumn
       expect((await rule.isValid(ctx))._unsafeUnwrap().valid).toBe(false);
     });
-  });
-
-  describe('ReferenceRule', () => {
-    const TABLE_NAME = 'test_reference_rule';
 
-    it('should return valid when no references expected', async () => {
+    it('should merge metadata updates instead of overwriting unrelated keys', async () => {
       await createTestTable(TABLE_NAME);
 
-      const fieldResult = createRealField('ref001', 'Text', 'text_col');
+      const fieldResult = createRealField('fmr004', 'Link', 'link_col');
       const field = fieldResult._unsafeUnwrap();
 
-      const rule = new ReferenceRule(field, []);
-      const ctx = createContext(TABLE_NAME, field);
+      await sql`INSERT INTO field (id, name, meta) VALUES (${field.id().toString()}, 'Link', '{"foo":"bar","nested":{"keep":true}}') ON CONFLICT (id) DO NOTHING`.execute(
+        db
+      );
 
-      const result = await rule.isValid(ctx);
-      expect(result.isOk()).toBe(true);
-      expect(result._unsafeUnwrap().valid).toBe(true);
-    });
+      const rule = FieldMetaRule.forOrderColumn(field);
+      const ctx = createContext(TABLE_NAME, field);
 
-    it('should return invalid when reference entry does not exist', async () => {
-      await createTestTable(TABLE_NAME);
+      for (const stmt of rule.up(ctx)._unsafeUnwrap()) {
+        await db.executeQuery(stmt.compile(db));
+      }
 
-      const fieldResult = createRealField('ref002', 'Formula', 'formula_col');
-      const field = fieldResult._unsafeUnwrap();
+      const row = await db
+        .selectFrom('field')
+        .select('meta')
+        .where('id', '=', field.id().toString())
+        .executeTakeFirstOrThrow();
+      const meta =
+        typeof row.meta === 'string' ? JSON.parse(row.meta) : (row.meta as Record<string, unknown>);
+
+      expect(meta).toMatchObject({
+        foo: 'bar',
+        nested: { keep: true },
+        hasOrderColumn: true,
+      });
 
-      const rule = ReferenceRule.single(field, 'fld_source_field_001', { fieldType: 'formula' });
-      const ctx = createContext(TABLE_NAME, field);
+      for (const stmt of rule.down(ctx)._unsafeUnwrap()) {
+        await db.executeQuery(stmt.compile(db));
+      }
 
-      const result = await rule.isValid(ctx);
-      expect(result.isOk()).toBe(true);
-      expect(result._unsafeUnwrap().valid).toBe(false);
-      expect(result._unsafeUnwrap().missing?.some((m) => m.includes('reference entry'))).toBe(true);
+      const revertedRow = await db
+        .selectFrom('field')
+        .select('meta')
+        .where('id', '=', field.id().toString())
+        .executeTakeFirstOrThrow();
+      const revertedMeta =
+        typeof revertedRow.meta === 'string'
+          ? JSON.parse(revertedRow.meta)
+          : (revertedRow.meta as Record<string, unknown>);
+
+      expect(revertedMeta).toMatchObject({
+        foo: 'bar',
+        nested: { keep: true },
+      });
+      expect(revertedMeta).not.toHaveProperty('hasOrderColumn');
     });
 
-    it('up then down should return to original state', async () => {
+    it('should repair text-backed field meta columns', async () => {
       await createTestTable(TABLE_NAME);
 
-      const fieldResult = createRealField('ref003', 'Formula', 'formula_col');
+      const fieldResult = createRealField('fmr005', 'Link', 'link_col');
       const field = fieldResult._unsafeUnwrap();
 
-      const rule = ReferenceRule.single(field, 'fld_source_field_001', { fieldType: 'formula' });
-      const ctx = createContext(TABLE_NAME, field);
+      try {
+        await sql`INSERT INTO field (id, name, meta) VALUES (${field.id().toString()}, 'Link', ${JSON.stringify({ foo: 'bar' })})`.execute(
+          db
+        );
 
-      expect((await rule.isValid(ctx))._unsafeUnwrap().valid).toBe(false);
+        const rule = FieldMetaRule.forOrderColumn(field);
+        const ctx = createContext(TABLE_NAME, field);
 
-      for (const stmt of rule.up(ctx)._unsafeUnwrap()) {
-        await db.executeQuery(stmt.compile(db));
-      }
-      expect((await rule.isValid(ctx))._unsafeUnwrap().valid).toBe(true);
+        for (const stmt of rule.up(ctx)._unsafeUnwrap()) {
+          await db.executeQuery(stmt.compile(db));
+        }
 
-      for (const stmt of rule.down(ctx)._unsafeUnwrap()) {
-        await db.executeQuery(stmt.compile(db));
+        const row = await db
+          .selectFrom('field')
+          .select('meta')
+          .where('id', '=', field.id().toString())
+          .executeTakeFirstOrThrow();
+
+        expect(typeof row.meta).toBe('string');
+        expect(JSON.parse(row.meta as string)).toMatchObject({
+          foo: 'bar',
+          hasOrderColumn: true,
+        });
+      } finally {
+        await sql`DELETE FROM field WHERE id = ${field.id().toString()}`.execute(db);
       }
-      expect((await rule.isValid(ctx))._unsafeUnwrap().valid).toBe(false);
     });
+  });
 
-    it('should handle multiple references', async () => {
-      await createTestTable(TABLE_NAME);
-
-      const fieldResult = createRealField('ref004', 'Rollup', 'rollup_col');
+  describe('SelectOptionsMetaRule', () => {
+    const TABLE_NAME = 'test_select_options_rule';
+    const expectedChoices = [
+      { id: 'choKeep', name: 'Keep', color: 'blueBright' },
+      { id: 'choDone', name: 'Done', color: 'greenBright' },
+    ] as const;
+
+    it('should validate and repair select option choices without rewriting stored record values', async () => {
+      await createTestTable(TABLE_NAME, ['status_col TEXT']);
+
+      const fieldResult = createRealSingleSelectField({
+        id: 'som001',
+        name: 'Status',
+        dbFieldName: 'status_col',
+        choices: expectedChoices,
+      });
+      expect(fieldResult.isOk()).toBe(true);
       const field = fieldResult._unsafeUnwrap();
 
-      const rule = ReferenceRule.multiple(field, ['fld_link_field_001', 'fld_value_field_001'], {
-        fieldType: 'rollup',
-      });
+      await sql
+        .raw(
+          `INSERT INTO ${TEST_SCHEMA}.${TABLE_NAME} (__id, status_col) VALUES ('rec_status_1', 'choKeep')`
+        )
+        .execute(db);
+      await sql`INSERT INTO field (id, name, type, options, table_id)
+        VALUES (
+          ${field.id().toString()},
+          'Status',
+          'singleSelect',
+          ${JSON.stringify({
+            choices: [
+              { id: 'choDup', name: 'Legacy', color: 'redBright' },
+              { id: 'choDup', name: 'Legacy Duplicate', color: 'yellowBright' },
+            ],
+            defaultValue: 'choKeep',
+            preventAutoNewOptions: true,
+          })},
+          ${TABLE_NAME}
+        )`.execute(db);
+
+      const rule = new SelectOptionsMetaRule(field);
       const ctx = createContext(TABLE_NAME, field);
 
-      expect((await rule.isValid(ctx))._unsafeUnwrap().valid).toBe(false);
+      const invalidResult = await rule.isValid(ctx);
+      expect(invalidResult.isOk()).toBe(true);
+      expect(invalidResult._unsafeUnwrap().valid).toBe(false);
+      expect(invalidResult._unsafeUnwrap().missing).toContain(
+        'options.choices does not match the field definition'
+      );
 
       for (const stmt of rule.up(ctx)._unsafeUnwrap()) {
         await db.executeQuery(stmt.compile(db));
       }
+
       expect((await rule.isValid(ctx))._unsafeUnwrap().valid).toBe(true);
 
-      for (const stmt of rule.down(ctx)._unsafeUnwrap()) {
-        await db.executeQuery(stmt.compile(db));
-      }
-      expect((await rule.isValid(ctx))._unsafeUnwrap().valid).toBe(false);
+      const fieldRow = await db
+        .selectFrom('field')
+        .select('options')
+        .where('id', '=', field.id().toString())
+        .executeTakeFirstOrThrow();
+      const options =
+        typeof fieldRow.options === 'string'
+          ? JSON.parse(fieldRow.options)
+          : (fieldRow.options as Record<string, unknown>);
+
+      expect(options).toMatchObject({
+        choices: expectedChoices,
+        defaultValue: 'choKeep',
+        preventAutoNewOptions: true,
+      });
+
+      const recordRow = await sql<{ status_col: string }>`
+        SELECT status_col
+        FROM ${sql.id(TEST_SCHEMA)}.${sql.id(TABLE_NAME)}
+        WHERE __id = 'rec_status_1'
+      `.execute(db);
+      expect(recordRow.rows[0]?.status_col).toBe('choKeep');
     });
 
-    it('should deduplicate self-lookup reference rules when link and lookup ids match', () => {
-      const field = createSelfLookupField(
-        'self_lookup001',
-        'SelfLookup',
-        'self_lookup_col'
-      )._unsafeUnwrap();
-      const rulesResult = createFieldSchemaRules(field, {
-        schema: TEST_SCHEMA,
-        tableName: 'self_lookup_table',
-        tableId: 'self_lookup_table',
+    it('should remap single-select values that point to removed duplicate choices', async () => {
+      await createTestTable(TABLE_NAME, ['status_col TEXT']);
+
+      const fieldResult = createRealSingleSelectField({
+        id: 'som006',
+        name: 'Status Duplicate Choices',
+        dbFieldName: 'status_col',
+        choices: [
+          { id: 'choDup', name: 'Legacy', color: 'blueBright' },
+          { id: 'choDup', name: 'Legacy Duplicate', color: 'yellowBright' },
+          { id: 'choKeep', name: 'Keep', color: 'greenBright' },
+        ],
       });
+      expect(fieldResult.isOk()).toBe(true);
+      const field = fieldResult._unsafeUnwrap();
 
-      expect(rulesResult.isOk()).toBe(true);
+      await sql
+        .raw(
+          `INSERT INTO ${TEST_SCHEMA}.${TABLE_NAME} (__id, status_col) VALUES
+            ('rec_duplicate_name', 'Legacy Duplicate'),
+            ('rec_canonical_name', 'Legacy'),
+            ('rec_keep', 'Keep')`
+        )
+        .execute(db);
+      await sql`INSERT INTO field (id, name, type, options, table_id)
+        VALUES (
+          ${field.id().toString()},
+          'Status Duplicate Choices',
+          'singleSelect',
+          ${JSON.stringify({
+            choices: [
+              { id: 'choDup', name: 'Legacy', color: 'blueBright' },
+              { id: 'choDup', name: 'Legacy Duplicate', color: 'yellowBright' },
+              { id: 'choKeep', name: 'Keep', color: 'greenBright' },
+            ],
+          })},
+          ${TABLE_NAME}
+        )`.execute(db);
 
-      const referenceRules = rulesResult
-        ._unsafeUnwrap()
-        .filter((rule) => rule instanceof ReferenceRule);
-      expect(referenceRules).toHaveLength(1);
-      expect(referenceRules[0].id).toBe(
-        `reference:${field.id().toString()}:${createValidFieldId('dep_self_lookup001')}`
-      );
-    });
-  });
+      const rule = new SelectOptionsMetaRule(field);
+      const ctx = createContext(TABLE_NAME, field);
 
-  describe('SchemaChecker', () => {
-    const TABLE_NAME = 'test_schema_checker_rule';
+      for (const stmt of rule.up(ctx)._unsafeUnwrap()) {
+        await db.executeQuery(stmt.compile(db));
+      }
 
-    it('should report error when required column is missing', async () => {
-      await createTestTable(TABLE_NAME);
+      const rows = await sql<{ __id: string; status_col: string }>`
+        SELECT __id, status_col
+        FROM ${sql.id(TEST_SCHEMA)}.${sql.id(TABLE_NAME)}
+        ORDER BY __id
+      `.execute(db);
+      expect(rows.rows).toEqual([
+        { __id: 'rec_canonical_name', status_col: 'Legacy' },
+        { __id: 'rec_duplicate_name', status_col: 'Legacy' },
+        { __id: 'rec_keep', status_col: 'Keep' },
+      ]);
 
-      const fieldResult = createRealField('chk001', 'Name', 'name_col');
-      const field = fieldResult._unsafeUnwrap();
-      const table = createTableAggregate(TABLE_NAME, field);
+      const fieldRow = await db
+        .selectFrom('field')
+        .select('options')
+        .where('id', '=', field.id().toString())
+        .executeTakeFirstOrThrow();
+      const options = JSON.parse(fieldRow.options as string) as {
+        choices: ReadonlyArray<{ id: string; name: string; color: string }>;
+      };
+      expect(options.choices).toEqual([
+        { id: 'choDup', name: 'Legacy', color: 'blueBright' },
+        { id: 'choKeep', name: 'Keep', color: 'greenBright' },
+      ]);
+    });
 
-      const checker = createSchemaChecker({
-        db,
-        introspector,
-        schema: TEST_SCHEMA,
+    it('should remap and dedupe multiple-select values that point to removed duplicate choices', async () => {
+      await createTestTable(TABLE_NAME, ['tags_col JSONB']);
+
+      const fieldResult = createRealMultipleSelectField({
+        id: 'som007',
+        name: 'Tags Duplicate Choices',
+        dbFieldName: 'tags_col',
+        choices: [
+          { id: 'choDup', name: 'Legacy', color: 'blueBright' },
+          { id: 'choDup', name: 'Legacy Duplicate', color: 'yellowBright' },
+          { id: 'choKeep', name: 'Keep', color: 'greenBright' },
+        ],
       });
+      expect(fieldResult.isOk()).toBe(true);
+      const field = fieldResult._unsafeUnwrap();
 
-      const results = await collectFinalResults(checker.checkField(table, field.id().toString()));
+      await sql
+        .raw(
+          `INSERT INTO ${TEST_SCHEMA}.${TABLE_NAME} (__id, tags_col) VALUES
+            ('rec_tags', '["Legacy Duplicate","Legacy","Keep"]'::jsonb)`
+        )
+        .execute(db);
+      await sql`INSERT INTO field (id, name, type, options, table_id)
+        VALUES (
+          ${field.id().toString()},
+          'Tags Duplicate Choices',
+          'multipleSelect',
+          ${JSON.stringify({
+            choices: [
+              { id: 'choDup', name: 'Legacy', color: 'blueBright' },
+              { id: 'choDup', name: 'Legacy Duplicate', color: 'yellowBright' },
+              { id: 'choKeep', name: 'Keep', color: 'greenBright' },
+            ],
+          })},
+          ${TABLE_NAME}
+        )`.execute(db);
+
+      const rule = new SelectOptionsMetaRule(field);
+      const ctx = createContext(TABLE_NAME, field);
+
+      for (const stmt of rule.up(ctx)._unsafeUnwrap()) {
+        await db.executeQuery(stmt.compile(db));
+      }
+
+      const recordRow = await sql<{ tags_col: unknown }>`
+        SELECT tags_col
+        FROM ${sql.id(TEST_SCHEMA)}.${sql.id(TABLE_NAME)}
+        WHERE __id = 'rec_tags'
+      `.execute(db);
+      expect(recordRow.rows[0]?.tags_col).toEqual(['Legacy', 'Keep']);
+    });
+
+    it('should repair text-backed field options columns', async () => {
+      await createTestTable(TABLE_NAME, ['status_col TEXT']);
+
+      const fieldResult = createRealSingleSelectField({
+        id: 'som005',
+        name: 'Status Text Options',
+        dbFieldName: 'status_col',
+        choices: expectedChoices,
+      });
+      expect(fieldResult.isOk()).toBe(true);
+      const field = fieldResult._unsafeUnwrap();
+
+      try {
+        await sql`INSERT INTO field (id, name, type, options, table_id)
+          VALUES (
+            ${field.id().toString()},
+            'Status Text Options',
+            'singleSelect',
+            ${JSON.stringify({
+              choices: [{ id: 'choLegacy', name: 'Legacy', color: 'redBright' }],
+              defaultValue: 'choKeep',
+            })},
+            ${TABLE_NAME}
+          )`.execute(db);
+
+        const rule = new SelectOptionsMetaRule(field);
+        const ctx = createContext(TABLE_NAME, field);
+
+        for (const stmt of rule.up(ctx)._unsafeUnwrap()) {
+          await db.executeQuery(stmt.compile(db));
+        }
+
+        const row = await db
+          .selectFrom('field')
+          .select('options')
+          .where('id', '=', field.id().toString())
+          .executeTakeFirstOrThrow();
+
+        expect(typeof row.options).toBe('string');
+        expect(JSON.parse(row.options as string)).toMatchObject({
+          choices: expectedChoices,
+          defaultValue: 'choKeep',
+        });
+      } finally {
+        await sql`DELETE FROM field WHERE id = ${field.id().toString()}`.execute(db);
+      }
+    });
+
+    it('should surface display impact in the repair hint', () => {
+      const field = createRealSingleSelectField({
+        id: 'som002',
+        name: 'Status',
+        dbFieldName: 'status_col',
+        choices: expectedChoices,
+      })._unsafeUnwrap();
+      const rule = new SelectOptionsMetaRule(field);
+
+      const repairHint = rule.getRepairHint({} as SchemaRuleContext, { valid: false });
+
+      expect(repairHint.isOk()).toBe(true);
+      expect(repairHint._unsafeUnwrap()).toMatchObject({
+        available: true,
+        mode: 'auto',
+        description: {
+          fallback: expect.stringContaining(
+            'migrates cells that point at removed duplicate choice'
+          ),
+        },
+      });
+      expect(repairHint._unsafeUnwrap()?.description?.fallback).toContain('display');
+    });
+
+    it('should register the select options rule for both single and multiple select fields', () => {
+      const singleField = createRealSingleSelectField({
+        id: 'som003',
+        name: 'Single Status',
+        dbFieldName: 'single_status_col',
+        choices: expectedChoices,
+      })._unsafeUnwrap();
+      const multipleField = createRealMultipleSelectField({
+        id: 'som004',
+        name: 'Multiple Status',
+        dbFieldName: 'multiple_status_col',
+        choices: expectedChoices,
+      })._unsafeUnwrap();
+
+      const singleRules = createFieldSchemaRules(singleField, {
+        schema: TEST_SCHEMA,
+        tableName: TABLE_NAME,
+        tableId: TABLE_NAME,
+      })._unsafeUnwrap();
+      const multipleRules = createFieldSchemaRules(multipleField, {
+        schema: TEST_SCHEMA,
+        tableName: TABLE_NAME,
+        tableId: TABLE_NAME,
+      })._unsafeUnwrap();
+
+      expect(
+        singleRules.some((rule) => rule.id === `select_options:${singleField.id().toString()}`)
+      ).toBe(true);
+      expect(
+        multipleRules.some((rule) => rule.id === `select_options:${multipleField.id().toString()}`)
+      ).toBe(true);
+    });
+  });
+
+  describe('ReferenceRule', () => {
+    const TABLE_NAME = 'test_reference_rule';
+
+    it('should return valid when no references expected', async () => {
+      await createTestTable(TABLE_NAME);
+
+      const fieldResult = createRealField('ref001', 'Text', 'text_col');
+      const field = fieldResult._unsafeUnwrap();
+
+      const rule = new ReferenceRule(field, []);
+      const ctx = createContext(TABLE_NAME, field);
+
+      const result = await rule.isValid(ctx);
+      expect(result.isOk()).toBe(true);
+      expect(result._unsafeUnwrap().valid).toBe(true);
+    });
+
+    it('should return invalid when reference entry does not exist', async () => {
+      await createTestTable(TABLE_NAME);
+
+      const fieldResult = createRealField('ref002', 'Formula', 'formula_col');
+      const field = fieldResult._unsafeUnwrap();
+
+      const rule = ReferenceRule.single(field, 'fld_source_field_001', { fieldType: 'formula' });
+      const ctx = createContext(TABLE_NAME, field);
+
+      const result = await rule.isValid(ctx);
+      expect(result.isOk()).toBe(true);
+      expect(result._unsafeUnwrap().valid).toBe(false);
+      expect(result._unsafeUnwrap().missing?.some((m) => m.includes('reference entry'))).toBe(true);
+    });
+
+    it('up then down should return to original state', async () => {
+      await createTestTable(TABLE_NAME);
+
+      const fieldResult = createRealField('ref003', 'Formula', 'formula_col');
+      const field = fieldResult._unsafeUnwrap();
+
+      const rule = ReferenceRule.single(field, 'fld_source_field_001', { fieldType: 'formula' });
+      const ctx = createContext(TABLE_NAME, field);
+
+      expect((await rule.isValid(ctx))._unsafeUnwrap().valid).toBe(false);
+
+      for (const stmt of rule.up(ctx)._unsafeUnwrap()) {
+        await db.executeQuery(stmt.compile(db));
+      }
+      expect((await rule.isValid(ctx))._unsafeUnwrap().valid).toBe(true);
+
+      for (const stmt of rule.down(ctx)._unsafeUnwrap()) {
+        await db.executeQuery(stmt.compile(db));
+      }
+      expect((await rule.isValid(ctx))._unsafeUnwrap().valid).toBe(false);
+    });
+
+    it('should handle multiple references', async () => {
+      await createTestTable(TABLE_NAME);
+
+      const fieldResult = createRealField('ref004', 'Rollup', 'rollup_col');
+      const field = fieldResult._unsafeUnwrap();
+
+      const rule = ReferenceRule.multiple(field, ['fld_link_field_001', 'fld_value_field_001'], {
+        fieldType: 'rollup',
+      });
+      const ctx = createContext(TABLE_NAME, field);
+
+      expect((await rule.isValid(ctx))._unsafeUnwrap().valid).toBe(false);
+
+      for (const stmt of rule.up(ctx)._unsafeUnwrap()) {
+        await db.executeQuery(stmt.compile(db));
+      }
+      expect((await rule.isValid(ctx))._unsafeUnwrap().valid).toBe(true);
+
+      for (const stmt of rule.down(ctx)._unsafeUnwrap()) {
+        await db.executeQuery(stmt.compile(db));
+      }
+      expect((await rule.isValid(ctx))._unsafeUnwrap().valid).toBe(false);
+    });
+
+    it('should deduplicate self-lookup reference rules when link and lookup ids match', () => {
+      const field = createSelfLookupField(
+        'self_lookup001',
+        'SelfLookup',
+        'self_lookup_col'
+      )._unsafeUnwrap();
+      const rulesResult = createFieldSchemaRules(field, {
+        schema: TEST_SCHEMA,
+        tableName: 'self_lookup_table',
+        tableId: 'self_lookup_table',
+      });
+
+      expect(rulesResult.isOk()).toBe(true);
+
+      const referenceRules = rulesResult
+        ._unsafeUnwrap()
+        .filter((rule) => rule instanceof ReferenceRule);
+      expect(referenceRules).toHaveLength(1);
+      expect(referenceRules[0].id).toBe(
+        `reference:${field.id().toString()}:${createValidFieldId('dep_self_lookup001')}`
+      );
+    });
+  });
+
+  describe('SchemaChecker', () => {
+    const TABLE_NAME = 'test_schema_checker_rule';
+
+    it('should report error when required column is missing', async () => {
+      await createTestTable(TABLE_NAME);
+
+      const fieldResult = createRealField('chk001', 'Name', 'name_col');
+      const field = fieldResult._unsafeUnwrap();
+      const table = createTableAggregate(TABLE_NAME, field);
+
+      const checker = createSchemaChecker({
+        db,
+        introspector,
+        schema: TEST_SCHEMA,
+      });
+
+      const results = await collectFinalResults(checker.checkField(table, field.id().toString()));
 
       expect(results).toHaveLength(1);
       expect(results[0].status).toBe('error');
@@ -2381,7 +2958,7 @@ describe('Schema Rules Unit Tests with PGlite', () => {
           ${symmetricFieldId!},
           'Back Link',
           'link',
-          ${JSON.stringify({ symmetricFieldId: field.id().toString() })}::jsonb,
+          ${JSON.stringify({ symmetricFieldId: field.id().toString() })},
           ${FOREIGN_TABLE_NAME}
         )
       `.execute(db);
@@ -2391,7 +2968,7 @@ describe('Schema Rules Unit Tests with PGlite', () => {
           ${createValidFieldId('symdup01')},
           'Legacy One Way',
           'link',
-          ${JSON.stringify({ symmetricFieldId, isOneWay: true })}::jsonb,
+          ${JSON.stringify({ symmetricFieldId, isOneWay: true })},
           ${TABLE_NAME}
         )
       `.execute(db);
@@ -2431,7 +3008,7 @@ describe('Schema Rules Unit Tests with PGlite', () => {
           ${symmetricFieldId!},
           'Back Link',
           'link',
-          ${JSON.stringify({ symmetricFieldId: field.id().toString() })}::jsonb,
+          ${JSON.stringify({ symmetricFieldId: field.id().toString() })},
           ${FOREIGN_TABLE_NAME}
         )
       `.execute(db);
@@ -2441,7 +3018,7 @@ describe('Schema Rules Unit Tests with PGlite', () => {
           ${createValidFieldId('symdup02')},
           'Competing Link',
           'link',
-          ${JSON.stringify({ symmetricFieldId })}::jsonb,
+          ${JSON.stringify({ symmetricFieldId })},
           ${TABLE_NAME}
         )
       `.execute(db);
@@ -2462,6 +3039,95 @@ describe('Schema Rules Unit Tests with PGlite', () => {
     });
   });
 
+  describe('repair hints for high-risk rules', () => {
+    it('explains fk-column repair uses the stored link value column as recovery source', () => {
+      const field = createRealField('fkhint1', 'Link', 'link_col')._unsafeUnwrap();
+      const rule = FkColumnRule.forField(field, 'fk_link_col', 'target_table');
+
+      const repairHint = rule.getRepairHint({} as SchemaRuleContext, { valid: false });
+
+      expect(repairHint.isOk()).toBe(true);
+      expect(repairHint._unsafeUnwrap()).toMatchObject({
+        available: true,
+        mode: 'auto',
+        description: {
+          fallback: expect.stringContaining('underlying table as the recovery source'),
+        },
+      });
+    });
+
+    it('explains junction-table repair only reconstructs relations that still exist in stored link values', () => {
+      const field = createRealLinkField({
+        id: 'jhint01',
+        name: 'Projects',
+        dbFieldName: 'projects_link',
+        relationship: 'manyMany',
+        foreignTableId: createValidTableId('projects'),
+        fkHostTableName: 'projects_junction',
+        selfKeyName: 'task_id',
+        foreignKeyName: 'project_id',
+      })._unsafeUnwrap() as LinkField;
+
+      const rule = new JunctionTableExistsRule(field, {
+        junctionTable: { schema: TEST_SCHEMA, tableName: 'projects_junction' },
+        selfKeyName: 'task_id',
+        foreignKeyName: 'project_id',
+        sourceTable: { schema: TEST_SCHEMA, tableName: 'tasks' },
+        foreignTable: { schema: TEST_SCHEMA, tableName: 'projects' },
+        withIndexes: true,
+      });
+
+      const repairHint = rule.getRepairHint({} as SchemaRuleContext, { valid: false });
+
+      expect(repairHint.isOk()).toBe(true);
+      expect(repairHint._unsafeUnwrap()).toMatchObject({
+        available: true,
+        mode: 'auto',
+        description: {
+          fallback: expect.stringContaining('Missing historical links cannot be recovered'),
+        },
+      });
+    });
+
+    it('explains link-value-column repair may still leave display values empty or stale', () => {
+      const field = createRealField('lvhint1', 'Link Display', 'link_display_col')._unsafeUnwrap();
+      const rule = LinkValueColumnRule.forField(field, 'twoWay');
+
+      const repairHint = rule.getRepairHint({} as SchemaRuleContext, { valid: false });
+
+      expect(repairHint.isOk()).toBe(true);
+      expect(repairHint._unsafeUnwrap()).toMatchObject({
+        available: true,
+        mode: 'auto',
+        description: {
+          fallback: expect.stringContaining('display empty or stale values'),
+        },
+      });
+    });
+
+    it('explains generated-column-meta repair discards old generated display values when recreating a stored column', () => {
+      const field = createCreatedTimeFieldWithGeneratedMeta(
+        'gchint1',
+        'Created At',
+        'created_at_copy',
+        true
+      )._unsafeUnwrap();
+      const generatedRule = GeneratedColumnRule.forCreatedTime(field);
+      const rule = new GeneratedColumnMetaRule(field, generatedRule, generatedRule);
+
+      const repairHint = rule.getRepairHint({} as SchemaRuleContext, { valid: false });
+
+      expect(repairHint.isOk()).toBe(true);
+      expect(repairHint._unsafeUnwrap()).toMatchObject({
+        available: true,
+        mode: 'auto',
+        description: {
+          fallback: expect.stringContaining('old generated display values'),
+        },
+      });
+    });
+  });
+
   describe('SchemaRepairer', () => {
     const expectRuleRepairLifecycle = async (params: {
       table: Table;
@@ -2533,7 +3199,7 @@ describe('Schema Rules Unit Tests with PGlite', () => {
           ${symmetricFieldId!},
           'Back Link',
           'link',
-          ${JSON.stringify({ symmetricFieldId: field.id().toString() })}::jsonb,
+          ${JSON.stringify({ symmetricFieldId: field.id().toString() })},
           ${foreignTableName}
         )
       `.execute(db);
@@ -2543,7 +3209,7 @@ describe('Schema Rules Unit Tests with PGlite', () => {
           ${createValidFieldId('symmreq3')},
           'Competing Link',
           'link',
-          ${JSON.stringify({ symmetricFieldId })}::jsonb,
+          ${JSON.stringify({ symmetricFieldId })},
           ${table.id().toString()}
         )
       `.execute(db);
@@ -2584,7 +3250,7 @@ describe('Schema Rules Unit Tests with PGlite', () => {
           ${symmetricFieldId!},
           'Back Link',
           'link',
-          ${JSON.stringify({ symmetricFieldId: field.id().toString() })}::jsonb,
+          ${JSON.stringify({ symmetricFieldId: field.id().toString() })},
           ${foreignTableName}
         )
       `.execute(db);
@@ -2594,7 +3260,7 @@ describe('Schema Rules Unit Tests with PGlite', () => {
           ${duplicateFieldId},
           'Competing Link',
           'link',
-          ${JSON.stringify({ symmetricFieldId })}::jsonb,
+          ${JSON.stringify({ symmetricFieldId })},
           ${table.id().toString()}
         )
       `.execute(db);
@@ -2821,9 +3487,12 @@ describe('Schema Rules Unit Tests with PGlite', () => {
       );
 
       expect(columnRule?.status).toBe('error');
-      expect(columnRule?.repair).toEqual({
+      expect(columnRule?.repair).toMatchObject({
         available: true,
         mode: 'auto',
+        reason: {
+          fallback: 'Automatic repair will recreate the missing physical column for "Name".',
+        },
       });
     });
 
@@ -3304,6 +3973,23 @@ describe('Schema Rules Unit Tests with PGlite', () => {
           { record_id: 'rec_source_b', fk_value: 'rec_target_b' },
         ]);
 
+        const sourceRows = await sql<{ record_id: string; link_value: unknown }>`
+          SELECT __id AS record_id, link_value
+          FROM ${sql.id(TEST_SCHEMA)}.${sql.id(sourceTableName)}
+          ORDER BY __id
+        `.execute(db);
+
+        expect(sourceRows.rows).toEqual([
+          {
+            record_id: 'rec_source_a',
+            link_value: { id: 'rec_target_a', title: 'Target A' },
+          },
+          {
+            record_id: 'rec_source_b',
+            link_value: { id: 'rec_target_b', title: 'Target B' },
+          },
+        ]);
+
         const checker = createSchemaChecker({ db, introspector, schema: TEST_SCHEMA });
         const checkResults = await collectFinalResults(
           checker.checkField(table, field.id().toString())
@@ -3400,6 +4086,26 @@ describe('Schema Rules Unit Tests with PGlite', () => {
         { record_id: 'rec_target_c', fk_value: 'rec_source_b' },
       ]);
 
+      const sourceRows = await sql<{ record_id: string; link_value: unknown }>`
+        SELECT __id AS record_id, link_value
+        FROM ${sql.id(TEST_SCHEMA)}.${sql.id(sourceTableName)}
+        ORDER BY __id
+      `.execute(db);
+
+      expect(sourceRows.rows).toEqual([
+        {
+          record_id: 'rec_source_a',
+          link_value: [
+            { id: 'rec_target_a', title: 'Target A' },
+            { id: 'rec_target_b', title: 'Target B' },
+          ],
+        },
+        {
+          record_id: 'rec_source_b',
+          link_value: [{ id: 'rec_target_c', title: 'Target C' }],
+        },
+      ]);
+
       const checker = createSchemaChecker({ db, introspector, schema: TEST_SCHEMA });
       const checkResults = await collectFinalResults(
         checker.checkField(table, field.id().toString())
@@ -3493,6 +4199,17 @@ describe('Schema Rules Unit Tests with PGlite', () => {
         { self_id: 'rec_source_a', foreign_id: 'rec_target_a' },
         { self_id: 'rec_source_a', foreign_id: 'rec_target_b' },
       ]);
+
+      const sourceRows = await sql<{ link_value: unknown }>`
+        SELECT link_value
+        FROM ${sql.id(TEST_SCHEMA)}.${sql.id(sourceTableName)}
+        WHERE __id = 'rec_source_a'
+      `.execute(db);
+
+      expect(sourceRows.rows[0]?.link_value).toEqual([
+        { id: 'rec_target_a', title: 'Target A' },
+        { id: 'rec_target_b', title: 'Target B' },
+      ]);
     });
 
     it('should repair a dropped junction table and backfill manyMany link rows with order', async () => {
@@ -3575,6 +4292,332 @@ describe('Schema Rules Unit Tests with PGlite', () => {
         { self_id: 'rec_source_a', foreign_id: 'rec_target_b', order_value: 1 },
         { self_id: 'rec_source_a', foreign_id: 'rec_target_a', order_value: 2 },
       ]);
+
+      const sourceRows = await sql<{ link_value: unknown }>`
+        SELECT link_value
+        FROM ${sql.id(TEST_SCHEMA)}.${sql.id(sourceTableName)}
+        WHERE __id = 'rec_source_a'
+      `.execute(db);
+
+      expect(sourceRows.rows[0]?.link_value).toEqual([
+        { id: 'rec_target_b', title: 'Target B' },
+        { id: 'rec_target_a', title: 'Target A' },
+      ]);
+    });
+
+    it('should not backfill a repaired junction table from an ambiguous shared link value column', async () => {
+      const sourceTableName = createValidTableId('src_many_many_ambiguous');
+      const targetTableName = createValidTableId('tgt_many_many_ambiguous');
+      const junctionTableName = 'junction_many_many_ambiguous';
+      const selfKeyName = '__fk_many_many_ambiguous_self';
+      const foreignKeyName = '__fk_many_many_ambiguous_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(
+          `
+          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: 'ambiguousA',
+        name: 'ManyMany Ambiguous Link',
+        dbFieldName: 'link_value',
+        relationship: 'manyMany',
+        foreignTableId: targetTableName,
+        fkHostTableName: junctionTableName,
+        selfKeyName,
+        foreignKeyName,
+        hasOrderColumn: true,
+      })._unsafeUnwrap();
+      const table = createTableAggregate(sourceTableName, field);
+      const sourceTableId = table.id().toString();
+
+      await sql`
+        INSERT INTO field (id, name, type, table_id, db_field_name)
+        VALUES
+          (${field.id().toString()}, 'ManyMany Ambiguous Link', 'link', ${sourceTableId}, 'link_value'),
+          (${createValidFieldId('otherLinkB')}, 'Other Link', 'link', ${sourceTableId}, 'link_value')
+      `.execute(db);
+
+      await sql.raw(`DROP TABLE ${TEST_SCHEMA}.${junctionTableName}`).execute(db);
+
+      const repairer = createSchemaRepairer({ db, introspector, schema: TEST_SCHEMA });
+      const repairResults = await collectFinalRepairResults(
+        repairer.repairField(table, field.id().toString())
+      );
+
+      expect(
+        repairResults.find((result) => result.ruleId === `junction_table:${field.id().toString()}`)
+          ?.outcome
+      ).toBe('repaired');
+
+      const junctionRows = await sql<{ self_id: string; foreign_id: string }>`
+        SELECT
+          ${sql.id(selfKeyName)} AS self_id,
+          ${sql.id(foreignKeyName)} AS foreign_id
+        FROM ${sql.id(TEST_SCHEMA)}.${sql.id(junctionTableName)}
+      `.execute(db);
+
+      expect(junctionRows.rows).toEqual([]);
+
+      await sql`DELETE FROM field WHERE table_id = ${sourceTableId}`.execute(db);
+    });
+
+    it('should preserve FK-backed link values after repair and computed backfill', async () => {
+      const sourceTableName = createValidTableId('src_fk_recompute');
+      const targetTableName = createValidTableId('tgt_fk_recompute');
+      const fkColumnName = '__fk_recompute_link';
+      const fieldSeed = 'rpfkrecompute';
+      const lookupFieldId = createValidFieldId(`lookup_${fieldSeed}`);
+
+      await createTestTable(targetTableName, [
+        '__version INTEGER DEFAULT 1',
+        '__auto_number INTEGER',
+        'title_col TEXT',
+      ]);
+      await createTestTable(sourceTableName, [
+        '__version INTEGER DEFAULT 1',
+        'link_value JSONB',
+        `"${fkColumnName}" TEXT`,
+      ]);
+
+      await sql
+        .raw(
+          `
+          INSERT INTO ${TEST_SCHEMA}.${targetTableName} (__id, __auto_number, title_col)
+          VALUES ('rec_target_a', 1, 'Target A'), ('rec_target_b', 2, 'Target B')
+        `
+        )
+        .execute(db);
+      await sql
+        .raw(
+          `
+          INSERT INTO ${TEST_SCHEMA}.${sourceTableName} (__id, link_value, "${fkColumnName}")
+          VALUES
+            ('rec_source_a', '{"id":"rec_target_a","title":"Target A"}'::jsonb, 'rec_target_a'),
+            ('rec_source_b', '{"id":"rec_target_b","title":"Target B"}'::jsonb, 'rec_target_b')
+        `
+        )
+        .execute(db);
+
+      const field = createRealLinkField({
+        id: fieldSeed,
+        name: 'FK Recompute Link',
+        dbFieldName: 'link_value',
+        relationship: 'manyOne',
+        foreignTableId: targetTableName,
+        fkHostTableName: `${TEST_SCHEMA}.${sourceTableName}`,
+        selfKeyName: '__id',
+        foreignKeyName: fkColumnName,
+        hasOrderColumn: false,
+      })._unsafeUnwrap();
+      const titleField = createRealFieldWithFieldId(
+        lookupFieldId,
+        'Title',
+        'title_col'
+      )._unsafeUnwrap();
+      const sourceTable = createTableAggregateWithId(sourceTableName, sourceTableName, [field]);
+      const targetTable = createTableAggregateWithId(
+        targetTableName,
+        targetTableName,
+        [titleField],
+        titleField.id()
+      );
+
+      await sql
+        .raw(`ALTER TABLE ${TEST_SCHEMA}.${sourceTableName} DROP COLUMN "${fkColumnName}" CASCADE`)
+        .execute(db);
+
+      const repairer = createSchemaRepairer({ db, introspector, schema: TEST_SCHEMA });
+      const repairResults = await collectFinalRepairResults(
+        repairer.repairField(sourceTable, field.id().toString())
+      );
+
+      expect(
+        repairResults.find((result) => result.ruleId === `fk_column:${field.id().toString()}`)
+          ?.outcome
+      ).toBe('repaired');
+
+      const backfillService = createComputedBackfillService([targetTable]);
+      const backfillResult = await backfillService.backfillMany({} as never, {
+        table: sourceTable,
+        fields: [field],
+      });
+
+      expect(backfillResult.isOk()).toBe(true);
+
+      const sourceRows = await sql<{ record_id: string; link_value: unknown }>`
+        SELECT __id AS record_id, link_value
+        FROM ${sql.id(TEST_SCHEMA)}.${sql.id(sourceTableName)}
+        ORDER BY __id
+      `.execute(db);
+
+      expect(sourceRows.rows).toEqual([
+        {
+          record_id: 'rec_source_a',
+          link_value: { id: 'rec_target_a', title: 'Target A' },
+        },
+        {
+          record_id: 'rec_source_b',
+          link_value: { id: 'rec_target_b', title: 'Target B' },
+        },
+      ]);
+
+      const checker = createSchemaChecker({ db, introspector, schema: TEST_SCHEMA });
+      const checkResults = await collectFinalResults(
+        checker.checkField(sourceTable, field.id().toString())
+      );
+      expect(
+        checkResults.find((result) => result.ruleId === `fk_column:${field.id().toString()}`)
+          ?.status
+      ).toBe('success');
+      expect(
+        checkResults.find(
+          (result) => result.ruleId === `fk:${field.id().toString()}:${fkColumnName}`
+        )?.status
+      ).toBe('success');
+    });
+
+    it('should preserve junction-backed link values after repair and computed backfill', async () => {
+      const sourceTableName = createValidTableId('src_junction_recompute');
+      const targetTableName = createValidTableId('tgt_junction_recompute');
+      const junctionTableName = 'junction_recompute_link';
+      const selfKeyName = '__fk_recompute_self';
+      const foreignKeyName = '__fk_recompute_foreign';
+      const fieldSeed = 'rpjctrecompute';
+      const lookupFieldId = createValidFieldId(`lookup_${fieldSeed}`);
+
+      await createTestTable(sourceTableName, ['__version INTEGER DEFAULT 1', 'link_value JSONB']);
+      await createTestTable(targetTableName, [
+        '__version INTEGER DEFAULT 1',
+        '__auto_number INTEGER',
+        'title_col TEXT',
+      ]);
+      await createExplicitTestTable(junctionTableName, [
+        '__id SERIAL PRIMARY KEY',
+        `"${selfKeyName}" TEXT`,
+        `"${foreignKeyName}" TEXT`,
+        '__order DOUBLE PRECISION',
+      ]);
+
+      await sql
+        .raw(
+          `
+          INSERT INTO ${TEST_SCHEMA}.${sourceTableName} (__id, link_value)
+          VALUES
+            ('rec_source_a', '[{"id":"rec_target_b","title":"Target B"},{"id":"rec_target_a","title":"Target A"}]'::jsonb)
+        `
+        )
+        .execute(db);
+      await sql
+        .raw(
+          `
+          INSERT INTO ${TEST_SCHEMA}.${targetTableName} (__id, __auto_number, title_col)
+          VALUES ('rec_target_a', 1, 'Target A'), ('rec_target_b', 2, 'Target B')
+        `
+        )
+        .execute(db);
+      await sql
+        .raw(
+          `
+          INSERT INTO ${TEST_SCHEMA}.${junctionTableName} ("${selfKeyName}", "${foreignKeyName}", "__order")
+          VALUES ('rec_source_a', 'rec_target_b', 1), ('rec_source_a', 'rec_target_a', 2)
+        `
+        )
+        .execute(db);
+
+      const field = createRealLinkField({
+        id: fieldSeed,
+        name: 'Junction Recompute Link',
+        dbFieldName: 'link_value',
+        relationship: 'manyMany',
+        foreignTableId: targetTableName,
+        fkHostTableName: `${TEST_SCHEMA}.${junctionTableName}`,
+        selfKeyName,
+        foreignKeyName,
+        hasOrderColumn: true,
+      })._unsafeUnwrap();
+      const titleField = createRealFieldWithFieldId(
+        lookupFieldId,
+        'Title',
+        'title_col'
+      )._unsafeUnwrap();
+      const sourceTable = createTableAggregateWithId(sourceTableName, sourceTableName, [field]);
+      const targetTable = createTableAggregateWithId(
+        targetTableName,
+        targetTableName,
+        [titleField],
+        titleField.id()
+      );
+
+      await sql.raw(`DROP TABLE ${TEST_SCHEMA}.${junctionTableName}`).execute(db);
+
+      const repairer = createSchemaRepairer({ db, introspector, schema: TEST_SCHEMA });
+      const repairResults = await collectFinalRepairResults(
+        repairer.repairField(sourceTable, field.id().toString())
+      );
+
+      expect(
+        repairResults.find((result) => result.ruleId === `junction_table:${field.id().toString()}`)
+          ?.outcome
+      ).toBe('repaired');
+
+      const backfillService = createComputedBackfillService([targetTable]);
+      const backfillResult = await backfillService.backfillMany({} as never, {
+        table: sourceTable,
+        fields: [field],
+      });
+
+      expect(backfillResult.isOk()).toBe(true);
+
+      const sourceRows = await sql<{ link_value: unknown }>`
+        SELECT link_value
+        FROM ${sql.id(TEST_SCHEMA)}.${sql.id(sourceTableName)}
+        WHERE __id = 'rec_source_a'
+      `.execute(db);
+
+      expect(sourceRows.rows[0]?.link_value).toEqual([
+        { id: 'rec_target_b', title: 'Target B' },
+        { id: 'rec_target_a', title: 'Target A' },
+      ]);
+
+      const checker = createSchemaChecker({ db, introspector, schema: TEST_SCHEMA });
+      const checkResults = await collectFinalResults(
+        checker.checkField(sourceTable, field.id().toString())
+      );
+      expect(
+        checkResults.find((result) => result.ruleId === `junction_table:${field.id().toString()}`)
+          ?.status
+      ).toBe('success');
+      expect(
+        checkResults.find((result) => result.ruleId === `junction_fk:${field.id().toString()}:self`)
+          ?.status
+      ).toBe('success');
+      expect(
+        checkResults.find(
+          (result) => result.ruleId === `junction_fk:${field.id().toString()}:foreign`
+        )?.status
+      ).toBe('success');
     });
 
     it('should repair a single reference rule using a checker-provided rule id', async () => {
@@ -3979,7 +5022,7 @@ describe('Schema Rules Unit Tests with PGlite', () => {
         })._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(
+        await sql`INSERT INTO field (id, name, meta) VALUES (${field.id().toString()}, 'Field Meta Rule', '{}') ON CONFLICT (id) DO UPDATE SET meta = '{}'`.execute(
           db
         );
 
@@ -3988,13 +5031,17 @@ describe('Schema Rules Unit Tests with PGlite', () => {
           fieldId: field.id().toString(),
           ruleId: `field_meta:${field.id().toString()}`,
           verifyAfterRepair: async () => {
-            const record = await sql<{ meta: Record<string, unknown> }>`
+            const record = await sql<{ meta: string | Record<string, unknown> }>`
               SELECT meta
               FROM field
               WHERE id = ${field.id().toString()}
             `.execute(db);
+            const meta =
+              typeof record.rows[0]?.meta === 'string'
+                ? JSON.parse(record.rows[0].meta)
+                : record.rows[0]?.meta;
 
-            expect(record.rows[0]?.meta).toMatchObject({ hasOrderColumn: true });
+            expect(meta).toMatchObject({ hasOrderColumn: true });
           },
         });
       });
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/SelectOptionsMetaRule.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/SelectOptionsMetaRule.ts
new file mode 100644
index 0000000000..9a6417a755
--- /dev/null
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/SelectOptionsMetaRule.ts
@@ -0,0 +1,312 @@
+import type { DomainError, MultipleSelectField, SingleSelectField } from '@teable/v2-core';
+import { sql } from 'kysely';
+import { ok, safeTry } from 'neverthrow';
+import type { Result } from 'neverthrow';
+
+import { resolveColumnName } from '../../visitors/PostgresTableSchemaFieldColumn';
+import type { SchemaRuleContext } from '../context/SchemaRuleContext';
+import type {
+  ISchemaRule,
+  SchemaRuleRepairHint,
+  SchemaRuleValidationResult,
+  TableSchemaStatementBuilder,
+} from '../core/ISchemaRule';
+import {
+  compressSql,
+  quoteIdentifier,
+  quoteLiteral,
+  quoteTableIdentifier,
+} from '../helpers/StatementBuilders';
+
+type SelectField = SingleSelectField | MultipleSelectField;
+type SelectChoiceDto = {
+  id: string;
+  name: string;
+  color: string;
+};
+
+const normalizeSelectChoice = (value: unknown): SelectChoiceDto | undefined => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return undefined;
+  }
+
+  const candidate = value as Partial<SelectChoiceDto>;
+  if (
+    typeof candidate.id !== 'string' ||
+    typeof candidate.name !== 'string' ||
+    typeof candidate.color !== 'string'
+  ) {
+    return undefined;
+  }
+
+  return {
+    id: candidate.id,
+    name: candidate.name,
+    color: candidate.color,
+  };
+};
+
+export class SelectOptionsMetaRule implements ISchemaRule {
+  readonly id: string;
+  readonly description: string;
+  readonly dependencies: ReadonlyArray<string>;
+  readonly required = true;
+
+  constructor(
+    private readonly field: SelectField,
+    dependsOnRuleId?: string
+  ) {
+    this.id = `select_options:${field.id().toString()}`;
+    this.description = `Select options metadata for "${field.name().toString()}"`;
+    this.dependencies = dependsOnRuleId ? [dependsOnRuleId] : [];
+  }
+
+  private expectedChoices(): ReadonlyArray<SelectChoiceDto> {
+    const choices: SelectChoiceDto[] = [];
+    const seenIds = new Set<string>();
+    const seenNames = new Set<string>();
+
+    for (const option of this.field.selectOptions()) {
+      const dto = option.toDto();
+      if (seenIds.has(dto.id) || seenNames.has(dto.name)) {
+        continue;
+      }
+      seenIds.add(dto.id);
+      seenNames.add(dto.name);
+      choices.push(dto);
+    }
+
+    return choices;
+  }
+
+  private parseOptions(raw: unknown): Record<string, unknown> | undefined {
+    if (raw == null) {
+      return {};
+    }
+
+    if (typeof raw === 'string') {
+      try {
+        const parsed = JSON.parse(raw) as unknown;
+        return this.parseOptions(parsed);
+      } catch {
+        return undefined;
+      }
+    }
+
+    if (typeof raw !== 'object' || Array.isArray(raw)) {
+      return undefined;
+    }
+
+    return raw as Record<string, unknown>;
+  }
+
+  private normalizeChoices(value: unknown): ReadonlyArray<SelectChoiceDto> | undefined {
+    if (!Array.isArray(value)) {
+      return undefined;
+    }
+
+    const normalized: SelectChoiceDto[] = [];
+    for (const item of value) {
+      const choice = normalizeSelectChoice(item);
+      if (!choice) {
+        return undefined;
+      }
+      normalized.push(choice);
+    }
+
+    return normalized;
+  }
+
+  async isValid(ctx: SchemaRuleContext): Promise<Result<SchemaRuleValidationResult, DomainError>> {
+    const fieldId = this.field.id().toString();
+    const result = await ctx.db
+      .selectFrom('field')
+      .select('options')
+      .where('id', '=', fieldId)
+      .executeTakeFirst();
+
+    if (!result) {
+      return ok({
+        valid: false,
+        missing: [`field record with id "${fieldId}" not found in field table`],
+      });
+    }
+
+    const currentOptions = this.parseOptions(result.options);
+    if (!currentOptions) {
+      return ok({
+        valid: false,
+        missing: [`field "${fieldId}" has invalid JSON in options column`],
+      });
+    }
+
+    const currentChoices = this.normalizeChoices(currentOptions.choices);
+    if (!currentChoices) {
+      return ok({
+        valid: false,
+        missing: ['options.choices is missing or invalid'],
+      });
+    }
+
+    if (JSON.stringify(currentChoices) !== JSON.stringify(this.expectedChoices())) {
+      return ok({
+        valid: false,
+        missing: ['options.choices does not match the field definition'],
+      });
+    }
+
+    return ok({ valid: true });
+  }
+
+  getRepairHint(
+    _ctx: SchemaRuleContext,
+    _validation: SchemaRuleValidationResult
+  ): Result<SchemaRuleRepairHint | undefined, DomainError> {
+    return ok({
+      available: true,
+      mode: 'auto',
+      reason: {
+        fallback: `Automatic repair will reconcile select option metadata for "${this.field.name().toString()}".`,
+      },
+      description: {
+        fallback:
+          'This repair rewrites field.options.choices to match the field definition, migrates cells that point at removed duplicate choice IDs or names to the retained choice, and preserves unrelated option keys. Labels, colors, and option order can change immediately in the UI. Cells that point at choices with no retained ID or name match may still display empty or unknown values until those stored values are corrected separately.',
+      },
+    });
+  }
+
+  up(ctx: SchemaRuleContext): Result<ReadonlyArray<TableSchemaStatementBuilder>, DomainError> {
+    const rule = this;
+    return safeTry<ReadonlyArray<TableSchemaStatementBuilder>, DomainError>(function* () {
+      const fieldId = rule.field.id().toString();
+      const columnName = yield* resolveColumnName(ctx.field);
+      const patch = JSON.stringify({ choices: rule.expectedChoices() });
+      const updateOptions = ctx.db
+        .updateTable('field')
+        .set({
+          options: sql`(coalesce(options::jsonb, '{}'::jsonb) || ${patch}::jsonb)::text`,
+        })
+        .where('id', '=', fieldId);
+
+      return ok([rule.repairStoredChoiceValues(ctx, columnName), updateOptions]);
+    });
+  }
+
+  down(ctx: SchemaRuleContext): Result<ReadonlyArray<TableSchemaStatementBuilder>, DomainError> {
+    const fieldId = this.field.id().toString();
+    const updateOptions = ctx.db
+      .updateTable('field')
+      .set({
+        options: sql`(coalesce(options::jsonb, '{}'::jsonb) - 'choices')::text`,
+      })
+      .where('id', '=', fieldId);
+
+    return ok([updateOptions]);
+  }
+
+  private buildChoiceTokenMapSql(): string {
+    return compressSql(`
+      current_choices AS (
+        SELECT
+          choice->>'id' AS old_id,
+          choice->>'name' AS old_name
+        FROM field f
+        CROSS JOIN LATERAL jsonb_array_elements(
+          COALESCE(f.options::jsonb->'choices', '[]'::jsonb)
+        ) AS choice
+        WHERE f.id = ${quoteLiteral(this.field.id().toString())}
+      ),
+      canonical_choices AS (
+        SELECT
+          choice->>'id' AS id,
+          choice->>'name' AS name
+        FROM jsonb_array_elements(${quoteLiteral(JSON.stringify(this.expectedChoices()))}::jsonb) AS choice
+      ),
+      choice_token_map AS (
+        SELECT DISTINCT ON (token)
+          token,
+          canonical_name
+        FROM (
+          SELECT
+            CASE
+              WHEN c.old_id IS NOT NULL AND c.old_id <> canonical.id THEN c.old_id
+            END AS token,
+            canonical.name AS canonical_name
+          FROM current_choices c
+          CROSS JOIN LATERAL (
+            SELECT e.id, e.name
+            FROM canonical_choices e
+            WHERE e.id = c.old_id OR e.name = c.old_name
+            ORDER BY CASE WHEN e.id = c.old_id THEN 0 ELSE 1 END
+            LIMIT 1
+          ) canonical
+          UNION ALL
+          SELECT
+            CASE
+              WHEN c.old_name IS NOT NULL AND c.old_name <> canonical.name THEN c.old_name
+            END AS token,
+            canonical.name AS canonical_name
+          FROM current_choices c
+          CROSS JOIN LATERAL (
+            SELECT e.id, e.name
+            FROM canonical_choices e
+            WHERE e.id = c.old_id OR e.name = c.old_name
+            ORDER BY CASE WHEN e.id = c.old_id THEN 0 ELSE 1 END
+            LIMIT 1
+          ) canonical
+        ) mapped
+        WHERE token IS NOT NULL AND token <> ''
+        ORDER BY token
+      )
+    `);
+  }
+
+  private repairStoredChoiceValues(
+    ctx: SchemaRuleContext,
+    columnName: string
+  ): TableSchemaStatementBuilder {
+    const tableName = quoteTableIdentifier({ schema: ctx.schema, tableName: ctx.tableName });
+    const column = quoteIdentifier(columnName);
+
+    if (this.field.type().toString() === 'multipleSelect') {
+      return sql.raw(
+        compressSql(`
+          WITH ${this.buildChoiceTokenMapSql()}
+          UPDATE ${tableName} AS t
+          SET ${column} = COALESCE(
+            (
+              SELECT jsonb_agg(d.mapped_value ORDER BY d.ord)
+              FROM (
+                SELECT mapped_value, MIN(ord) AS ord
+                FROM (
+                  SELECT
+                    COALESCE(m.canonical_name, elem.value #>> '{}') AS mapped_value,
+                    elem.ord
+                  FROM jsonb_array_elements(t.${column}) WITH ORDINALITY AS elem(value, ord)
+                  LEFT JOIN choice_token_map m
+                    ON jsonb_typeof(elem.value) = 'string'
+                    AND elem.value #>> '{}' = m.token
+                ) expanded
+                GROUP BY mapped_value
+              ) d
+            ),
+            '[]'::jsonb
+          )
+          WHERE t.${column} IS NOT NULL
+            AND jsonb_typeof(t.${column}) = 'array'
+            AND EXISTS (SELECT 1 FROM choice_token_map)
+        `)
+      );
+    }
+
+    return sql.raw(
+      compressSql(`
+        WITH ${this.buildChoiceTokenMapSql()}
+        UPDATE ${tableName} AS t
+        SET ${column} = m.canonical_name
+        FROM choice_token_map m
+        WHERE t.${column} = m.token
+      `)
+    );
+  }
+}
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/index.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/index.ts
index 9a39b8e985..c275a2a349 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/index.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/field/index.ts
@@ -23,4 +23,5 @@ export { LinkSymmetricFieldRule } from './LinkSymmetricFieldRule';
 export { LinkValueColumnRule } from './LinkValueColumnRule';
 export { OrderColumnRule } from './OrderColumnRule';
 export { ReferenceRule, type ReferenceEntry } from './ReferenceRule';
+export { SelectOptionsMetaRule } from './SelectOptionsMetaRule';
 export { UniqueIndexRule } from './UniqueIndexRule';
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/rules/helpers/StatementBuilders.ts b/packages/v2/adapter-table-repository-postgres/src/schema/rules/helpers/StatementBuilders.ts
index 7dd6c0440d..129c22a8f7 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/rules/helpers/StatementBuilders.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/rules/helpers/StatementBuilders.ts
@@ -314,6 +314,7 @@ export const backfillForeignHostFkColumnFromLinkValueStatement = (params: {
 
 export const backfillJunctionTableFromLinkValueStatement = (params: {
   sourceTable: TableIdentifier;
+  sourceTableId?: string;
   sourceLinkValueColumnName: string;
   junctionTable: TableIdentifier;
   selfKeyName: string;
@@ -339,6 +340,9 @@ export const backfillJunctionTableFromLinkValueStatement = (params: {
   return sql.raw(
     compressSql(`
       DO $$
+      DECLARE
+        same_db_field_count integer := 0;
+        has_field_deleted_time boolean := false;
       BEGIN
         IF EXISTS (
           SELECT 1
@@ -347,6 +351,36 @@ export const backfillJunctionTableFromLinkValueStatement = (params: {
             AND table_name = ${quoteLiteral(sourceTableName)}
             AND column_name = ${quoteLiteral(params.sourceLinkValueColumnName)}
         ) THEN
+          IF ${params.sourceTableId ? 'TRUE' : 'FALSE'} AND EXISTS (
+            SELECT 1
+            FROM information_schema.columns
+            WHERE table_schema = 'public'
+              AND table_name = 'field'
+              AND column_name = 'db_field_name'
+          ) THEN
+            SELECT EXISTS (
+              SELECT 1
+              FROM information_schema.columns
+              WHERE table_schema = 'public'
+                AND table_name = 'field'
+                AND column_name = 'deleted_time'
+            ) INTO has_field_deleted_time;
+
+            IF has_field_deleted_time THEN
+              EXECUTE 'SELECT count(*) FROM field WHERE table_id = $1 AND db_field_name = $2 AND deleted_time IS NULL'
+              INTO same_db_field_count
+              USING ${quoteLiteral(params.sourceTableId ?? '')}, ${quoteLiteral(params.sourceLinkValueColumnName)};
+            ELSE
+              EXECUTE 'SELECT count(*) FROM field WHERE table_id = $1 AND db_field_name = $2'
+              INTO same_db_field_count
+              USING ${quoteLiteral(params.sourceTableId ?? '')}, ${quoteLiteral(params.sourceLinkValueColumnName)};
+            END IF;
+
+            IF same_db_field_count > 1 THEN
+              RETURN;
+            END IF;
+          END IF;
+
           WITH pairs AS (
             SELECT
               s."__id" AS self_id,
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 3e625568cc..8b2645a6f6 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
@@ -10,6 +10,12 @@ export interface SchemaRepairDetails {
   extra?: ReadonlyArray<string>;
   extraItems?: ReadonlyArray<SchemaRuleDetailItem>;
   statementCount?: number;
+  statements?: ReadonlyArray<SchemaRepairSqlStatement>;
+}
+
+export interface SchemaRepairSqlStatement {
+  sql: string;
+  parameters: ReadonlyArray<unknown>;
 }
 
 export interface SchemaRepairResult {
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 f725038ed4..42ad1aad1f 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,7 +1,7 @@
 import type { Table } from '@teable/v2-core';
 
 import { executeTableSchemaStatements } from '../../../shared/db';
-import type { SchemaRuleManualRepairValues } from '../core';
+import type { SchemaRuleManualRepairValues, TableSchemaStatementBuilder } from '../core';
 import { getRuleRepairHint } from '../core/RuleRepairMetadata';
 import {
   createSchemaRulePlanner,
@@ -10,6 +10,7 @@ import {
 } from '../planner/SchemaRulePlanner';
 import {
   type SchemaRepairResult,
+  type SchemaRepairSqlStatement,
   pendingResult,
   runningResult,
   successResult,
@@ -26,6 +27,19 @@ export interface SchemaRepairOptions {
   readonly targetStatuses?: ReadonlyArray<'warn' | 'error'>;
 }
 
+const compileRepairStatements = (
+  db: SchemaRepairerParams['db'],
+  statements: ReadonlyArray<TableSchemaStatementBuilder>
+): ReadonlyArray<SchemaRepairSqlStatement> =>
+  statements.map((statement) => {
+    const compiled = statement.compile(db);
+
+    return {
+      sql: compiled.sql,
+      parameters: compiled.parameters ?? [],
+    };
+  });
+
 export class SchemaRepairer {
   constructor(private readonly params: SchemaRepairerParams) {}
 
@@ -248,12 +262,17 @@ export class SchemaRepairer {
           }
 
           if (options?.dryRun) {
+            const compiledStatements = compileRepairStatements(ctx.db, statements);
             yield {
               ...successResult(
                 pending,
                 `Dry run: ${statements.length} statements ready`,
                 'repaired',
-                { ...details, statementCount: statements.length }
+                {
+                  ...details,
+                  statementCount: statements.length,
+                  statements: compiledStatements,
+                }
               ),
               repair,
             };
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/visitors/TableSchemaUpdateVisitor.ts b/packages/v2/adapter-table-repository-postgres/src/schema/visitors/TableSchemaUpdateVisitor.ts
index a030370946..32eb8b4978 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/visitors/TableSchemaUpdateVisitor.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/visitors/TableSchemaUpdateVisitor.ts
@@ -133,17 +133,11 @@ export class TableSchemaUpdateVisitor
     return `${prefix}_${tableName.slice(0, tableDbNameLen)}_${abbDbFieldName}_${fieldId}`;
   }
 
-  /** Field types whose cellValueType is Boolean or DateTime (unsupported by GIN trigram). */
-  private static readonly SEARCH_INDEX_UNSUPPORTED_TYPES = new Set([
-    'checkbox',
-    'date',
-    'createdTime',
-    'lastModifiedTime',
-    'button',
-  ]);
+  /** Field types that should never participate in search indexing. */
+  private static readonly SEARCH_INDEX_UNSUPPORTED_TYPES = new Set(['checkbox', 'button']);
 
   /**
-   * Whether a field type supports GIN trigram search indexes.
+   * Whether a field type supports search indexes.
    */
   private static fieldSupportsSearchIndex(fieldType: string): boolean {
     return !TableSchemaUpdateVisitor.SEARCH_INDEX_UNSUPPORTED_TYPES.has(fieldType);
@@ -165,7 +159,7 @@ export class TableSchemaUpdateVisitor
   }
 
   /**
-   * Build a conditional CREATE INDEX statement for a field's GIN trigram search index.
+   * Build a conditional CREATE INDEX statement for a field's search index.
    * Only creates the index if any idx_trgm indexes already exist on the table
    * (i.e., the table has search indexing enabled).
    */
@@ -179,11 +173,19 @@ export class TableSchemaUpdateVisitor
     }
 
     const valueTypeResult = field.accept(new FieldValueTypeVisitor());
+    let useBtree = false;
     if (valueTypeResult.isOk()) {
       const cellValueType = valueTypeResult.value.cellValueType.toString();
-      if (cellValueType === 'boolean' || cellValueType === 'dateTime') {
+      const isMultiple = valueTypeResult.value.isMultipleCellValue.isMultiple();
+      if (cellValueType === 'boolean') {
         return null;
       }
+      if (cellValueType === 'dateTime') {
+        if (isMultiple) {
+          return null;
+        }
+        useBtree = true;
+      }
     }
 
     const { db, schema, tableName } = this.params;
@@ -196,8 +198,9 @@ export class TableSchemaUpdateVisitor
     const isMultipleResult = field.isMultipleCellValue();
     const isMultiple = isMultipleResult.isOk() && isMultipleResult.value.toBoolean();
     let expression = `"${dbFieldName}"::text`;
-
-    if (!isMultiple && fieldType === 'longText') {
+    if (useBtree) {
+      expression = `"${dbFieldName}"`;
+    } else if (!isMultiple && fieldType === 'longText') {
       expression = `REPLACE(REPLACE(REPLACE("${dbFieldName}"::text, CHR(13), ' '::text), CHR(10), ' '::text), CHR(9), ' '::text)`;
     }
 
@@ -211,7 +214,7 @@ export class TableSchemaUpdateVisitor
             AND tablename = '${tableName}'
             AND indexname LIKE 'idx_trgm%'
         ) THEN
-          EXECUTE 'CREATE INDEX IF NOT EXISTS "${indexName}" ON "${pgSchema}"."${tableName}" USING gin ((${expression.replace(/'/g, "''")}) gin_trgm_ops)';
+          EXECUTE 'CREATE INDEX IF NOT EXISTS "${indexName}" ON "${pgSchema}"."${tableName}" ${useBtree ? `USING btree (${expression.replace(/'/g, "''")})` : `USING gin ((${expression.replace(/'/g, "''")}) gin_trgm_ops)`}';
         END IF;
       END
       $$;
diff --git a/packages/v2/adapter-table-repository-postgres/src/schema/visitors/__tests__/TableSchemaUpdateVisitor.spec.ts b/packages/v2/adapter-table-repository-postgres/src/schema/visitors/__tests__/TableSchemaUpdateVisitor.spec.ts
index bda1dfbaa1..f089e1c292 100644
--- a/packages/v2/adapter-table-repository-postgres/src/schema/visitors/__tests__/TableSchemaUpdateVisitor.spec.ts
+++ b/packages/v2/adapter-table-repository-postgres/src/schema/visitors/__tests__/TableSchemaUpdateVisitor.spec.ts
@@ -24,6 +24,7 @@ import { describe, expect, it } from 'vitest';
 
 import { TableSchemaUpdateVisitor } from '../TableSchemaUpdateVisitor';
 import { createTestDb } from './helpers/createTestDb';
+import { createDtField } from './helpers/fieldFactories';
 
 describe('TableSchemaUpdateVisitor', () => {
   describe('visitTableUpdateFieldConstraints', () => {
@@ -982,7 +983,15 @@ describe('TableSchemaUpdateVisitor', () => {
         table: createTable(),
       });
 
-    const createField = (params: { id: string; kind: 'singleLineText' | 'checkbox' }) => {
+    const createField = (params: { id: string; kind: 'singleLineText' | 'checkbox' | 'date' }) => {
+      if (params.kind === 'date') {
+        return createDtField(
+          params.id,
+          `Field ${params.id.slice(-4)}`,
+          `fld_${params.id.slice(-8)}`
+        )._unsafeUnwrap();
+      }
+
       const table = Table.builder()
         .withBaseId(BaseId.create(SCHEMA)._unsafeUnwrap())
         .withName(TableName.create('Field Source')._unsafeUnwrap());
@@ -1019,6 +1028,21 @@ describe('TableSchemaUpdateVisitor', () => {
       expect(sqls.some((text) => text.includes('CREATE INDEX IF NOT EXISTS'))).toBe(true);
     });
 
+    it('should append a btree search index statement for date fields', () => {
+      const field = createField({ id: 'fldDateField000001', kind: 'date' });
+      const spec = TableAddFieldSpec.create(field);
+      const visitor = createVisitor();
+
+      const result = visitor.visitTableAddField(spec);
+      expect(result.isOk()).toBe(true);
+
+      const sqls = result._unsafeUnwrap().map((statement) => statement.compile(db).sql);
+      expect(sqls.some((text) => text.includes("indexname LIKE 'idx_trgm%'"))).toBe(true);
+      expect(sqls.some((text) => text.includes('CREATE INDEX IF NOT EXISTS'))).toBe(true);
+      expect(sqls.some((text) => text.includes('USING btree'))).toBe(true);
+      expect(sqls.some((text) => text.includes('gin_trgm_ops'))).toBe(false);
+    });
+
     it('should not append search index statement for unsupported field types', () => {
       const field = createField({ id: 'fldCheckboxField001', kind: 'checkbox' });
       const spec = TableAddFieldSpec.create(field);
diff --git a/packages/v2/core/src/commands/UpdateRecordHandler.spec.ts b/packages/v2/core/src/commands/UpdateRecordHandler.spec.ts
index 11f44f6c89..5d2080aecf 100644
--- a/packages/v2/core/src/commands/UpdateRecordHandler.spec.ts
+++ b/packages/v2/core/src/commands/UpdateRecordHandler.spec.ts
@@ -229,6 +229,7 @@ class FakeTableRecordRepository implements ITableRecordRepository {
   lastRecordId: RecordId | undefined;
   lastMutateSpec: ICellValueSpec | undefined;
   omitUpdateSnapshot = false;
+  mutationApplied: boolean | undefined = true;
 
   async insert(
     _: IExecutionContext,
@@ -265,8 +266,11 @@ class FakeTableRecordRepository implements ITableRecordRepository {
     this.lastMutateSpec = mutateSpec;
     return ok(
       this.omitUpdateSnapshot
-        ? {}
+        ? {
+            mutationApplied: this.mutationApplied,
+          }
         : {
+            mutationApplied: this.mutationApplied,
             updateSnapshot: {
               previous: {
                 recordId: recordId.toString(),
@@ -876,6 +880,57 @@ describe('UpdateRecordHandler', () => {
     expect(result._unsafeUnwrapErr().code).toBe('record.update_snapshot.unavailable');
   });
 
+  it('does not require an update snapshot when a stale no-op update was not persisted', async () => {
+    const { table, tableId, textFieldId } = buildTable();
+    const recordResult = table
+      .createRecord(new Map([[textFieldId.toString(), 'Old Title']]))
+      ._unsafeUnwrap();
+
+    const tableRepository = new FakeTableRepository();
+    tableRepository.tables.push(table);
+    const tableQueryService = new TableQueryService(tableRepository);
+
+    const recordRepository = new FakeTableRecordRepository();
+    recordRepository.omitUpdateSnapshot = true;
+    recordRepository.mutationApplied = false;
+    const recordQueryRepository = new FakeTableRecordQueryRepository();
+    recordQueryRepository.record = {
+      id: recordResult.record.id().toString(),
+      fields: { [textFieldId.toString()]: 'Old Title' },
+      version: 1,
+    };
+
+    const eventBus = new FakeEventBus();
+    const undoRedoService = new FakeUndoRedoService();
+    const handler = new UpdateRecordHandler(
+      tableQueryService,
+      recordRepository,
+      recordQueryRepository,
+      new FakeRecordOrderCalculator(),
+      new FakeRecordMutationSpecResolverService() as unknown as RecordMutationSpecResolverService,
+      noopRecordChangedValueDecoratorService,
+      createRecordWritePluginRunner(),
+      new RecordWriteSideEffectService(),
+      noopRecordWriteUndoRedoPlanService,
+      createTableUpdateFlow(tableRepository, eventBus, new FakeUnitOfWork()),
+      eventBus,
+      undoRedoService as unknown as UndoRedoStackService,
+      new FakeUnitOfWork()
+    );
+
+    const command = UpdateRecordCommand.create({
+      tableId: tableId.toString(),
+      recordId: recordResult.record.id().toString(),
+      fields: { [textFieldId.toString()]: 'New Title' },
+    })._unsafeUnwrap();
+
+    const result = await handler.handle(createContext(), command);
+
+    expect(result.isOk()).toBe(true);
+    expect(eventBus.published.some(isRecordUpdatedEvent)).toBe(false);
+    expect(undoRedoService.calls).toHaveLength(0);
+  });
+
   it('event changes contain resolved values after typecast user field resolution', async () => {
     const { table, tableId, textFieldId, userFieldId } = buildTable();
     const recordResult = table
diff --git a/packages/v2/core/src/commands/UpdateRecordHandler.ts b/packages/v2/core/src/commands/UpdateRecordHandler.ts
index b767cb0865..1957c7fa8e 100644
--- a/packages/v2/core/src/commands/UpdateRecordHandler.ts
+++ b/packages/v2/core/src/commands/UpdateRecordHandler.ts
@@ -316,14 +316,17 @@ export class UpdateRecordHandler
 
       // 2. Build changes array with old/new values (need to resolve field keys to IDs for event)
       const changes: RecordFieldChangeDTO[] = [];
+      const mutationApplied = mutationResult.mutation.mutationApplied !== false;
       const changedFieldValues = new Map<string, unknown>(
         mutationResult.mutation.changedFields ?? []
       );
-      for (const entry of updatedRecord.fields().entries()) {
-        const fieldId = entry.fieldId.toString();
-        const newValue = entry.value.toValue();
-        if (!areFieldValuesEqual(currentRecord.fields[fieldId], newValue)) {
-          changedFieldValues.set(fieldId, newValue);
+      if (mutationApplied) {
+        for (const entry of updatedRecord.fields().entries()) {
+          const fieldId = entry.fieldId.toString();
+          const newValue = entry.value.toValue();
+          if (!areFieldValuesEqual(currentRecord.fields[fieldId], newValue)) {
+            changedFieldValues.set(fieldId, newValue);
+          }
         }
       }
       const updatedFieldValues =
diff --git a/packages/v2/core/src/domain/table/fields/types/FieldValueObjects.spec.ts b/packages/v2/core/src/domain/table/fields/types/FieldValueObjects.spec.ts
index a1b69d9c7c..3ea82d2c90 100644
--- a/packages/v2/core/src/domain/table/fields/types/FieldValueObjects.spec.ts
+++ b/packages/v2/core/src/domain/table/fields/types/FieldValueObjects.spec.ts
@@ -24,7 +24,7 @@ import { SelectOptionId } from './SelectOptionId';
 import { SelectOptionName } from './SelectOptionName';
 import { validateSelectOptions } from './SelectOptions';
 import { TextDefaultValue } from './TextDefaultValue';
-import { TimeZone } from './TimeZone';
+import { TIME_ZONE_LIST, TimeZone, timeZoneValueSchema } from './TimeZone';
 import { UserDefaultValue } from './UserDefaultValue';
 import { UserId } from './UserId';
 import { UserMultiplicity } from './UserMultiplicity';
@@ -349,6 +349,36 @@ describe('TimeZone', () => {
     expect(TimeZone.create('Etc/UTC')._unsafeUnwrap().toString()).toBe('Etc/UTC');
   });
 
+  it('accepts known IANA aliases supported by Intl', () => {
+    const aliases = [
+      'Africa/Asmera',
+      'America/Buenos_Aires',
+      'America/Catamarca',
+      'America/Ciudad_Juarez',
+      'America/Coral_Harbour',
+      'America/Cordoba',
+      'America/Coyhaique',
+      'America/Indianapolis',
+      'America/Jujuy',
+      'America/Louisville',
+      'America/Mendoza',
+      'Asia/Calcutta',
+      'Asia/Katmandu',
+      'Asia/Rangoon',
+      'Asia/Saigon',
+      'Atlantic/Faeroe',
+      'Europe/Kiev',
+      'Pacific/Ponape',
+      'Pacific/Truk',
+    ];
+
+    for (const alias of aliases) {
+      expect(TIME_ZONE_LIST).toContain(alias);
+      expect(TimeZone.create(alias)._unsafeUnwrap().toString()).toBe(alias);
+      expect(timeZoneValueSchema.parse(alias)).toBe(alias);
+    }
+  });
+
   it('provides detailed error message for invalid timezone', () => {
     const result = TimeZone.create('Invalid/Zone');
     expect(result.isErr()).toBe(true);
diff --git a/packages/v2/core/src/domain/table/fields/types/TimeZone.ts b/packages/v2/core/src/domain/table/fields/types/TimeZone.ts
index 1c31bcba64..2af6e0b73a 100644
--- a/packages/v2/core/src/domain/table/fields/types/TimeZone.ts
+++ b/packages/v2/core/src/domain/table/fields/types/TimeZone.ts
@@ -12,6 +12,7 @@ export const TIME_ZONE_LIST = [
   'Africa/Addis_Ababa',
   'Africa/Algiers',
   'Africa/Asmara',
+  'Africa/Asmera',
   'Africa/Bamako',
   'Africa/Bangui',
   'Africa/Banjul',
@@ -88,15 +89,21 @@ export const TIME_ZONE_LIST = [
   'America/Boa_Vista',
   'America/Bogota',
   'America/Boise',
+  'America/Buenos_Aires',
   'America/Cambridge_Bay',
   'America/Campo_Grande',
   'America/Cancun',
   'America/Caracas',
+  'America/Catamarca',
   'America/Cayenne',
   'America/Cayman',
   'America/Chicago',
   'America/Chihuahua',
+  'America/Ciudad_Juarez',
+  'America/Coral_Harbour',
+  'America/Cordoba',
   'America/Costa_Rica',
+  'America/Coyhaique',
   'America/Creston',
   'America/Cuiaba',
   'America/Curacao',
@@ -131,9 +138,11 @@ export const TIME_ZONE_LIST = [
   'America/Indiana/Vevay',
   'America/Indiana/Vincennes',
   'America/Indiana/Winamac',
+  'America/Indianapolis',
   'America/Inuvik',
   'America/Iqaluit',
   'America/Jamaica',
+  'America/Jujuy',
   'America/Juneau',
   'America/Kentucky/Louisville',
   'America/Kentucky/Monticello',
@@ -141,6 +150,7 @@ export const TIME_ZONE_LIST = [
   'America/La_Paz',
   'America/Lima',
   'America/Los_Angeles',
+  'America/Louisville',
   'America/Lower_Princes',
   'America/Maceio',
   'America/Managua',
@@ -149,6 +159,7 @@ export const TIME_ZONE_LIST = [
   'America/Martinique',
   'America/Matamoros',
   'America/Mazatlan',
+  'America/Mendoza',
   'America/Menominee',
   'America/Merida',
   'America/Metlakatla',
@@ -235,6 +246,7 @@ export const TIME_ZONE_LIST = [
   'Asia/Beirut',
   'Asia/Bishkek',
   'Asia/Brunei',
+  'Asia/Calcutta',
   'Asia/Chita',
   'Asia/Choibalsan',
   'Asia/Colombo',
@@ -257,6 +269,7 @@ export const TIME_ZONE_LIST = [
   'Asia/Kamchatka',
   'Asia/Karachi',
   'Asia/Kathmandu',
+  'Asia/Katmandu',
   'Asia/Khandyga',
   'Asia/Kolkata',
   'Asia/Krasnoyarsk',
@@ -279,7 +292,9 @@ export const TIME_ZONE_LIST = [
   'Asia/Qatar',
   'Asia/Qostanay',
   'Asia/Qyzylorda',
+  'Asia/Rangoon',
   'Asia/Riyadh',
+  'Asia/Saigon',
   'Asia/Sakhalin',
   'Asia/Samarkand',
   'Asia/Seoul',
@@ -306,6 +321,7 @@ export const TIME_ZONE_LIST = [
   'Atlantic/Bermuda',
   'Atlantic/Canary',
   'Atlantic/Cape_Verde',
+  'Atlantic/Faeroe',
   'Atlantic/Faroe',
   'Atlantic/Madeira',
   'Atlantic/Reykjavik',
@@ -343,6 +359,7 @@ export const TIME_ZONE_LIST = [
   'Europe/Isle_of_Man',
   'Europe/Istanbul',
   'Europe/Jersey',
+  'Europe/Kiev',
   'Europe/Kaliningrad',
   'Europe/Kirov',
   'Europe/Lisbon',
@@ -424,12 +441,14 @@ export const TIME_ZONE_LIST = [
   'Pacific/Palau',
   'Pacific/Pitcairn',
   'Pacific/Pohnpei',
+  'Pacific/Ponape',
   'Pacific/Port_Moresby',
   'Pacific/Rarotonga',
   'Pacific/Saipan',
   'Pacific/Tahiti',
   'Pacific/Tarawa',
   'Pacific/Tongatapu',
+  'Pacific/Truk',
   'Pacific/Wake',
   'Pacific/Wallis',
   'Etc/GMT',
@@ -464,8 +483,9 @@ export const TIME_ZONE_LIST = [
   'Etc/UTC',
 ] as const;
 
-const timeZoneSchema = z.enum(TIME_ZONE_LIST);
-export type TimeZoneValue = z.infer<typeof timeZoneSchema>;
+export const timeZoneValueSchema = z.enum(TIME_ZONE_LIST);
+
+export type TimeZoneValue = z.infer<typeof timeZoneValueSchema>;
 
 export class TimeZone extends ValueObject {
   private constructor(private readonly value: TimeZoneValue) {
@@ -475,7 +495,7 @@ export class TimeZone extends ValueObject {
   static create(raw: unknown): Result<TimeZone, DomainError> {
     // Handle case-insensitive 'UTC' for backwards compatibility
     const normalized = typeof raw === 'string' && raw.toUpperCase() === 'UTC' ? 'utc' : raw;
-    const parsed = timeZoneSchema.safeParse(normalized);
+    const parsed = timeZoneValueSchema.safeParse(normalized);
     if (!parsed.success)
       return err(
         domainError.validation({
diff --git a/packages/v2/core/src/domain/table/specs/visitors/TableEventGeneratingSpecVisitor.ts b/packages/v2/core/src/domain/table/specs/visitors/TableEventGeneratingSpecVisitor.ts
index d26b727a36..faf684f682 100644
--- a/packages/v2/core/src/domain/table/specs/visitors/TableEventGeneratingSpecVisitor.ts
+++ b/packages/v2/core/src/domain/table/specs/visitors/TableEventGeneratingSpecVisitor.ts
@@ -171,6 +171,11 @@ export class TableEventGeneratingSpecVisitor implements ITableSpecVisitor<void>
   }
 
   visitTableDuplicateField(spec: TableDuplicateFieldSpec): Result<void, DomainError> {
+    const viewOrdersResult = this.collectViewOrders(spec.newField().id());
+    if (viewOrdersResult.isErr()) {
+      return err(viewOrdersResult.error);
+    }
+
     this.events.push(
       FieldDuplicated.create({
         tableId: this.table.id(),
@@ -178,6 +183,12 @@ export class TableEventGeneratingSpecVisitor implements ITableSpecVisitor<void>
         sourceFieldId: spec.sourceField().id(),
         newFieldId: spec.newField().id(),
         includeRecordValues: spec.includeRecordValues(),
+      }),
+      FieldCreated.create({
+        tableId: this.table.id(),
+        baseId: this.table.baseId(),
+        fieldId: spec.newField().id(),
+        viewOrders: viewOrdersResult.value,
       })
     );
     return ok(undefined);
diff --git a/packages/v2/core/src/domain/table/specs/visitors/__tests__/TableEventGeneratingSpecVisitor.spec.ts b/packages/v2/core/src/domain/table/specs/visitors/__tests__/TableEventGeneratingSpecVisitor.spec.ts
index 1e5853d666..8abd4d0ab4 100644
--- a/packages/v2/core/src/domain/table/specs/visitors/__tests__/TableEventGeneratingSpecVisitor.spec.ts
+++ b/packages/v2/core/src/domain/table/specs/visitors/__tests__/TableEventGeneratingSpecVisitor.spec.ts
@@ -115,7 +115,7 @@ describe('TableEventGeneratingSpecVisitor', () => {
     expect((events[0] as FieldOptionsAdded).options).toEqual([option.toDto()]);
   });
 
-  it('generates FieldDuplicated event for TableDuplicateFieldSpec', () => {
+  it('generates FieldDuplicated and FieldCreated events for TableDuplicateFieldSpec', () => {
     const table = buildTable();
     const visitor = new TableEventGeneratingSpecVisitor(table);
     const sourceField = table.getFields()[0];
@@ -127,10 +127,12 @@ describe('TableEventGeneratingSpecVisitor', () => {
     TableDuplicateFieldSpec.create(sourceField, newField, true).accept(visitor)._unsafeUnwrap();
 
     const events = visitor.getEvents();
-    expect(events).toHaveLength(1);
+    expect(events).toHaveLength(2);
     expect(events[0]).toBeInstanceOf(FieldDuplicated);
     expect((events[0] as FieldDuplicated).sourceFieldId).toEqual(sourceField.id());
     expect((events[0] as FieldDuplicated).newFieldId).toEqual(newField.id());
+    expect(events[1]).toBeInstanceOf(FieldCreated);
+    expect((events[1] as FieldCreated).fieldId).toEqual(newField.id());
   });
 
   it('generates FieldDeleted event for TableRemoveFieldSpec', () => {
diff --git a/packages/v2/core/src/ports/TableRecordRepository.ts b/packages/v2/core/src/ports/TableRecordRepository.ts
index a90136e553..0f05223554 100644
--- a/packages/v2/core/src/ports/TableRecordRepository.ts
+++ b/packages/v2/core/src/ports/TableRecordRepository.ts
@@ -41,6 +41,14 @@ export interface RecordUpdateSnapshot {
  * Contains computed field values that were updated as part of the operation.
  */
 export interface RecordMutationResult {
+  /**
+   * Whether the repository actually persisted a storage mutation.
+   *
+   * `false` is distinct from a missing snapshot: it means the requested mutation
+   * was skipped because storage already matched the desired state.
+   */
+  mutationApplied?: boolean;
+
   /**
    * Final stored values for fields changed by this operation.
    * Map of fieldId -> persisted newValue.
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 9f8891eb89..698e472604 100644
--- a/packages/v2/core/src/ports/mappers/defaults/DefaultTableMapper.spec.ts
+++ b/packages/v2/core/src/ports/mappers/defaults/DefaultTableMapper.spec.ts
@@ -373,6 +373,62 @@ describe('DefaultTableMapper', () => {
     fieldDbNameResult?._unsafeUnwrap();
   });
 
+  it('deduplicates select choices by name when rehydrating persistence dto', () => {
+    const mapper = new DefaultTableMapper();
+    const dto = mapper.toDTO(buildTable())._unsafeUnwrap();
+
+    const withDuplicateSelectChoices = {
+      ...dto,
+      fields: dto.fields.map((field) => {
+        if (field.type === 'singleSelect') {
+          return {
+            ...field,
+            options: {
+              ...field.options,
+              choices: [
+                ...field.options.choices,
+                { id: `cho${'c'.repeat(16)}`, name: 'Todo', color: 'red' },
+                { id: `cho${'e'.repeat(16)}`, name: ' Todo ', color: 'blue' },
+              ],
+            },
+          };
+        }
+
+        if (field.type === 'multipleSelect') {
+          return {
+            ...field,
+            options: {
+              ...field.options,
+              choices: [
+                ...field.options.choices,
+                { id: `cho${'d'.repeat(16)}`, name: 'Done', color: 'yellow' },
+              ],
+            },
+          };
+        }
+
+        return field;
+      }),
+    };
+
+    const mapped = mapper.toDomain(withDuplicateSelectChoices)._unsafeUnwrap();
+    const statusField = mapped.getFields().find((field) => field.name().toString() === 'Status') as
+      | SingleSelectField
+      | undefined;
+    const tagsField = mapped.getFields().find((field) => field.name().toString() === 'Tags') as
+      | MultipleSelectField
+      | undefined;
+
+    expect(statusField?.selectOptions().map((option) => option.name().toString())).toEqual([
+      'Todo',
+      'Done',
+    ]);
+    expect(tagsField?.selectOptions().map((option) => option.name().toString())).toEqual([
+      'Todo',
+      'Done',
+    ]);
+  });
+
   it('preserves dbTableName when mapping builder-backed tables to dto', () => {
     const baseId = BaseId.create(`bse${'z'.repeat(16)}`)._unsafeUnwrap();
     const tableId = TableId.create(`tbl${'z'.repeat(16)}`)._unsafeUnwrap();
diff --git a/packages/v2/core/src/ports/mappers/defaults/DefaultTableMapper.ts b/packages/v2/core/src/ports/mappers/defaults/DefaultTableMapper.ts
index 6e63317533..d731dacbcd 100644
--- a/packages/v2/core/src/ports/mappers/defaults/DefaultTableMapper.ts
+++ b/packages/v2/core/src/ports/mappers/defaults/DefaultTableMapper.ts
@@ -114,6 +114,7 @@ import type {
   IRatingFieldOptionsDTO,
   IRollupFieldConfigDTO,
   IRollupFieldOptionsDTO,
+  ISelectFieldChoiceDTO,
   ISelectFieldOptionsDTO,
   ISingleLineTextFieldOptionsDTO,
   IUserFieldOptionsDTO,
@@ -139,6 +140,20 @@ const optional = <T>(
   return parser(raw).map((value) => value);
 };
 
+const deduplicateSelectChoiceDtos = (
+  choices: ReadonlyArray<ISelectFieldChoiceDTO>
+): ReadonlyArray<ISelectFieldChoiceDTO> => {
+  const seen = new Set<string>();
+  const deduped: ISelectFieldChoiceDTO[] = [];
+  for (const choice of choices) {
+    const name = choice.name.trim();
+    if (seen.has(name)) continue;
+    seen.add(name);
+    deduped.push(choice);
+  }
+  return deduped;
+};
+
 const parseFormulaFormatting = (
   raw: unknown
 ): Result<NumberFormatting | DateTimeFormatting | undefined, DomainError> => {
@@ -695,12 +710,23 @@ class FieldToPersistenceVisitor implements IFieldVisitor<ITableFieldPersistenceD
           innerOptions: unwrappedInner.innerOptions,
           innerOptionsPatch: field.innerOptionsPatch(),
         });
+        const {
+          innerType: _innerType,
+          innerOptions: _innerOptions,
+          ...innerShape
+        } = innerDto as
+          | (ITableFieldPersistenceDTO & {
+              innerType?: ITableFieldPersistenceDTO['type'];
+              innerOptions?: unknown;
+            })
+          | Record<string, unknown>;
 
         return {
-          ...innerDto,
+          ...innerShape,
           ...baseDto,
           id: field.id().toString(),
           name: field.name().toString(),
+          type: unwrappedInner.innerType ?? innerDto.type,
           isLookup: true,
           isConditionalLookup,
           lookupOptions: lookupOptionsWithRelationship,
@@ -1148,7 +1174,7 @@ export class DefaultTableMapper implements ITableMapper {
             })
             .with({ type: 'singleSelect' }, (dto) => {
               const optionsDto = dto.options ?? { choices: [] };
-              const choices = optionsDto.choices ?? [];
+              const choices = deduplicateSelectChoiceDtos(optionsDto.choices ?? []);
               return sequenceResults(choices.map((choice) => SelectOption.create(choice))).andThen(
                 (options) =>
                   optional(optionsDto.defaultValue, SelectDefaultValue.create).andThen(
@@ -1170,7 +1196,7 @@ export class DefaultTableMapper implements ITableMapper {
             })
             .with({ type: 'multipleSelect' }, (dto) => {
               const optionsDto = dto.options ?? { choices: [] };
-              const choices = optionsDto.choices ?? [];
+              const choices = deduplicateSelectChoiceDtos(optionsDto.choices ?? []);
               return sequenceResults(choices.map((choice) => SelectOption.create(choice))).andThen(
                 (options) =>
                   optional(optionsDto.defaultValue, SelectDefaultValue.create).andThen(
diff --git a/packages/v2/core/src/queries/ListTableRecordsHandler.spec.ts b/packages/v2/core/src/queries/ListTableRecordsHandler.spec.ts
index 6fa58ed106..415b413ec1 100644
--- a/packages/v2/core/src/queries/ListTableRecordsHandler.spec.ts
+++ b/packages/v2/core/src/queries/ListTableRecordsHandler.spec.ts
@@ -12,6 +12,7 @@ import { LinkFieldConfig } from '../domain/table/fields/types/LinkFieldConfig';
 import { SelectOption } from '../domain/table/fields/types/SelectOption';
 import { RecordId } from '../domain/table/records/RecordId';
 import { NoopRecordConditionSpecVisitor } from '../domain/table/records/specs/visitors/NoopRecordConditionSpecVisitor';
+import type { UserConditionSpec } from '../domain/table/records/specs/UserConditionSpec';
 import { TableUpdateViewColumnMetaSpec } from '../domain/table/specs/TableUpdateViewColumnMetaSpec';
 import { TableUpdateViewQueryDefaultsSpec } from '../domain/table/specs/TableUpdateViewQueryDefaultsSpec';
 import { Table } from '../domain/table/Table';
@@ -53,6 +54,16 @@ const buildTable = () => {
   return builder.build()._unsafeUnwrap();
 };
 
+const buildUserFilterTable = () => {
+  const builder = Table.builder()
+    .withBaseId(createBaseId('u'))
+    .withName(TableName.create('User Filter Records')._unsafeUnwrap());
+  builder.field().singleLineText().withName(FieldName.create('Title')._unsafeUnwrap()).done();
+  builder.field().user().withName(FieldName.create('Assignee')._unsafeUnwrap()).done();
+  builder.view().defaultGrid().done();
+  return builder.build()._unsafeUnwrap();
+};
+
 const buildHostTableReferencing = (
   foreignTable: Table,
   relationship: 'manyMany' | 'oneMany' = 'oneMany',
@@ -90,6 +101,7 @@ class RecordingSpecVisitor extends NoopRecordConditionSpecVisitor {
   readonly visited: string[] = [];
   readonly incomingLinkSelectedModes: string[] = [];
   readonly incomingLinkCandidateModes: string[] = [];
+  readonly userValues: unknown[] = [];
 
   override visitIncomingLinkSelected(
     ...args: Parameters<NoopRecordConditionSpecVisitor['visitIncomingLinkSelected']>
@@ -113,6 +125,13 @@ class RecordingSpecVisitor extends NoopRecordConditionSpecVisitor {
     this.visited.push(`recordByIds:${args[0].recordIds().length}`);
     return super.visitRecordByIds(...args);
   }
+
+  override visitUserIs(spec: UserConditionSpec) {
+    this.visited.push('userIs');
+    const value = spec.value();
+    this.userValues.push(value && 'toValue' in value ? value.toValue() : value);
+    return super.visitUserIs(spec);
+  }
 }
 
 describe('ListTableRecordsHandler', () => {
@@ -179,6 +198,63 @@ describe('ListTableRecordsHandler', () => {
     expect(captured.spec).toBeDefined();
   });
 
+  it('replaces Me in view filters with the current actor id', async () => {
+    const table = buildUserFilterTable();
+    const assigneeField = table
+      .getField((field) => field.name().toString() === 'Assignee')
+      ._unsafeUnwrap();
+    const view = table.views()[0]!;
+    const tableWithViewFilter = TableUpdateViewQueryDefaultsSpec.create([
+      {
+        viewId: view.id(),
+        queryDefaults: ViewQueryDefaults.create({
+          filter: {
+            conjunction: 'and',
+            items: [
+              {
+                fieldId: assigneeField.id().toString(),
+                operator: 'is',
+                value: 'Me',
+              },
+            ],
+          },
+        })._unsafeUnwrap(),
+      },
+    ])
+      .mutate(table)
+      ._unsafeUnwrap();
+    const tableRepository = new MemoryTableRepository();
+    const context = createContext();
+    await tableRepository.insert(context, tableWithViewFilter);
+
+    const captured: { spec?: unknown } = {};
+    const recordQueryRepo: ITableRecordQueryRepository = {
+      find: async (_context, _table, spec) => {
+        captured.spec = spec;
+        return ok({ records: [], total: 0 });
+      },
+      findOne: async () => err(domainError.notFound({ message: 'Not found' })),
+      async *findStream() {},
+    };
+
+    const queryResult = ListTableRecordsQuery.create({
+      tableId: table.id().toString(),
+      viewId: view.id().toString(),
+    });
+    const handler = new ListTableRecordsHandler(tableRepository, recordQueryRepo, new NoopLogger());
+    const result = await handler.handle(context, queryResult._unsafeUnwrap());
+
+    expect(result.isOk()).toBe(true);
+    const visitor = new RecordingSpecVisitor();
+    const acceptResult = (
+      captured.spec as {
+        accept: (visitor: RecordingSpecVisitor) => ReturnType<RecordingSpecVisitor['visit']>;
+      }
+    ).accept(visitor);
+    expect(acceptResult.isOk()).toBe(true);
+    expect(visitor.userValues).toEqual([context.actorId.toString()]);
+  });
+
   it('drops filters for disabled fields from the permission read source', async () => {
     const table = buildTable();
     const tableRepository = new MemoryTableRepository();
diff --git a/packages/v2/core/src/queries/ListTableRecordsHandler.ts b/packages/v2/core/src/queries/ListTableRecordsHandler.ts
index 8102eda10f..9472419b72 100644
--- a/packages/v2/core/src/queries/ListTableRecordsHandler.ts
+++ b/packages/v2/core/src/queries/ListTableRecordsHandler.ts
@@ -6,6 +6,7 @@ import { FieldKeyResolverService } from '../application/services/FieldKeyResolve
 import { mergeOrderBy, resolveOrderBy as resolveQueryOrderBy } from '../commands/shared/orderBy';
 import { domainError, isNotFoundError, type DomainError } from '../domain/shared/DomainError';
 import { type ISpecification } from '../domain/shared/specification/ISpecification';
+import { FieldType } from '../domain/table/fields/FieldType';
 import { FieldId } from '../domain/table/fields/FieldId';
 import { FieldKeyType } from '../domain/table/fields/FieldKeyType';
 import { FieldCondition } from '../domain/table/fields/types/FieldCondition';
@@ -36,10 +37,13 @@ import {
   type RecordFilter,
   type RecordFilterCondition,
   type RecordFilterNode,
+  type RecordFilterValue,
 } from './RecordFilterDto';
 import { buildRecordConditionSpec, sanitizeRecordFilter } from './RecordFilterMapper';
 import { RecordSearch, resolveVisibleRowSearch } from './RecordSearch';
 
+const currentUserFilterValue = 'Me';
+
 export class ListTableRecordsResult {
   private constructor(
     readonly records: ReadonlyArray<TableRecordReadModel>,
@@ -154,6 +158,60 @@ function resolveFilterNodeFieldKeys(
   return ok(node);
 }
 
+function isUserLikeFieldType(type: FieldType): boolean {
+  return (
+    type.equals(FieldType.user()) ||
+    type.equals(FieldType.createdBy()) ||
+    type.equals(FieldType.lastModifiedBy())
+  );
+}
+
+function replaceCurrentUserTagInFilter(
+  table: Table,
+  filter: RecordFilter | null | undefined,
+  actorId: string
+): RecordFilter | null | undefined {
+  if (!filter) {
+    return filter;
+  }
+
+  const replaceNode = (node: RecordFilterNode): RecordFilterNode => {
+    if (isRecordFilterNot(node)) {
+      return { not: replaceNode(node.not) };
+    }
+
+    if (isRecordFilterGroup(node)) {
+      return {
+        ...node,
+        items: node.items.map((item) => replaceNode(item)),
+      };
+    }
+
+    if (!isRecordFilterCondition(node)) {
+      return node;
+    }
+
+    const fieldResult = table.getField((field) => field.id().toString() === node.fieldId);
+    if (fieldResult.isErr() || !isUserLikeFieldType(fieldResult.value.type())) {
+      return node;
+    }
+
+    const replaceValue = (value: RecordFilterValue): RecordFilterValue => {
+      if (Array.isArray(value)) {
+        return value.map((item) => (item === currentUserFilterValue ? actorId : item));
+      }
+      return value === currentUserFilterValue ? actorId : value;
+    };
+
+    return {
+      ...node,
+      value: replaceValue(node.value),
+    };
+  };
+
+  return replaceNode(filter);
+}
+
 type IRecordReadQuerySource = {
   enabledFieldIds?: ReadonlyArray<string>;
 };
@@ -356,6 +414,11 @@ export class ListTableRecordsHandler
           const resolvedFilter = query.filter
             ? yield* resolveFilterFieldKeys(table, query.filter, query.fieldKeyType)
             : undefined;
+          const actorResolvedFilter = replaceCurrentUserTagInFilter(
+            table,
+            resolvedFilter,
+            context.actorId.toString()
+          );
 
           // Pre-resolve link candidate plan so filterByViewId can inform effectiveView.
           const linkCandidatePlan = query.filterLinkCellCandidate
@@ -387,12 +450,14 @@ export class ListTableRecordsHandler
           const effectiveQueryDefaults = effectiveView
             ? yield* effectiveView.queryDefaults()
             : undefined;
-          const sanitizedDefaultFilter = yield* sanitizeRecordFilter(
+          const defaultFilter = replaceCurrentUserTagInFilter(
             table,
-            effectiveQueryDefaults?.filter()
+            effectiveQueryDefaults?.filter(),
+            context.actorId.toString()
           );
+          const sanitizedDefaultFilter = yield* sanitizeRecordFilter(table, defaultFilter);
           const effectiveFilter = sanitizeFilterByEnabledFieldIds(
-            mergeFilterWithViewDefaults(sanitizedDefaultFilter, resolvedFilter),
+            mergeFilterWithViewDefaults(sanitizedDefaultFilter, actorResolvedFilter),
             enabledFieldIds
           );
           const effectiveSort = mergeSortWithViewDefaults(
diff --git a/packages/v2/core/src/schemas/field/common.schema.ts b/packages/v2/core/src/schemas/field/common.schema.ts
index 3042c91ab2..a6d5c7353b 100644
--- a/packages/v2/core/src/schemas/field/common.schema.ts
+++ b/packages/v2/core/src/schemas/field/common.schema.ts
@@ -2,6 +2,7 @@ import { z } from 'zod';
 
 import { TimeFormatting } from '../../domain/table/fields/types/DateTimeFormatting';
 import { fieldColorSchema } from '../../domain/table/fields/types/FieldColor';
+import { longTextShowAsValues } from '../../domain/table/fields/types/LongTextShowAs';
 import { NumberFormattingType } from '../../domain/table/fields/types/NumberFormatting';
 import {
   MultiNumberDisplayType,
@@ -9,9 +10,8 @@ import {
 } from '../../domain/table/fields/types/NumberShowAs';
 import { ratingColorValues } from '../../domain/table/fields/types/RatingColor';
 import { ratingIconValues } from '../../domain/table/fields/types/RatingIcon';
-import { longTextShowAsValues } from '../../domain/table/fields/types/LongTextShowAs';
 import { singleLineTextShowAsValues } from '../../domain/table/fields/types/SingleLineTextShowAs';
-import { TIME_ZONE_LIST } from '../../domain/table/fields/types/TimeZone';
+import { timeZoneValueSchema } from '../../domain/table/fields/types/TimeZone';
 
 // Basic enum schemas (re-export or define locally)
 export const ratingIconSchema = z.enum(ratingIconValues);
@@ -61,7 +61,7 @@ export const numberShowAsSchema = z.union([singleNumberShowAsSchema, multiNumber
 export const dateFormattingSchema = z.object({
   date: z.string(),
   time: z.enum([TimeFormatting.Hour24, TimeFormatting.Hour12, TimeFormatting.None]),
-  timeZone: z.enum(TIME_ZONE_LIST),
+  timeZone: timeZoneValueSchema,
 });
 
 // Formula formatting (union of number and date)
diff --git a/packages/v2/core/src/schemas/field/tableField.schema.ts b/packages/v2/core/src/schemas/field/tableField.schema.ts
index 9f7a9a7318..3499640406 100644
--- a/packages/v2/core/src/schemas/field/tableField.schema.ts
+++ b/packages/v2/core/src/schemas/field/tableField.schema.ts
@@ -1,7 +1,7 @@
 import { z } from 'zod';
 
 import { fieldColorSchema, fieldColorValues } from '../../domain/table/fields/types/FieldColor';
-import { TIME_ZONE_LIST } from '../../domain/table/fields/types/TimeZone';
+import { timeZoneValueSchema } from '../../domain/table/fields/types/TimeZone';
 import {
   cellValueTypeSchema,
   dateFormattingSchema,
@@ -129,7 +129,7 @@ export const buttonOptionsSchema = z.object({
 
 export const formulaOptionsSchema = z.object({
   expression: z.string(),
-  timeZone: z.enum(TIME_ZONE_LIST).optional(),
+  timeZone: timeZoneValueSchema.optional(),
   formatting: formulaFormattingSchema.optional(),
   showAs: formulaShowAsSchema.optional(),
 });
@@ -154,7 +154,7 @@ export const linkOptionsSchema = z
 export const rollupOptionsSchema = z
   .object({
     expression: z.string(),
-    timeZone: z.enum(TIME_ZONE_LIST).optional(),
+    timeZone: timeZoneValueSchema.optional(),
     formatting: formulaFormattingSchema.optional(),
     showAs: formulaShowAsSchema.optional(),
   })
@@ -205,7 +205,7 @@ export const conditionalRollupConfigSchema = z
 export const conditionalRollupOptionsSchema = z
   .object({
     expression: z.string(),
-    timeZone: z.enum(TIME_ZONE_LIST).optional(),
+    timeZone: timeZoneValueSchema.optional(),
     formatting: formulaFormattingSchema.optional(),
     showAs: formulaShowAsSchema.optional(),
   })
diff --git a/packages/v2/core/src/schemas/field/time-zone.schema.spec.ts b/packages/v2/core/src/schemas/field/time-zone.schema.spec.ts
new file mode 100644
index 0000000000..57c9076f74
--- /dev/null
+++ b/packages/v2/core/src/schemas/field/time-zone.schema.spec.ts
@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest';
+
+import { TimeFormatting } from '../../domain/table/fields/types/DateTimeFormatting';
+import { dateFormattingSchema } from './common.schema';
+import {
+  conditionalRollupOptionsSchema,
+  formulaOptionsSchema,
+  rollupOptionsSchema,
+} from './tableField.schema';
+
+describe('field timezone schemas', () => {
+  it('accepts known IANA aliases in field option schemas', () => {
+    expect(
+      dateFormattingSchema.parse({
+        date: 'YYYY-MM-DD',
+        time: TimeFormatting.None,
+        timeZone: 'Asia/Saigon',
+      }).timeZone
+    ).toBe('Asia/Saigon');
+
+    expect(
+      formulaOptionsSchema.parse({
+        expression: 'NOW()',
+        timeZone: 'Asia/Saigon',
+      }).timeZone
+    ).toBe('Asia/Saigon');
+
+    expect(
+      rollupOptionsSchema.parse({
+        expression: 'COUNTALL(values)',
+        timeZone: 'Asia/Saigon',
+      }).timeZone
+    ).toBe('Asia/Saigon');
+
+    expect(
+      conditionalRollupOptionsSchema.parse({
+        expression: 'COUNTALL(values)',
+        timeZone: 'Asia/Saigon',
+      }).timeZone
+    ).toBe('Asia/Saigon');
+  });
+
+  it('still rejects invalid timezone values', () => {
+    expect(() =>
+      dateFormattingSchema.parse({
+        date: 'YYYY-MM-DD',
+        time: TimeFormatting.None,
+        timeZone: 'Invalid/Zone',
+      })
+    ).toThrow();
+  });
+});
diff --git a/packages/v2/dottea/src/index.ts b/packages/v2/dottea/src/index.ts
index 55ced87fa6..8854e3fdd9 100644
--- a/packages/v2/dottea/src/index.ts
+++ b/packages/v2/dottea/src/index.ts
@@ -109,29 +109,26 @@ export class DotTeaParser implements IDotTeaParser {
 
     const structure = structureResult.value;
 
-    // Build a map of field IDs to field types for dependency detection
-    const fieldTypesById = new Map<string, string>();
-    for (const table of structure.tables) {
-      for (const field of table.fields) {
-        if (field.id) {
-          fieldTypesById.set(field.id, field.type);
-        }
-      }
-    }
-
-    // Normalize all tables and their fields
-    const normalizedTables = structure.tables.map((table) => ({
-      ...(table.id ? { id: table.id } : {}),
-      name: table.name,
-      fields: table.fields.map((field) => normalizeField(field, fieldTypesById)),
-      views: table.views
-        ?.filter((view) => (view.type ? allowedViewTypes.has(view.type) : true))
-        .map((view) => ({
-          ...(view.id ? { id: view.id } : {}),
-          name: view.name,
-          type: view.type,
-        })),
-    }));
+    // Normalize all tables and their fields using table-local field IDs so
+    // legacy formulas that reference deleted fields can be downgraded safely.
+    const normalizedTables = structure.tables.map((table) => {
+      const tableFieldTypesById = new Map(
+        table.fields.filter((field) => field.id).map((field) => [field.id!, field.type] as const)
+      );
+
+      return {
+        ...(table.id ? { id: table.id } : {}),
+        name: table.name,
+        fields: table.fields.map((field) => normalizeField(field, tableFieldTypesById)),
+        views: table.views
+          ?.filter((view) => (view.type ? allowedViewTypes.has(view.type) : true))
+          .map((view) => ({
+            ...(view.id ? { id: view.id } : {}),
+            name: view.name,
+            type: view.type,
+          })),
+      };
+    });
 
     return ok({ tables: normalizedTables });
   }
diff --git a/packages/v2/dottea/src/normalizer/DotTeaFieldNormalizer.spec.ts b/packages/v2/dottea/src/normalizer/DotTeaFieldNormalizer.spec.ts
new file mode 100644
index 0000000000..b4b142e747
--- /dev/null
+++ b/packages/v2/dottea/src/normalizer/DotTeaFieldNormalizer.spec.ts
@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildTableFromInput } from '../../../core/src/commands/TableInputParser';
+import { normalizeField } from './DotTeaFieldNormalizer';
+
+describe('DotTeaFieldNormalizer', () => {
+  it('deduplicates select choices that only differ by surrounding whitespace', () => {
+    const normalized = normalizeField(
+      {
+        id: `fld${'s'.repeat(16)}`,
+        type: 'singleSelect',
+        name: 'T次',
+        options: {
+          choices: [
+            { id: 'chom4XbfXuh', name: 'T1', color: 'purple' },
+            { id: 'cho0eYy9LIM', name: ' T1', color: 'purpleLight2' },
+            { id: 'chojvEzfz4d', name: 'T2', color: 'blueLight2' },
+          ],
+          defaultValue: ' T1',
+        },
+      },
+      new Map()
+    );
+
+    expect(normalized.options).toEqual({
+      choices: [
+        { id: 'chom4XbfXuh', name: 'T1', color: 'purple' },
+        { id: 'chojvEzfz4d', name: 'T2', color: 'blueLight2' },
+      ],
+      defaultValue: 'T1',
+    });
+
+    const result = buildTableFromInput({
+      baseId: `bse${'a'.repeat(16)}`,
+      tableId: `tbl${'b'.repeat(16)}`,
+      name: 'Import Test',
+      fields: [
+        {
+          id: `fld${'p'.repeat(16)}`,
+          type: 'singleLineText',
+          name: 'Name',
+          isPrimary: true,
+        },
+        {
+          id: normalized.id,
+          type: normalized.type,
+          name: normalized.name,
+          options: normalized.options,
+        },
+      ],
+    });
+
+    expect(result.isOk()).toBe(true);
+  });
+
+  it('downgrades formulas that reference missing fields to singleLineText', () => {
+    const normalized = normalizeField(
+      {
+        id: `fld${'f'.repeat(16)}`,
+        type: 'formula',
+        name: 'Broken Formula',
+        options: {
+          expression: 'SUM({fldaaaaaaaaaaaaaaaa},{fldbbbbbbbbbbbbbbbb})',
+        },
+      },
+      new Map([['fldaaaaaaaaaaaaaaaa', 'number']])
+    );
+
+    expect(normalized.type).toBe('singleLineText');
+    expect(normalized.options).toEqual({
+      expression: 'SUM({fldaaaaaaaaaaaaaaaa},{fldbbbbbbbbbbbbbbbb})',
+    });
+  });
+});
diff --git a/packages/v2/dottea/src/normalizer/DotTeaFieldNormalizer.ts b/packages/v2/dottea/src/normalizer/DotTeaFieldNormalizer.ts
index 80bfd74a9e..0933d0a72f 100644
--- a/packages/v2/dottea/src/normalizer/DotTeaFieldNormalizer.ts
+++ b/packages/v2/dottea/src/normalizer/DotTeaFieldNormalizer.ts
@@ -6,6 +6,53 @@ const asRecord = (value: unknown): Record<string, unknown> | undefined =>
 const readString = (value: Record<string, unknown> | undefined, key: string): string | undefined =>
   typeof value?.[key] === 'string' ? (value[key] as string) : undefined;
 
+const normalizeSelectOptionName = (name: unknown): unknown =>
+  typeof name === 'string' ? name.trim() : name;
+
+const normalizeSelectDefaultValue = (value: unknown): unknown => {
+  if (typeof value === 'string') {
+    return value.trim();
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => (typeof item === 'string' ? item.trim() : item));
+  }
+  return value;
+};
+
+const normalizeSelectChoices = (
+  options: Record<string, unknown> | undefined
+): Record<string, unknown> | undefined => {
+  if (!options || !Array.isArray(options.choices)) {
+    return options;
+  }
+
+  const seen = new Set<string>();
+  const choices = options.choices.flatMap((choice) => {
+    if (!choice || typeof choice !== 'object' || Array.isArray(choice)) {
+      return [choice];
+    }
+
+    const rawChoice = choice as Record<string, unknown>;
+    const normalizedName = normalizeSelectOptionName(rawChoice.name);
+    if (typeof normalizedName === 'string') {
+      if (seen.has(normalizedName)) {
+        return [];
+      }
+      seen.add(normalizedName);
+    }
+
+    return [{ ...rawChoice, name: normalizedName }];
+  });
+
+  return {
+    ...options,
+    choices,
+    ...(options.defaultValue !== undefined
+      ? { defaultValue: normalizeSelectDefaultValue(options.defaultValue) }
+      : {}),
+  };
+};
+
 /**
  * Extract field IDs from a formula expression.
  */
@@ -116,11 +163,17 @@ export const normalizeFieldOptions = (
   fieldTypesById: ReadonlyMap<string, string>
 ): NormalizedFieldOptions => {
   const rawOptions = asRecord(field.options);
+  const normalizedSelectOptions =
+    field.type === 'singleSelect' || field.type === 'multipleSelect'
+      ? normalizeSelectChoices(rawOptions)
+      : rawOptions;
   const rawLookupOptions = asRecord(field.lookupOptions);
 
   if (field.type === 'link') {
-    const options = normalizeLinkOptions(rawOptions);
-    return options ? { type: 'link', options } : { type: 'singleLineText', options: rawOptions };
+    const options = normalizeLinkOptions(normalizedSelectOptions);
+    return options
+      ? { type: 'link', options }
+      : { type: 'singleLineText', options: normalizedSelectOptions };
   }
 
   const lookupOptions = normalizeLookupOptions(rawLookupOptions);
@@ -129,10 +182,10 @@ export const normalizeFieldOptions = (
   }
 
   if (field.type === 'rollup') {
-    const options = normalizeFormulaOptions(rawOptions, 'countall({values})');
+    const options = normalizeFormulaOptions(normalizedSelectOptions, 'countall({values})');
     return options && lookupOptions
       ? { type: 'rollup', options, config: lookupOptions }
-      : { type: 'singleLineText', options: rawOptions };
+      : { type: 'singleLineText', options: normalizedSelectOptions };
   }
 
   // Check conditionalLookup BEFORE formula, because v1 dottea stores conditional lookups
@@ -141,21 +194,24 @@ export const normalizeFieldOptions = (
   if (field.type === 'conditionalLookup' || field.isConditionalLookup) {
     // Config can be in rawOptions or rawLookupOptions depending on v1 export format
     const foreignTableId =
-      readString(rawLookupOptions, 'foreignTableId') ?? readString(rawOptions, 'foreignTableId');
+      readString(rawLookupOptions, 'foreignTableId') ??
+      readString(normalizedSelectOptions, 'foreignTableId');
     const lookupFieldId =
-      readString(rawLookupOptions, 'lookupFieldId') ?? readString(rawOptions, 'lookupFieldId');
-    const condition = normalizeCondition(rawLookupOptions) ?? normalizeCondition(rawOptions);
+      readString(rawLookupOptions, 'lookupFieldId') ??
+      readString(normalizedSelectOptions, 'lookupFieldId');
+    const condition =
+      normalizeCondition(rawLookupOptions) ?? normalizeCondition(normalizedSelectOptions);
     if (foreignTableId && lookupFieldId && condition) {
       return { type: 'conditionalLookup', options: { foreignTableId, lookupFieldId, condition } };
     }
-    return { type: 'singleLineText', options: rawOptions };
+    return { type: 'singleLineText', options: normalizedSelectOptions };
   }
 
   if (field.type === 'conditionalRollup') {
-    const options = normalizeFormulaOptions(rawOptions, 'countall({values})');
-    const foreignTableId = readString(rawOptions, 'foreignTableId');
-    const lookupFieldId = readString(rawOptions, 'lookupFieldId');
-    const condition = normalizeCondition(rawOptions);
+    const options = normalizeFormulaOptions(normalizedSelectOptions, 'countall({values})');
+    const foreignTableId = readString(normalizedSelectOptions, 'foreignTableId');
+    const lookupFieldId = readString(normalizedSelectOptions, 'lookupFieldId');
+    const condition = normalizeCondition(normalizedSelectOptions);
     if (options && foreignTableId && lookupFieldId && condition) {
       return {
         type: 'conditionalRollup',
@@ -163,24 +219,30 @@ export const normalizeFieldOptions = (
         config: { foreignTableId, lookupFieldId, condition },
       };
     }
-    return { type: 'singleLineText', options: rawOptions };
+    return { type: 'singleLineText', options: normalizedSelectOptions };
   }
 
   if (field.type === 'formula') {
-    const expression = typeof rawOptions?.expression === 'string' ? rawOptions.expression : '';
+    const expression =
+      typeof normalizedSelectOptions?.expression === 'string'
+        ? normalizedSelectOptions.expression
+        : '';
     const refs = expression ? extractFieldReferences(expression) : [];
+    const hasMissingDependency = refs.some((ref) => !fieldTypesById.has(ref));
     const hasComputedDependency = refs.some((ref) => {
       const type = fieldTypesById.get(ref);
       return type === 'rollup' || type === 'conditionalRollup';
     });
-    if (hasComputedDependency) {
-      return { type: 'singleLineText', options: rawOptions };
+    if (hasMissingDependency || hasComputedDependency) {
+      return { type: 'singleLineText', options: normalizedSelectOptions };
     }
-    const options = normalizeFormulaOptions(rawOptions, '0');
-    return options ? { type: 'formula', options } : { type: 'singleLineText', options: rawOptions };
+    const options = normalizeFormulaOptions(normalizedSelectOptions, '0');
+    return options
+      ? { type: 'formula', options }
+      : { type: 'singleLineText', options: normalizedSelectOptions };
   }
 
-  return { options: rawOptions };
+  return { options: normalizedSelectOptions };
 };
 
 /**
diff --git a/packages/v2/e2e/src/date-time.e2e.spec.ts b/packages/v2/e2e/src/date-time.e2e.spec.ts
index f203be3412..d2b7c33315 100644
--- a/packages/v2/e2e/src/date-time.e2e.spec.ts
+++ b/packages/v2/e2e/src/date-time.e2e.spec.ts
@@ -5,7 +5,7 @@ import {
   listTableRecordsOkResponseSchema,
   updateRecordOkResponseSchema,
 } from '@teable/v2-contract-http';
-import { FieldKeyType, type RecordFilter, type RecordSearchInput } from '@teable/v2-core';
+import { FieldKeyType, type RecordFilter } from '@teable/v2-core';
 import { beforeAll, describe, expect, it } from 'vitest';
 import { getSharedTestContext, type SharedTestContext } from './shared/globalTestContext';
 
@@ -133,7 +133,7 @@ describe('v2 http date time parsing (e2e)', () => {
 
   const listRecords = async (
     tableId: string,
-    options?: { filter?: RecordFilter; groupBy?: string[]; search?: RecordSearchInput }
+    options?: { filter?: RecordFilter; groupBy?: string[] }
   ) => {
     const params = new URLSearchParams({
       tableId,
@@ -148,10 +148,6 @@ describe('v2 http date time parsing (e2e)', () => {
       params.set('groupBy', JSON.stringify(options.groupBy));
     }
 
-    if (options?.search) {
-      params.set('search', JSON.stringify(options.search));
-    }
-
     const response = await fetch(`${ctx.baseUrl}/tables/listRecords?${params.toString()}`, {
       method: 'GET',
       headers: { 'content-type': 'application/json' },
@@ -209,51 +205,6 @@ describe('v2 http date time parsing (e2e)', () => {
     expect(updatedRecord.fields[dateFieldId]).toBe(dateCase.update.expected);
   });
 
-  it('searches date fields globally', async () => {
-    const table = await createTable({
-      baseId: ctx.baseId,
-      name: uniqueName('global-date-search'),
-      fields: [
-        { type: 'singleLineText', name: 'Title', isPrimary: true },
-        {
-          type: 'date',
-          name: 'Question Date',
-          options: {
-            formatting: {
-              date: 'YYYY-MM-DD',
-              time: 'None',
-              timeZone: 'utc',
-            },
-          },
-        },
-      ],
-      views: [{ type: 'grid' }],
-    });
-
-    const primaryFieldId = table.fields.find((field) => field.isPrimary)?.id ?? '';
-    const dateFieldId = table.fields.find((field) => field.name === 'Question Date')?.id ?? '';
-
-    await createRecords(table.id, [
-      {
-        fields: {
-          [primaryFieldId]: 'Target',
-          [dateFieldId]: '2026-02-24',
-        },
-      },
-      {
-        fields: {
-          [primaryFieldId]: 'Other',
-          [dateFieldId]: '2026-02-25',
-        },
-      },
-    ]);
-
-    const records = await listRecords(table.id, { search: ['2026-02-24', '', true] });
-
-    expect(records).toHaveLength(1);
-    expect(records[0]?.fields[primaryFieldId]).toBe('Target');
-  });
-
   it('filters exact datetime groups to a single timestamp', async () => {
     const table = await createTable({
       baseId: ctx.baseId,
diff --git a/packages/v2/e2e/src/link-migration-compat.e2e.spec.ts b/packages/v2/e2e/src/link-migration-compat.e2e.spec.ts
index 5bb775abdc..b945022b21 100644
--- a/packages/v2/e2e/src/link-migration-compat.e2e.spec.ts
+++ b/packages/v2/e2e/src/link-migration-compat.e2e.spec.ts
@@ -3,6 +3,7 @@ import {
   createRecordOkResponseSchema,
   createRecordsOkResponseSchema,
   createTableOkResponseSchema,
+  getTableByIdOkResponseSchema,
   listTableRecordsOkResponseSchema,
   updateRecordOkResponseSchema,
   updateRecordsOkResponseSchema,
@@ -261,10 +262,44 @@ describe('v2 link migration compatibility – step-by-step debug', () => {
       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');
+    it('Step 7 – symmetric link on Speakers table populated after updateRecord', async () => {
+      console.log('\n======= Step 7: listRecords – check symmetric links =======');
+
+      const tableRes = await apiGet(`/tables/get?baseId=${ctx.baseId}&tableId=${speakersTableId}`);
+      expect(tableRes.status).toBe(200);
+      const speakerTable = getTableByIdOkResponseSchema.parse(tableRes.body).data.table;
+      const symmetricField = speakerTable.fields.find((field) => {
+        if (field.type !== 'link') return false;
+        const options = field.options as { symmetricFieldId?: string };
+        return options.symmetricFieldId === esLinkFieldId;
+      });
+      expect(symmetricField).toBeDefined();
+      if (!symmetricField) return;
+
+      await ctx.testContainer.processOutbox();
+
+      const res = await apiGet(
+        `/tables/listRecords?tableId=${speakersTableId}&fieldKeyType=${FieldKeyType.Id}`
+      );
+      expect(res.status).toBe(200);
+      const records = listTableRecordsOkResponseSchema.parse(res.body).data.records;
+
+      const alice = records.find((r) => r.id === spkAliceId);
+      const bob = records.find((r) => r.id === spkBobId);
+      expect(alice).toBeDefined();
+      expect(bob).toBeDefined();
+      if (!alice || !bob) return;
+
+      const aliceLinks = alice.fields[symmetricField.id] as Array<{ id: string; title?: string }>;
+      const bobLinks = bob.fields[symmetricField.id] as Array<{ id: string; title?: string }>;
+      console.log('  Alice symmetric links:', JSON.stringify(aliceLinks));
+      console.log('  Bob symmetric links:', JSON.stringify(bobLinks));
+
+      expect(aliceLinks).toHaveLength(1);
+      expect(aliceLinks[0]).toMatchObject({ id: es001Id, title: 'ES001' });
+      expect(bobLinks).toHaveLength(1);
+      expect(bobLinks[0]).toMatchObject({ id: es002Id, title: 'ES002' });
+    });
   });
 
   // ═══════════════════════════════════════════════════════════════════════════
diff --git a/packages/v2/e2e/src/record-http-compat.e2e.spec.ts b/packages/v2/e2e/src/record-http-compat.e2e.spec.ts
index 4f12cb7e3d..754a16a667 100644
--- a/packages/v2/e2e/src/record-http-compat.e2e.spec.ts
+++ b/packages/v2/e2e/src/record-http-compat.e2e.spec.ts
@@ -24,6 +24,7 @@ describe('v2 http record compatibility (P0)', () => {
   let attachmentPath = '';
   let attachmentSize = 0;
   let attachmentMimetype = '';
+  let attachmentIdCounter = 0;
 
   const uniqueTableName = (prefix: string) => {
     tableCounter += 1;
@@ -210,18 +211,36 @@ describe('v2 http record compatibility (P0)', () => {
   };
 
   const seedAttachment = async () => {
-    attachmentToken = `tok_${Date.now()}`;
-    attachmentPath = 'table/DXR3aPmms8EI';
-    attachmentSize = 4;
-    attachmentMimetype = 'text/plain';
+    attachmentIdCounter += 1;
+    const token = `tok_${Date.now()}_${attachmentIdCounter}`;
+    const path = `table/DXR3aPmms8EI_${attachmentIdCounter}`;
+    const size = 4 + attachmentIdCounter;
+    const mimetype = 'text/plain';
 
     await sql
       .raw(
         `insert into attachments (id, token, hash, size, mimetype, path, created_by)
-         values ('att_${Date.now()}', '${attachmentToken}', 'hash', ${attachmentSize}, '${attachmentMimetype}', '${attachmentPath}', '${ctx.testUser.id}')
+         values ('att_${Date.now()}_${attachmentIdCounter}', '${token}', 'hash', ${size}, '${mimetype}', '${path}', '${ctx.testUser.id}')
          on conflict (token) do nothing`
       )
       .execute(ctx.testContainer.db);
+
+    return {
+      token,
+      path,
+      size,
+      mimetype,
+    };
+  };
+
+  const listAttachmentRows = async (recordId: string, fieldId: string) => {
+    return await ctx.testContainer.db
+      .selectFrom('attachments_table')
+      .select(['attachment_id', 'token', 'name', 'table_id', 'record_id', 'field_id'])
+      .where('record_id', '=', recordId)
+      .where('field_id', '=', fieldId)
+      .orderBy('token')
+      .execute();
   };
 
   beforeAll(async () => {
@@ -229,7 +248,11 @@ describe('v2 http record compatibility (P0)', () => {
 
     // Test user is already inserted by globalTestContext
     await ensureAttachmentTables();
-    await seedAttachment();
+    const seeded = await seedAttachment();
+    attachmentToken = seeded.token;
+    attachmentPath = seeded.path;
+    attachmentSize = seeded.size;
+    attachmentMimetype = seeded.mimetype;
   });
 
   describe('audit user fields', () => {
@@ -464,6 +487,72 @@ describe('v2 http record compatibility (P0)', () => {
       ]);
     });
 
+    it('persists attachment rows into attachments_table on create and update', async () => {
+      const initialAttachment = await seedAttachment();
+      const replacementAttachment = await seedAttachment();
+      const table = await createTable({
+        baseId: ctx.baseId,
+        name: uniqueTableName('attachment-sync'),
+        fields: [
+          { type: 'singleLineText', name: 'title', isPrimary: true },
+          { type: 'attachment', name: 'attachment' },
+        ],
+      });
+      const titleFieldId = table.fields.find((field) => field.name === 'title')?.id ?? '';
+      const attachmentFieldId = table.fields.find((field) => field.name === 'attachment')?.id ?? '';
+
+      const createdRecord = await createRecord(table.id, {
+        [titleFieldId]: 'attachment row sync',
+        [attachmentFieldId]: [
+          {
+            id: 'act_sync_create_1',
+            name: 'created.txt',
+            token: initialAttachment.token,
+            path: 'ignored/on/write',
+            size: 1,
+            mimetype: 'text/plain',
+          },
+        ],
+      });
+
+      const createdRows = await listAttachmentRows(createdRecord.id, attachmentFieldId);
+      expect(createdRows).toEqual([
+        {
+          attachment_id: 'act_sync_create_1',
+          token: initialAttachment.token,
+          name: 'created.txt',
+          table_id: table.id,
+          record_id: createdRecord.id,
+          field_id: attachmentFieldId,
+        },
+      ]);
+
+      await updateRecord(table.id, createdRecord.id, {
+        [attachmentFieldId]: [
+          {
+            id: 'act_sync_update_1',
+            name: 'updated.txt',
+            token: replacementAttachment.token,
+            path: 'ignored/on/update',
+            size: 2,
+            mimetype: 'text/plain',
+          },
+        ],
+      });
+
+      const updatedRows = await listAttachmentRows(createdRecord.id, attachmentFieldId);
+      expect(updatedRows).toEqual([
+        {
+          attachment_id: 'act_sync_update_1',
+          token: replacementAttachment.token,
+          name: 'updated.txt',
+          table_id: table.id,
+          record_id: createdRecord.id,
+          field_id: attachmentFieldId,
+        },
+      ]);
+    });
+
     it('errors when attachment token not exist', async () => {
       const table = await createTable({
         baseId: ctx.baseId,
diff --git a/packages/v2/e2e/src/update-field/computed/force-v2-all-regressions.spec.ts b/packages/v2/e2e/src/update-field/computed/force-v2-all-regressions.spec.ts
index 74501ecade..a5f99712a7 100644
--- a/packages/v2/e2e/src/update-field/computed/force-v2-all-regressions.spec.ts
+++ b/packages/v2/e2e/src/update-field/computed/force-v2-all-regressions.spec.ts
@@ -10,6 +10,36 @@ const createFieldId = () => {
   return `fld${suffix}`;
 };
 
+const getDbTableName = async (ctx: SharedTestContext, tableId: string) => {
+  const tableMeta = await ctx.testContainer.db
+    .selectFrom('table_meta')
+    .select('db_table_name')
+    .where('id', '=', tableId)
+    .executeTakeFirst();
+
+  const dbTableName = tableMeta?.db_table_name;
+  if (!dbTableName) {
+    throw new Error(`Missing db_table_name for table ${tableId}`);
+  }
+
+  return dbTableName;
+};
+
+const getDbFieldName = async (ctx: SharedTestContext, fieldId: string) => {
+  const fieldMeta = await ctx.testContainer.db
+    .selectFrom('field')
+    .select('db_field_name')
+    .where('id', '=', fieldId)
+    .executeTakeFirst();
+
+  const dbFieldName = fieldMeta?.db_field_name;
+  if (!dbFieldName) {
+    throw new Error(`Missing db_field_name for field ${fieldId}`);
+  }
+
+  return dbFieldName;
+};
+
 describe('update-field: FORCE_V2_ALL regressions', () => {
   let ctx: SharedTestContext;
   let nameCounter = 0;
@@ -203,6 +233,114 @@ describe('update-field: FORCE_V2_ALL regressions', () => {
     }
   );
 
+  test(
+    'converts text to formula using stored link title snapshot when foreign display is blank',
+    { timeout: 120_000 },
+    async () => {
+      let hostTableId: string | undefined;
+      let foreignTableId: string | undefined;
+
+      try {
+        const expectedTitle = 'Snapshot Title';
+        const foreignNameFieldId = createFieldId();
+        const linkFieldId = createFieldId();
+        const formulaFieldId = createFieldId();
+
+        const foreignTable = await ctx.createTable({
+          baseId: ctx.baseId,
+          name: nextName('v1p-link-formula-foreign'),
+          fields: [
+            {
+              type: 'singleLineText',
+              id: foreignNameFieldId,
+              name: 'Name',
+              isPrimary: true,
+            },
+          ],
+        });
+        foreignTableId = foreignTable.id;
+
+        const foreignRecord = await ctx.createRecord(foreignTable.id, {
+          [foreignNameFieldId]: expectedTitle,
+        });
+
+        const hostTable = await ctx.createTable({
+          baseId: ctx.baseId,
+          name: nextName('v1p-link-formula-host'),
+          fields: [
+            { type: 'singleLineText', name: 'Name', isPrimary: true },
+            { type: 'singleLineText', id: formulaFieldId, name: 'Formula Target' },
+          ],
+        });
+        hostTableId = hostTable.id;
+
+        const hostRecord = await ctx.createRecord(hostTable.id, {
+          Name: 'Host Row',
+          [formulaFieldId]: 'will convert',
+        });
+
+        await ctx.createField({
+          baseId: ctx.baseId,
+          tableId: hostTable.id,
+          field: {
+            type: 'link',
+            id: linkFieldId,
+            name: 'Linked Record',
+            options: {
+              relationship: 'manyOne',
+              foreignTableId: foreignTable.id,
+              lookupFieldId: foreignNameFieldId,
+            },
+          },
+        });
+
+        await ctx.updateRecord(hostTable.id, hostRecord.id, {
+          [linkFieldId]: { id: foreignRecord.id },
+        });
+        await ctx.drainOutbox();
+
+        const linkedRows = await ctx.listRecords(hostTable.id, { limit: 10, offset: 0 });
+        const linkedRow = linkedRows.find((record) => record.id === hostRecord.id);
+        expect(linkedRow?.fields[linkFieldId]).toEqual({
+          id: foreignRecord.id,
+          title: expectedTitle,
+        });
+
+        const foreignDbTableName = await getDbTableName(ctx, foreignTable.id);
+        const foreignNameDbFieldName = await getDbFieldName(ctx, foreignNameFieldId);
+        await sql`
+          UPDATE ${sql.table(foreignDbTableName)}
+          SET ${sql.ref(foreignNameDbFieldName)} = ${''}
+          WHERE "__id" = ${foreignRecord.id}
+        `.execute(ctx.testContainer.db);
+
+        await ctx.updateField({
+          tableId: hostTable.id,
+          fieldId: formulaFieldId,
+          field: {
+            type: 'formula',
+            name: 'Formula Target',
+            options: {
+              expression: `{${linkFieldId}}`,
+            },
+          },
+        });
+        await ctx.drainOutbox();
+
+        const records = await ctx.listRecords(hostTable.id, { limit: 10, offset: 0 });
+        const record = records.find((item) => item.id === hostRecord.id);
+        expect(record?.fields[formulaFieldId]).toBe(expectedTitle);
+      } finally {
+        if (hostTableId) {
+          await ctx.deleteTable(hostTableId).catch(() => undefined);
+        }
+        if (foreignTableId) {
+          await ctx.deleteTable(foreignTableId).catch(() => undefined);
+        }
+      }
+    }
+  );
+
   test(
     'ignores malformed numeric text in conditional rollup backfill instead of throwing pg cast errors',
     { timeout: 120_000 },
diff --git a/packages/v2/e2e/src/updateRecord.e2e.spec.ts b/packages/v2/e2e/src/updateRecord.e2e.spec.ts
index ed290d312f..7a402851e3 100644
--- a/packages/v2/e2e/src/updateRecord.e2e.spec.ts
+++ b/packages/v2/e2e/src/updateRecord.e2e.spec.ts
@@ -1062,4 +1062,84 @@ describe('v2 http updateRecord (e2e)', () => {
       | undefined;
     expect((updatedLinks ?? []).some((link) => link.id === project.id)).toBe(false);
   });
+
+  it('updates original link values when generated symmetric relations change', async () => {
+    const items = await ctx.createTable({
+      baseId: ctx.baseId,
+      name: 'Items For Reverse Link',
+      fields: [{ type: 'singleLineText', name: 'Item', isPrimary: true }],
+      views: [{ type: 'grid' }],
+    });
+
+    const itemNameFieldId = items.fields.find((f) => f.isPrimary)?.id ?? '';
+    if (!itemNameFieldId) {
+      throw new Error('Missing item primary field for reverse symmetric link test');
+    }
+
+    const orderItemsLinkId = createFieldId();
+
+    const orders = await ctx.createTable({
+      baseId: ctx.baseId,
+      name: 'Orders With Link',
+      fields: [
+        { type: 'singleLineText', name: 'Order', isPrimary: true },
+        {
+          type: 'link',
+          id: orderItemsLinkId,
+          name: 'Items',
+          options: {
+            relationship: 'manyMany',
+            foreignTableId: items.id,
+            lookupFieldId: itemNameFieldId,
+          },
+        },
+      ],
+      views: [{ type: 'grid' }],
+    });
+
+    const orderNameFieldId = orders.fields.find((f) => f.isPrimary)?.id ?? '';
+    if (!orderNameFieldId) {
+      throw new Error('Missing order primary field for reverse symmetric link test');
+    }
+
+    const orderLinkField = orders.fields.find((f) => f.id === orderItemsLinkId);
+    if (!orderLinkField || orderLinkField.type !== 'link') {
+      throw new Error('Missing order link field');
+    }
+    const symmetricFieldId = orderLinkField.options.symmetricFieldId ?? '';
+    if (!symmetricFieldId) throw new Error('Missing reverse symmetric link field id');
+
+    const item = await ctx.createRecord(items.id, {
+      [itemNameFieldId]: 'Item 1',
+    });
+
+    const order = await ctx.createRecord(orders.id, {
+      [orderNameFieldId]: 'Order 1',
+    });
+    await processOutbox(2);
+
+    await ctx.updateRecord(items.id, item.id, {
+      [symmetricFieldId]: [{ id: order.id }],
+    });
+    await processOutbox(2);
+
+    let orderRecords = await ctx.listRecords(orders.id);
+    let orderRow = orderRecords.find((r) => r.id === order.id);
+    const originalLinks = normalizeLookupArray(orderRow?.fields[orderItemsLinkId]) as
+      | Array<{ id: string }>
+      | undefined;
+    expect(originalLinks?.some((link) => link.id === item.id)).toBe(true);
+
+    await ctx.updateRecord(items.id, item.id, {
+      [symmetricFieldId]: [],
+    });
+    await processOutbox(2);
+
+    orderRecords = await ctx.listRecords(orders.id);
+    orderRow = orderRecords.find((r) => r.id === order.id);
+    const updatedOriginalLinks = normalizeLookupArray(orderRow?.fields[orderItemsLinkId]) as
+      | Array<{ id: string }>
+      | undefined;
+    expect((updatedOriginalLinks ?? []).some((link) => link.id === item.id)).toBe(false);
+  });
 });
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index a8a6184fae..edfba347b2 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -58,38 +58,41 @@ importers:
   apps/nestjs-backend:
     dependencies:
       '@ai-sdk/amazon-bedrock':
-        specifier: 4.0.69
-        version: 4.0.69(zod@4.1.8)
+        specifier: 4.0.97
+        version: 4.0.97(zod@4.1.8)
       '@ai-sdk/anthropic':
-        specifier: 3.0.50
-        version: 3.0.50(zod@4.1.8)
+        specifier: 3.0.72
+        version: 3.0.72(zod@4.1.8)
       '@ai-sdk/azure':
-        specifier: 3.0.38
-        version: 3.0.38(zod@4.1.8)
+        specifier: 3.0.55
+        version: 3.0.55(zod@4.1.8)
       '@ai-sdk/cohere':
-        specifier: 3.0.22
-        version: 3.0.22(zod@4.1.8)
+        specifier: 3.0.31
+        version: 3.0.31(zod@4.1.8)
       '@ai-sdk/deepseek':
-        specifier: 2.0.21
-        version: 2.0.21(zod@4.1.8)
+        specifier: 2.0.30
+        version: 2.0.30(zod@4.1.8)
       '@ai-sdk/google':
-        specifier: 3.0.34
-        version: 3.0.34(zod@4.1.8)
+        specifier: 3.0.65
+        version: 3.0.65(zod@4.1.8)
       '@ai-sdk/mistral':
-        specifier: 3.0.21
-        version: 3.0.21(zod@4.1.8)
+        specifier: 3.0.31
+        version: 3.0.31(zod@4.1.8)
       '@ai-sdk/openai':
-        specifier: 3.0.37
-        version: 3.0.37(zod@4.1.8)
+        specifier: 3.0.54
+        version: 3.0.54(zod@4.1.8)
       '@ai-sdk/openai-compatible':
-        specifier: 2.0.31
-        version: 2.0.31(zod@4.1.8)
+        specifier: 2.0.42
+        version: 2.0.42(zod@4.1.8)
+      '@ai-sdk/provider':
+        specifier: 3.0.9
+        version: 3.0.9
       '@ai-sdk/togetherai':
-        specifier: 2.0.35
-        version: 2.0.35(zod@4.1.8)
+        specifier: 2.0.46
+        version: 2.0.46(zod@4.1.8)
       '@ai-sdk/xai':
-        specifier: 3.0.60
-        version: 3.0.60(zod@4.1.8)
+        specifier: 3.0.84
+        version: 3.0.84(zod@4.1.8)
       '@an-epiphany/websocket-json-stream':
         specifier: 1.2.0
         version: 1.2.0
@@ -151,8 +154,8 @@ importers:
         specifier: 10.3.5
         version: 10.3.5(@nestjs/common@10.3.5(class-transformer@0.5.1)(class-validator@0.14.1)(reflect-metadata@0.2.1)(rxjs@7.8.1))(@nestjs/core@10.3.5)(reflect-metadata@0.2.1)(rxjs@7.8.1)
       '@openrouter/ai-sdk-provider':
-        specifier: 2.2.3
-        version: 2.2.3(ai@6.0.105(zod@4.1.8))(zod@4.1.8)
+        specifier: 2.8.1
+        version: 2.8.1(ai@6.0.169(zod@4.1.8))(zod@4.1.8)
       '@opentelemetry/api':
         specifier: 1.9.0
         version: 1.9.0
@@ -268,8 +271,8 @@ importers:
         specifier: 1.3.0
         version: 1.3.0(valibot@1.1.0(typescript@5.4.3))
       ai:
-        specifier: 6.0.105
-        version: 6.0.105(zod@4.1.8)
+        specifier: 6.0.169
+        version: 6.0.169(zod@4.1.8)
       ajv:
         specifier: 8.12.0
         version: 8.12.0
@@ -412,8 +415,8 @@ importers:
         specifier: 2.6.4
         version: 2.6.4
       ollama-ai-provider-v2:
-        specifier: 3.0.2
-        version: 3.0.2(ai@6.0.105(zod@4.1.8))(zod@4.1.8)
+        specifier: 3.5.0
+        version: 3.5.0(ai@6.0.169(zod@4.1.8))(zod@4.1.8)
       p-limit:
         specifier: 3.1.0
         version: 3.1.0
@@ -4361,94 +4364,94 @@ packages:
   '@adobe/css-tools@4.4.1':
     resolution: {integrity: sha512-12WGKBQzjUAI4ayyF4IAtfw2QR/IDoqk6jTddXDhtYTJF9ASmoE1zst7cVtP0aL/F1jUJL5r+JxKXKEgHNbEUQ==}
 
-  '@ai-sdk/amazon-bedrock@4.0.69':
-    resolution: {integrity: sha512-XdsJnMa1DZAQJ4bRuy97JYF48fSJUZWUpjg4rrDrzKY6wUAOIKpHMHmnGF6bCpd3NcR6E2R7c/HhWyIQAHuuUg==}
+  '@ai-sdk/amazon-bedrock@4.0.97':
+    resolution: {integrity: sha512-T0uI1FeZ3IHM6n8x9Taylh1wOY1BYQ86AlLxcVs+oONLHTetSpev9JxJa/QID/3a5L6ve8p1+oXxtyVRrv7N7A==}
     engines: {node: '>=18'}
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
 
-  '@ai-sdk/anthropic@3.0.50':
-    resolution: {integrity: sha512-BkCUgGTp/iZJuuFBF1wv7GGnrEJg7X7hqbaa+/t4HTBt9dZn3e6NFn5NhPUvo2p5SreUeHEl0As0r2uaVn3K9Q==}
+  '@ai-sdk/anthropic@3.0.72':
+    resolution: {integrity: sha512-t0j9mggxylA9uP0hi12NlRk2npYh4QkE7JIpws2MdV/18QzHcsT6+TNGIjbOPayLQDjrmRKx78Ym7iZkg9qRxQ==}
     engines: {node: '>=18'}
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
 
-  '@ai-sdk/azure@3.0.38':
-    resolution: {integrity: sha512-ihePWrlsSfCz1sB6tkaRErw9w1f26uKncoVYu3EBjFhvuY0tOIOOcMS3649R/she8wPR/cP5n69t6C8BtjZAFA==}
+  '@ai-sdk/azure@3.0.55':
+    resolution: {integrity: sha512-60a9dmRz3s1mgcJeUTrrS/dr2vRXZaypipfLjEW41gdw6Za//Pa2BMEpG+5QSBYDWIZrOdtvvy7yjbBMVqG7wg==}
     engines: {node: '>=18'}
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
 
-  '@ai-sdk/cohere@3.0.22':
-    resolution: {integrity: sha512-D4TU80rLUD+9eiOd035WMSsQuDBa8/AOcU4NpETfZ7SHZdgGl1WI4EKZAuqAjCfPGgor/QiY+oC1R+ReHFzGQw==}
+  '@ai-sdk/cohere@3.0.31':
+    resolution: {integrity: sha512-PvVW9PVXjDjR8lCLLe1N7gdT5LZGNKbJJ1PiHED22++R8qnlDd42l2cSfJeOmf1UtbQFnMTCVAh9s1de3mCv8A==}
     engines: {node: '>=18'}
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
 
-  '@ai-sdk/deepseek@2.0.21':
-    resolution: {integrity: sha512-swIljtTiEBt5fTmnHftb20MnM06eBEANJzEYAUvU1m3yQH+HcduHxwVMLUtf9M7RqpTrBrAJxLtHHP5kPIVSCQ==}
+  '@ai-sdk/deepseek@2.0.30':
+    resolution: {integrity: sha512-ATqXxA0u2h201mrtr8KYp6hJGKbnorby9gti/Jgk5m9A3HzWpnw2AjO0uFHTRkhHonhoZD6QH/WyIEQGKDtmIg==}
     engines: {node: '>=18'}
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
 
-  '@ai-sdk/gateway@3.0.59':
-    resolution: {integrity: sha512-MbtheWHgEFV/8HL1Z6E3hOAsmP73zZlNFg0F0nJAD0Adnjp4J/plqNK00Y896d+dWTw+r0OXzyov9/2wCFjH0Q==}
+  '@ai-sdk/gateway@3.0.105':
+    resolution: {integrity: sha512-XpERadvLMHkYGJO4hz1Sw7Y9J705Iex48TmdZLdZdaPiFFtVgiA9qhXugLUWGAxdlXU/2N6ipoPSOwfnULZbXw==}
     engines: {node: '>=18'}
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
 
-  '@ai-sdk/google@3.0.34':
-    resolution: {integrity: sha512-1tXUr1W5YACXPgtHYWIU3raqMsayp6cMI8NUT4EEzzZSpvHzkkiNWHEr+bGxEGurSUukfo+pE1RKpLwBFOZtJg==}
+  '@ai-sdk/google@3.0.65':
+    resolution: {integrity: sha512-SwdaJ6IqguyiVuDRgiRM4sHj7uUO4AETlQFFLF3jcEvu/3yrgIHfw2aM6bBNKSdalw0j25Pedx6qyHc2DWJwrg==}
     engines: {node: '>=18'}
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
 
-  '@ai-sdk/mistral@3.0.21':
-    resolution: {integrity: sha512-GhLRyfXghnKpt51t8ELU3cXwbCUcGOxZFUQFUZvNBt+y298PlOhaAK6pQtihfpNRGUycrdNotKwVajJm0a6uwg==}
+  '@ai-sdk/mistral@3.0.31':
+    resolution: {integrity: sha512-dwb+D7xlLNqxn2PSHe6jCgY0vrrJXdYfTShXjNQLr7o15XgtCuQ76ezXHFHdmkb8I2jdVGiuOe+68hwqMw7ZsA==}
     engines: {node: '>=18'}
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
 
-  '@ai-sdk/openai-compatible@2.0.31':
-    resolution: {integrity: sha512-e78xiImcTe2aCMQoFbVJluQmUV4XgahOmmehAuRPlcwzRv2KtkvuLCXPC9Xcy2u83e8SimVva9k9G8SvZcnaBA==}
+  '@ai-sdk/openai-compatible@2.0.42':
+    resolution: {integrity: sha512-hjq485U/dpi6Hvjzw5+F1vohCrB1kibGHlUFknYGa4nOoCnSvFM1lTXEIyTAkjK1uXgTbNk8vw66lbEyWT12jg==}
     engines: {node: '>=18'}
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
 
-  '@ai-sdk/openai@3.0.37':
-    resolution: {integrity: sha512-bcYjT3/58i/C0DN3AnrjiGsAb0kYivZLWWUtgTjsBurHSht/LTEy+w3dw5XQe3FmZwX7Z/mUQCiA3wB/5Kf7ow==}
+  '@ai-sdk/openai@3.0.54':
+    resolution: {integrity: sha512-j1qrNe/ebUKuE+fETzS+CVnczs11jQBR9y9M6aoKtJZAosg6SZnPC1Bb92e2u6yaSK+88TZoFhiY67uYphPitw==}
     engines: {node: '>=18'}
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
 
-  '@ai-sdk/provider-utils@4.0.16':
-    resolution: {integrity: sha512-kBvDqNkt5EwlzF9FujmNhhtl8FYg3e8FO8P5uneKliqfRThWemzBj+wfYr7ZCymAQhTRnwSSz1/SOqhOAwmx9g==}
+  '@ai-sdk/provider-utils@4.0.23':
+    resolution: {integrity: sha512-z8GlDaCmRSDlqkMF2f4/RFgWxdarvIbyuk+m6WXT1LYgsnGiXRJGTD2Z1+SDl3LqtFuRtGX1aghYvQLoHL/9pg==}
     engines: {node: '>=18'}
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
 
-  '@ai-sdk/provider-utils@4.0.5':
-    resolution: {integrity: sha512-Ow/X/SEkeExTTc1x+nYLB9ZHK2WUId8+9TlkamAx7Tl9vxU+cKzWx2dwjgMHeCN6twrgwkLrrtqckQeO4mxgVA==}
+  '@ai-sdk/provider-utils@4.0.24':
+    resolution: {integrity: sha512-oXIw1oLmuBILuvHgSj6w5LOV8oSnFRouPSv0MGkG9sRMeukZ9JnMF17kldaRQaRq8lSJIxo6aS3NzWlVmSb+4Q==}
     engines: {node: '>=18'}
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
 
-  '@ai-sdk/provider@3.0.2':
-    resolution: {integrity: sha512-HrEmNt/BH/hkQ7zpi2o6N3k1ZR1QTb7z85WYhYygiTxOQuaml4CMtHCWRbric5WPU+RNsYI7r1EpyVQMKO1pYw==}
-    engines: {node: '>=18'}
-
   '@ai-sdk/provider@3.0.8':
     resolution: {integrity: sha512-oGMAgGoQdBXbZqNG0Ze56CHjDZ1IDYOwGYxYjO5KLSlz5HiNQ9udIXsPZ61VWaHGZ5XW/jyjmr6t2xz2jGVwbQ==}
     engines: {node: '>=18'}
 
-  '@ai-sdk/togetherai@2.0.35':
-    resolution: {integrity: sha512-nTEYviZRpgx5R93E4HFcuUpkK4Cj6JxY+tDkqtC4MlGZfLG6gefrOMHb7CTwv6cLu+CEO6iSyd2uiIa0/pm0Eg==}
+  '@ai-sdk/provider@3.0.9':
+    resolution: {integrity: sha512-/ngMKqKdL9dSlY/eQ3NFDzzFyw0Hix+cbFFlyuKEKcOgpHdBt/spKUvX/i0wGrDLFPYJeVvv3N0j92LxWRL7yQ==}
+    engines: {node: '>=18'}
+
+  '@ai-sdk/togetherai@2.0.46':
+    resolution: {integrity: sha512-7SPR2HpFXkY6SFxkkMmwv9ZbPMvh7O5niHIxPXRWKABzSldYQ1AQ39Tq02e1TpHfz/Fj1+RMjB4lst59v3pklw==}
     engines: {node: '>=18'}
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
 
-  '@ai-sdk/xai@3.0.60':
-    resolution: {integrity: sha512-nDOUyzeepmyyoL5+9LxmwXy3BoX9mZy7cv3BjHPN4Xc+SVFVqL7uj/9m1oLRCNmpwfA/9QBq9kuD+J31EfdhMw==}
+  '@ai-sdk/xai@3.0.84':
+    resolution: {integrity: sha512-L9NIlV7iUpx+dLFAtHEeAexugr3zb6Y28zW8WLwaiDcs546VQCgY12toyGn9vJgFleL40J4JUU4J8Ev0XFZnxw==}
     engines: {node: '>=18'}
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
@@ -8058,8 +8061,8 @@ packages:
   '@one-ini/wasm@0.1.1':
     resolution: {integrity: sha512-XuySG1E38YScSJoMlqovLru4KTUNSjgVTIjyh7qMX6aNN5HY5Ct5LhRJdxO79JtTzKfzV/bnWpz+zquYrISsvw==}
 
-  '@openrouter/ai-sdk-provider@2.2.3':
-    resolution: {integrity: sha512-NovC+BaCfEeJwhToDrs8JeDYXXlJdEyz7lcxkjtyePSE4eoAKik872SyDK0MzXKcz8MRkv7XlNhPI6zz4TQp0g==}
+  '@openrouter/ai-sdk-provider@2.8.1':
+    resolution: {integrity: sha512-Y6j3yivgoEUf/kutD/k5GX/mzZfioRFoSx0gbQ+mIOzMaH/vJv1rCkztiuvlLw5xRYQil7oxHUZvmSfXqOx1NQ==}
     engines: {node: '>=18'}
     peerDependencies:
       ai: ^6.0.0
@@ -10553,10 +10556,6 @@ packages:
     resolution: {integrity: sha512-bNwBYYmN8Eh9RyjS1p2gW6MIhSO2rl7X9QeLM8iTdcGRP+eDiIWDt66c9IysCc22gefKszZv+ubV9qZc7hdESg==}
     engines: {node: '>=16.0.0'}
 
-  '@smithy/types@4.3.1':
-    resolution: {integrity: sha512-UqKOQBL2x6+HWl3P+3QqFD4ncKq0I8Nuz9QItGv5WuKuMHuuwlhvqcZCoXGfc+P1QmfJE7VieykoYYmrOoFJxA==}
-    engines: {node: '>=18.0.0'}
-
   '@smithy/types@4.3.2':
     resolution: {integrity: sha512-QO4zghLxiQ5W9UZmX2Lo0nta2PuE1sSrXUYDoaB6HMR762C0P7v/HEPHf6ZdglTVssJG1bsrSBxdc3quvDSihw==}
     engines: {node: '>=18.0.0'}
@@ -12184,8 +12183,8 @@ packages:
   '@univerjs/icons@0.1.87':
     resolution: {integrity: sha512-YSrFS+eBcwawuHbeTP+25E9SdNgkcyFvBWXJi0JAFUqStQGHTQtoGQRNFMgkKetJZqKCyg8h2dvyynYZIiwSaA==}
     peerDependencies:
-      react: '*'
-      react-dom: '*'
+      react: 18.3.1
+      react-dom: 18.3.1
 
   '@univerjs/network@0.3.0':
     resolution: {integrity: sha512-89qSapDKK7ZafFH56dG/JEn89C4luVFFrCRiiZMB/VQA+zjoCK0UdxqHTDuGkyLrayOT595jedMILgXfsQUoCg==}
@@ -12447,8 +12446,8 @@ packages:
     peerDependencies:
       valibot: ^1.1.0
 
-  '@vercel/oidc@3.1.0':
-    resolution: {integrity: sha512-Fw28YZpRnA3cAHHDlkt7xQHiJ0fcL+NRcIqsocZQUSmbzeIKRpwttJjik5ZGanXP+vlA4SbTg+AbA3bP363l+w==}
+  '@vercel/oidc@3.2.0':
+    resolution: {integrity: sha512-UycprH3T6n3jH0k44NHMa7pnFHGu/N05MjojYr+Mc6I7obkoLIJujSWwin1pCvdy/eOxrI/l3uDLQsmcrOb4ug==}
     engines: {node: '>= 20'}
 
   '@vitejs/plugin-react-swc@3.6.0':
@@ -12793,8 +12792,8 @@ packages:
     resolution: {integrity: sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==}
     engines: {node: '>=8'}
 
-  ai@6.0.105:
-    resolution: {integrity: sha512-rp+exWtZS3J0DDvZIfetpKCIg7D3cCsvBPoFN3I67IDTs9aoBZDbpecoIkmNLT+U9RBkoEial3OGHRvme23HCw==}
+  ai@6.0.169:
+    resolution: {integrity: sha512-eDAIc8bJJ3Ktk5qvBvWfAK7Uwj6zrOMI9VvQ6yLfF+7HdqnR0TSxgkLuIONrmowB2OujeAuVF9jalpNPJSN57g==}
     engines: {node: '>=18'}
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
@@ -15346,6 +15345,10 @@ packages:
     resolution: {integrity: sha512-Vo1ab+QXPzZ4tCa8SwIHJFaSzy4R6SHf7BY79rFBDf0idraZWAkYrDjDj8uWaSm3S2TK+hJ7/t1CEmZ7jXw+pg==}
     engines: {node: '>=18.0.0'}
 
+  eventsource-parser@3.0.8:
+    resolution: {integrity: sha512-70QWGkr4snxr0OXLRWsFLeRBIRPuQOvt4s8QYjmUlmlkyTZkRqS7EDVRZtzU3TiyDbXSzaOeF0XUKy8PchzukQ==}
+    engines: {node: '>=18.0.0'}
+
   eventsource@2.0.2:
     resolution: {integrity: sha512-IzUmBGPR3+oUG9dUeXynyNmf91/3zUSJg1lCktzKw47OXuhco54U3r9B7O4XX+Rb1Itm9OZ2b0RkTs10bICOxA==}
     engines: {node: '>=12.0.0'}
@@ -18283,6 +18286,7 @@ packages:
 
   nest-knexjs@0.0.22:
     resolution: {integrity: sha512-vS2ODayDRnd+2CkOdcfOTWdxuVpqRD8Px8k8AOEx/1Pxc6CT6sYhxsv6IN4M6L/ztegqJrXvuWGHPTYPmx53/A==}
+    deprecated: ⚠️ DEPRECATED - This package is no longer maintained. Please use the official knex package instead.
     peerDependencies:
       '@nestjs/common': ^7.0.0 || ^8.0.0 || ^9.0.0 || ^10.0.0
       '@nestjs/core': ^7.0.0 || ^8.0.0 || ^9.0.0 || ^10.0.0
@@ -18646,8 +18650,8 @@ packages:
   obug@2.1.1:
     resolution: {integrity: sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==}
 
-  ollama-ai-provider-v2@3.0.2:
-    resolution: {integrity: sha512-MCGlAl6ycgJ4lq2r5KestglluAidds7uYhtj2wcxxga6eMbJIvGXXE1fR18WpU+ook2Yur1EbjMJDJD3GMZpgA==}
+  ollama-ai-provider-v2@3.5.0:
+    resolution: {integrity: sha512-+s/aYIYa91z2Vk3AkGAz3BaPAQ0flS2eFZD3BN2mD/N6W6YQbcookyu6pc2cbc8SP5VGpNB857WJ0eHDjKXsXw==}
     engines: {node: '>=18'}
     peerDependencies:
       ai: ^5.0.0 || ^6.0.0
@@ -22567,7 +22571,7 @@ packages:
   use-sync-external-store@1.6.0:
     resolution: {integrity: sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==}
     peerDependencies:
-      react: 18.3.1
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
 
   use@3.1.1:
     resolution: {integrity: sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==}
@@ -23304,106 +23308,106 @@ snapshots:
 
   '@adobe/css-tools@4.4.1': {}
 
-  '@ai-sdk/amazon-bedrock@4.0.69(zod@4.1.8)':
+  '@ai-sdk/amazon-bedrock@4.0.97(zod@4.1.8)':
     dependencies:
-      '@ai-sdk/anthropic': 3.0.50(zod@4.1.8)
-      '@ai-sdk/provider': 3.0.8
-      '@ai-sdk/provider-utils': 4.0.16(zod@4.1.8)
+      '@ai-sdk/anthropic': 3.0.72(zod@4.1.8)
+      '@ai-sdk/provider': 3.0.9
+      '@ai-sdk/provider-utils': 4.0.24(zod@4.1.8)
       '@smithy/eventstream-codec': 4.0.5
       '@smithy/util-utf8': 4.0.0
       aws4fetch: 1.0.20
       zod: 4.1.8
 
-  '@ai-sdk/anthropic@3.0.50(zod@4.1.8)':
+  '@ai-sdk/anthropic@3.0.72(zod@4.1.8)':
     dependencies:
-      '@ai-sdk/provider': 3.0.8
-      '@ai-sdk/provider-utils': 4.0.16(zod@4.1.8)
+      '@ai-sdk/provider': 3.0.9
+      '@ai-sdk/provider-utils': 4.0.24(zod@4.1.8)
       zod: 4.1.8
 
-  '@ai-sdk/azure@3.0.38(zod@4.1.8)':
+  '@ai-sdk/azure@3.0.55(zod@4.1.8)':
     dependencies:
-      '@ai-sdk/openai': 3.0.37(zod@4.1.8)
-      '@ai-sdk/provider': 3.0.8
-      '@ai-sdk/provider-utils': 4.0.16(zod@4.1.8)
+      '@ai-sdk/openai': 3.0.54(zod@4.1.8)
+      '@ai-sdk/provider': 3.0.9
+      '@ai-sdk/provider-utils': 4.0.24(zod@4.1.8)
       zod: 4.1.8
 
-  '@ai-sdk/cohere@3.0.22(zod@4.1.8)':
+  '@ai-sdk/cohere@3.0.31(zod@4.1.8)':
     dependencies:
-      '@ai-sdk/provider': 3.0.8
-      '@ai-sdk/provider-utils': 4.0.16(zod@4.1.8)
+      '@ai-sdk/provider': 3.0.9
+      '@ai-sdk/provider-utils': 4.0.24(zod@4.1.8)
       zod: 4.1.8
 
-  '@ai-sdk/deepseek@2.0.21(zod@4.1.8)':
+  '@ai-sdk/deepseek@2.0.30(zod@4.1.8)':
     dependencies:
-      '@ai-sdk/provider': 3.0.8
-      '@ai-sdk/provider-utils': 4.0.16(zod@4.1.8)
+      '@ai-sdk/provider': 3.0.9
+      '@ai-sdk/provider-utils': 4.0.24(zod@4.1.8)
       zod: 4.1.8
 
-  '@ai-sdk/gateway@3.0.59(zod@4.1.8)':
+  '@ai-sdk/gateway@3.0.105(zod@4.1.8)':
     dependencies:
-      '@ai-sdk/provider': 3.0.8
-      '@ai-sdk/provider-utils': 4.0.16(zod@4.1.8)
-      '@vercel/oidc': 3.1.0
+      '@ai-sdk/provider': 3.0.9
+      '@ai-sdk/provider-utils': 4.0.24(zod@4.1.8)
+      '@vercel/oidc': 3.2.0
       zod: 4.1.8
 
-  '@ai-sdk/google@3.0.34(zod@4.1.8)':
+  '@ai-sdk/google@3.0.65(zod@4.1.8)':
     dependencies:
-      '@ai-sdk/provider': 3.0.8
-      '@ai-sdk/provider-utils': 4.0.16(zod@4.1.8)
+      '@ai-sdk/provider': 3.0.9
+      '@ai-sdk/provider-utils': 4.0.24(zod@4.1.8)
       zod: 4.1.8
 
-  '@ai-sdk/mistral@3.0.21(zod@4.1.8)':
+  '@ai-sdk/mistral@3.0.31(zod@4.1.8)':
     dependencies:
-      '@ai-sdk/provider': 3.0.8
-      '@ai-sdk/provider-utils': 4.0.16(zod@4.1.8)
+      '@ai-sdk/provider': 3.0.9
+      '@ai-sdk/provider-utils': 4.0.24(zod@4.1.8)
       zod: 4.1.8
 
-  '@ai-sdk/openai-compatible@2.0.31(zod@4.1.8)':
+  '@ai-sdk/openai-compatible@2.0.42(zod@4.1.8)':
     dependencies:
-      '@ai-sdk/provider': 3.0.8
-      '@ai-sdk/provider-utils': 4.0.16(zod@4.1.8)
+      '@ai-sdk/provider': 3.0.9
+      '@ai-sdk/provider-utils': 4.0.24(zod@4.1.8)
       zod: 4.1.8
 
-  '@ai-sdk/openai@3.0.37(zod@4.1.8)':
+  '@ai-sdk/openai@3.0.54(zod@4.1.8)':
     dependencies:
-      '@ai-sdk/provider': 3.0.8
-      '@ai-sdk/provider-utils': 4.0.16(zod@4.1.8)
+      '@ai-sdk/provider': 3.0.9
+      '@ai-sdk/provider-utils': 4.0.24(zod@4.1.8)
       zod: 4.1.8
 
-  '@ai-sdk/provider-utils@4.0.16(zod@4.1.8)':
+  '@ai-sdk/provider-utils@4.0.23(zod@4.1.8)':
     dependencies:
       '@ai-sdk/provider': 3.0.8
       '@standard-schema/spec': 1.1.0
       eventsource-parser: 3.0.6
       zod: 4.1.8
 
-  '@ai-sdk/provider-utils@4.0.5(zod@4.1.8)':
+  '@ai-sdk/provider-utils@4.0.24(zod@4.1.8)':
     dependencies:
-      '@ai-sdk/provider': 3.0.2
+      '@ai-sdk/provider': 3.0.9
       '@standard-schema/spec': 1.1.0
-      eventsource-parser: 3.0.6
+      eventsource-parser: 3.0.8
       zod: 4.1.8
 
-  '@ai-sdk/provider@3.0.2':
+  '@ai-sdk/provider@3.0.8':
     dependencies:
       json-schema: 0.4.0
 
-  '@ai-sdk/provider@3.0.8':
+  '@ai-sdk/provider@3.0.9':
     dependencies:
       json-schema: 0.4.0
 
-  '@ai-sdk/togetherai@2.0.35(zod@4.1.8)':
+  '@ai-sdk/togetherai@2.0.46(zod@4.1.8)':
     dependencies:
-      '@ai-sdk/openai-compatible': 2.0.31(zod@4.1.8)
-      '@ai-sdk/provider': 3.0.8
-      '@ai-sdk/provider-utils': 4.0.16(zod@4.1.8)
+      '@ai-sdk/openai-compatible': 2.0.42(zod@4.1.8)
+      '@ai-sdk/provider': 3.0.9
+      '@ai-sdk/provider-utils': 4.0.24(zod@4.1.8)
       zod: 4.1.8
 
-  '@ai-sdk/xai@3.0.60(zod@4.1.8)':
+  '@ai-sdk/xai@3.0.84(zod@4.1.8)':
     dependencies:
-      '@ai-sdk/openai-compatible': 2.0.31(zod@4.1.8)
-      '@ai-sdk/provider': 3.0.8
-      '@ai-sdk/provider-utils': 4.0.16(zod@4.1.8)
+      '@ai-sdk/openai-compatible': 2.0.42(zod@4.1.8)
+      '@ai-sdk/provider': 3.0.9
+      '@ai-sdk/provider-utils': 4.0.24(zod@4.1.8)
       zod: 4.1.8
 
   '@alloc/quick-lru@5.2.0': {}
@@ -24010,7 +24014,7 @@ snapshots:
 
   '@aws-sdk/types@3.840.0':
     dependencies:
-      '@smithy/types': 4.3.1
+      '@smithy/types': 4.3.2
       tslib: 2.8.1
 
   '@aws-sdk/util-arn-parser@3.568.0':
@@ -27556,9 +27560,9 @@ snapshots:
 
   '@one-ini/wasm@0.1.1': {}
 
-  '@openrouter/ai-sdk-provider@2.2.3(ai@6.0.105(zod@4.1.8))(zod@4.1.8)':
+  '@openrouter/ai-sdk-provider@2.8.1(ai@6.0.169(zod@4.1.8))(zod@4.1.8)':
     dependencies:
-      ai: 6.0.105(zod@4.1.8)
+      ai: 6.0.169(zod@4.1.8)
       zod: 4.1.8
 
   '@opentelemetry/api-logs@0.201.1':
@@ -30506,10 +30510,6 @@ snapshots:
     dependencies:
       tslib: 2.8.1
 
-  '@smithy/types@4.3.1':
-    dependencies:
-      tslib: 2.8.1
-
   '@smithy/types@4.3.2':
     dependencies:
       tslib: 2.8.1
@@ -33283,7 +33283,7 @@ snapshots:
     dependencies:
       valibot: 1.1.0(typescript@5.4.3)
 
-  '@vercel/oidc@3.1.0': {}
+  '@vercel/oidc@3.2.0': {}
 
   '@vitejs/plugin-react-swc@3.6.0(@swc/helpers@0.5.17)(vite@7.3.1(@types/node@22.18.0)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.37.0)(tsx@4.19.4)(yaml@2.6.1))':
     dependencies:
@@ -33773,11 +33773,11 @@ snapshots:
       clean-stack: 2.2.0
       indent-string: 4.0.0
 
-  ai@6.0.105(zod@4.1.8):
+  ai@6.0.169(zod@4.1.8):
     dependencies:
-      '@ai-sdk/gateway': 3.0.59(zod@4.1.8)
-      '@ai-sdk/provider': 3.0.8
-      '@ai-sdk/provider-utils': 4.0.16(zod@4.1.8)
+      '@ai-sdk/gateway': 3.0.105(zod@4.1.8)
+      '@ai-sdk/provider': 3.0.9
+      '@ai-sdk/provider-utils': 4.0.24(zod@4.1.8)
       '@opentelemetry/api': 1.9.0
       zod: 4.1.8
 
@@ -36569,7 +36569,7 @@ snapshots:
       debug: 4.4.0
       enhanced-resolve: 5.17.1
       eslint: 8.57.0
-      eslint-module-utils: 2.12.0(@typescript-eslint/parser@7.3.1(eslint@8.57.0)(typescript@5.4.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1)(eslint@8.57.0)
+      eslint-module-utils: 2.12.0(@typescript-eslint/parser@7.3.1(eslint@8.57.0)(typescript@5.4.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@7.3.1(eslint@8.57.0)(typescript@5.4.3))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.32.0(@typescript-eslint/parser@7.3.1(eslint@8.57.0)(typescript@5.4.3))(eslint@8.57.0))(eslint@8.57.0))(eslint@8.57.0)
       eslint-plugin-import: 2.32.0(@typescript-eslint/parser@7.3.1(eslint@8.57.0)(typescript@5.4.3))(eslint-import-resolver-typescript@3.6.1)(eslint@8.57.0)
       fast-glob: 3.3.2
       get-tsconfig: 4.7.3
@@ -36619,6 +36619,17 @@ snapshots:
       - bluebird
       - supports-color
 
+  eslint-module-utils@2.12.0(@typescript-eslint/parser@7.3.1(eslint@8.57.0)(typescript@5.4.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@7.3.1(eslint@8.57.0)(typescript@5.4.3))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.32.0(@typescript-eslint/parser@7.3.1(eslint@8.57.0)(typescript@5.4.3))(eslint@8.57.0))(eslint@8.57.0))(eslint@8.57.0):
+    dependencies:
+      debug: 3.2.7
+    optionalDependencies:
+      '@typescript-eslint/parser': 7.3.1(eslint@8.57.0)(typescript@5.4.3)
+      eslint: 8.57.0
+      eslint-import-resolver-node: 0.3.9
+      eslint-import-resolver-typescript: 3.6.1(@typescript-eslint/parser@7.3.1(eslint@8.57.0)(typescript@5.4.3))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.32.0(@typescript-eslint/parser@7.3.1(eslint@8.57.0)(typescript@5.4.3))(eslint@8.57.0))(eslint@8.57.0)
+    transitivePeerDependencies:
+      - supports-color
+
   eslint-module-utils@2.12.0(@typescript-eslint/parser@7.3.1(eslint@8.57.0)(typescript@5.4.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1)(eslint@8.57.0):
     dependencies:
       debug: 3.2.7
@@ -36630,7 +36641,7 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  eslint-module-utils@2.12.1(@typescript-eslint/parser@7.3.1(eslint@8.57.0)(typescript@5.4.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1)(eslint@8.57.0):
+  eslint-module-utils@2.12.1(@typescript-eslint/parser@7.3.1(eslint@8.57.0)(typescript@5.4.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@7.3.1(eslint@8.57.0)(typescript@5.4.3))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.32.0(@typescript-eslint/parser@7.3.1(eslint@8.57.0)(typescript@5.4.3))(eslint@8.57.0))(eslint@8.57.0))(eslint@8.57.0):
     dependencies:
       debug: 3.2.7
     optionalDependencies:
@@ -36679,7 +36690,7 @@ snapshots:
       doctrine: 2.1.0
       eslint: 8.57.0
       eslint-import-resolver-node: 0.3.9
-      eslint-module-utils: 2.12.1(@typescript-eslint/parser@7.3.1(eslint@8.57.0)(typescript@5.4.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1)(eslint@8.57.0)
+      eslint-module-utils: 2.12.1(@typescript-eslint/parser@7.3.1(eslint@8.57.0)(typescript@5.4.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@7.3.1(eslint@8.57.0)(typescript@5.4.3))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.32.0(@typescript-eslint/parser@7.3.1(eslint@8.57.0)(typescript@5.4.3))(eslint@8.57.0))(eslint@8.57.0))(eslint@8.57.0)
       hasown: 2.0.2
       is-core-module: 2.16.1
       is-glob: 4.0.3
@@ -37004,6 +37015,8 @@ snapshots:
 
   eventsource-parser@3.0.6: {}
 
+  eventsource-parser@3.0.8: {}
+
   eventsource@2.0.2: {}
 
   evp_bytestokey@1.0.3:
@@ -41291,11 +41304,11 @@ snapshots:
 
   obug@2.1.1: {}
 
-  ollama-ai-provider-v2@3.0.2(ai@6.0.105(zod@4.1.8))(zod@4.1.8):
+  ollama-ai-provider-v2@3.5.0(ai@6.0.169(zod@4.1.8))(zod@4.1.8):
     dependencies:
-      '@ai-sdk/provider': 3.0.2
-      '@ai-sdk/provider-utils': 4.0.5(zod@4.1.8)
-      ai: 6.0.105(zod@4.1.8)
+      '@ai-sdk/provider': 3.0.9
+      '@ai-sdk/provider-utils': 4.0.23(zod@4.1.8)
+      ai: 6.0.169(zod@4.1.8)
       zod: 4.1.8
 
   on-exit-leak-free@2.1.2: {}