@@ -19,6 +19,12 @@ var (
 	_ advisor.Advisor = (*StatementPriorBackupCheckAdvisor)(nil)
 )
 
+// maxMixedDMLCount must stay in sync with the backup transformer's
+// constant at backend/plugin/parser/tidb/backup.go:23. The advisor's
+// count-cap gate (Codex-fix-1g) uses the same threshold to predict
+// transformer behavior at pre-execution time.
+const maxMixedDMLCount = 5
+
 func init() {
 	advisor.Register(storepb.Engine_TIDB, storepb.SQLReviewRule_BUILTIN_PRIOR_BACKUP_CHECK, &StatementPriorBackupCheckAdvisor{})
 }
@@ -229,6 +235,37 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx adv
 		}
 	}
 
+	// Cumulative #30 Codex-fix-1g: count-cap with multi-table gate.
+	// The backup transformer at backend/plugin/parser/tidb/backup.go:
+	// 96-110 routes > maxMixedDMLCount DML statements into
+	// generateSQLForSingleTable which errors on multi-table inputs
+	// ("prior backup cannot handle statements on different tables
+	// more than 5"). My reshape (cumulative #30) dropped this gate
+	// under the "modernize-away-pre-omni-logic" framing — but the
+	// transformer constraint is current, not legacy. Reinstating
+	// the count gate prevents the advisor from approving inputs
+	// that the transformer rejects at runtime.
+	//
+	// Single-table batches above the threshold are intentionally
+	// allowed — the transformer's generateSQLForSingleTable
+	// successfully handles them.
+	if len(dmlRefs) > maxMixedDMLCount {
+		distinctDMLTables := make(map[string]struct{})
+		for _, ref := range dmlRefs {
+			distinctKey := strings.ToLower(ref.table.database) + "." + strings.ToLower(ref.table.table)
+			distinctDMLTables[distinctKey] = struct{}{}
+		}
+		if len(distinctDMLTables) > 1 {
+			adviceList = append(adviceList, &storepb.Advice{
+				Status:        level,
+				Title:         title,
+				Content:       fmt.Sprintf("Prior backup cannot handle more than %d DML statements across different tables", maxMixedDMLCount),
+				Code:          code.BuiltinPriorBackupCheck.Int32(),
+				StartPosition: nil,
+			})
+		}
+	}
+
 	return adviceList, nil
 }
 
 
@@ -268,6 +268,45 @@ func TestTiDBPriorBackupCheckAdvisor(t *testing.T) {
 				"db1.tech_book",
 			},
 		},
+		{
+			// Cumulative #30 Codex-fix-1g: count-cap with multi-table
+			// gate. The backup transformer at parser/tidb/backup.go:
+			// 96-110 routes >5 DML statements into single-table-only
+			// path which errors on multi-table inputs. The advisor
+			// must catch this pre-execution.
+			//
+			// 6 UPDATEs across two tables (tech_book × 3 + orders × 3)
+			// → must fire "more than 5 DML statements across different
+			// tables".
+			name: "6+ DML across multiple tables fires count-cap (Codex-fix-1g)",
+			statement: "UPDATE tech_book SET id = 1 WHERE id = 1;\n" +
+				"UPDATE tech_book SET id = 2 WHERE id = 2;\n" +
+				"UPDATE tech_book SET id = 3 WHERE id = 3;\n" +
+				"UPDATE orders SET order_id = 4 WHERE order_id = 4;\n" +
+				"UPDATE orders SET order_id = 5 WHERE order_id = 5;\n" +
+				"UPDATE orders SET order_id = 6 WHERE order_id = 6;",
+			backupDBPresent: true,
+			wantContentSubstr: []string{
+				"more than 5 DML statements across different tables",
+			},
+		},
+		{
+			// Cumulative #30 Codex-fix-1g: single-table batches >5
+			// are still OK — the transformer's
+			// generateSQLForSingleTable handles them successfully.
+			// 6 UPDATEs on tech_book only → no count-cap advice.
+			name: "6+ DML on single table — no count-cap advice (Codex-fix-1g)",
+			statement: "UPDATE tech_book SET id = 1 WHERE id = 1;\n" +
+				"UPDATE tech_book SET id = 2 WHERE id = 2;\n" +
+				"UPDATE tech_book SET id = 3 WHERE id = 3;\n" +
+				"UPDATE tech_book SET id = 4 WHERE id = 4;\n" +
+				"UPDATE tech_book SET id = 5 WHERE id = 5;\n" +
+				"UPDATE tech_book SET id = 6 WHERE id = 6;",
+			backupDBPresent: true,
+			wantNoneSubstr: []string{
+				"more than 5 DML statements",
+			},
+		},
 		{
 			// Cumulative #30 Codex-fix-1f: Tier-4-deferred DDL
 			// (CREATE/ALTER/DROP SEQUENCE) is omni-rejected at