What worries me about this API design: It's gonna be very easy to use a listenable in the compute function and accidentally forget to include it in the listenable list...

You're absolutely right!! But although I think it might happen, I am not very worried about that.. It's a basic programming skill issue, not very related to the API signature.
Also, in some cases, you might not want to include all values ​​used in the computed callback in your listenable list, right?

But, what do you think we can do to improve it? Besides a clear documentation..

Maybe we can return the listenable list as a parameter in our callback, so it can reinforces the user to add the listenable to the list:

final ComputedNotifier<String> sum = ComputedNotifier<int>(
  <ValueListenable<int>>[a, b],
  (List<ValueListenable<dynamic>> list) => ((list.first.value as int) + (list[1].value as int)).toString(),
);

To be honest, I do not found this a good solution. Maybe because I don't see it as a ruge problem.

You made me intriguer about a solution for this... what do you think about write the API as this?

  final ValueNotifier<int> a = ValueNotifier<int>(1);
  final ValueNotifier<int> b = ValueNotifier<int>(2);

  final ComputedNotifier<int> sum = ComputedNotifier<int>(
      (ValueGetter getter) => getter(a) + getter(b),
  );

  int sumValue = sum.value;
  sum.addListener(() => sumValue = sum.value);

  a.value = 2;
  print(sumValue); // 4

  b.value = 3;
  print(sumValue); // 5