Repeated Grouped Digit Sum

You are given a non-negative integer number represented as a string of digits and a positive integer k. Repeatedly perform the following algorithm:
If the length of number is at most k, stop.
Split number from left to right into groups of k digits. The final group may contain fewer than k digits.
Compute the sum of the digits in each group and concatenate the decimal representations of those sums in the same order.
Replace number with the concatenated result and return to step 1.
Return the resulting string number when the algorithm stops. It is guaranteed that the algorithm eventually terminates.
A solution with time complexity no worse than O(number.length * NUMBER_OF_STEPS) fits within the execution time limit.

Function
repeatedGroupedDigitSum(number: String, k: int) → String

Examples
Example 1
number = "11111222322"
k = 3
return = "144"
Split 11111222322 into 111, 112, 223, and 22. Their digit sums are 3, 4, 7, and 4, producing 3474.
Split 3474 into 347 and 4. Their digit sums are 14 and 4, producing 144.
The length of 144 is 3, which is at most k, so return 144.

The trick is that there isn't one. Write a while loop that runs as long as len(number) > k. Inside, step through the string in strides of k, slice number[i:i+k], sum the int value of each character, and append str(sum) to a list. Join the list and assign it back to number. The final slice is shorter than k, and Python slicing handles that for free. The pitfall is the one above: summing groups and appending a digit, or adding the sums numerically instead of concatenating them. Example 1 shows it: 14 and 4 become 144, not 18. Also don't convert the whole string to an int. Keep it as a string the whole way. The stated bound is O(length * steps), and the string shrinks quickly, so the simple loop fits. If you freeze on the slicing or the loop condition during the live OA, StealthCoder can hand you the working version.

The honest play: practice the pattern, and have StealthCoder ready for the one you didn't see coming.