fix(worker): bound flakyActivity's effective retry policy in the fixture

The activityOptionsByName override in activity-options.workflows.ts
shallow-replaces flakyActivity's contract-level retry block (by design,
to prove shallow merge doesn't inherit maximumAttempts from the layer
below) but supplied no maximumAttempts of its own, leaving the EFFECTIVE
policy Temporal actually runs with unbounded. A regression that broke
the "succeeds on retry" path would hang the test to its 120s timeout
instead of failing an assertion.

Add an explicit maximumAttempts: 2 to the override — exactly what the
"fails once, succeeds on retry" implementation needs — without
defeating the shallow-merge proof: the override's own bound (2) still
visibly wins over the contract-level one (1), it's just no longer
implicitly unbounded in between.

Also soften activity-options.contract.ts's doc comment, which asserted
from an informal, unreproduced probe that the time-skipping server skips
retry backoff delay. That claim doesn't matter to correctness anymore:
the explicit cap bounds retries regardless of backoff timing.

Author: btravers

packages/worker/src/__tests__/activity-options.contract.ts

@@ -92,18 +92,25 @@ const usesDefaultActivity = defineActivity({
  *   won), the override would never take effect.
  * - Overrides shallow-merge, they don't deep-merge into the layer below —
  *   the contract-level `retry` here caps `maximumAttempts` at 1. The
- *   workflow's override supplies a *different* `retry` field
- *   (`backoffCoefficient`) and says nothing about `maximumAttempts`. If the
- *   merge were deep (field-by-field), the lower layer's `maximumAttempts: 1`
- *   would survive inside the merged `retry` and the activity would be
- *   allowed exactly one attempt — permanently failing, since the
- *   implementation only succeeds on the second call. Because the real merge
- *   is shallow, the override's `retry` object replaces the contract-level
- *   one *wholesale*: `maximumAttempts` is gone, Temporal's own (unbounded)
- *   default applies, a second attempt happens, and the workflow completes.
- *   A scratch probe against the real time-skipping server confirmed this
- *   resolves in well under a second — server-side retry backoff is skipped
- *   the same way workflow timers are.
+ *   workflow's override (`activity-options.workflows.ts`) supplies its own
+ *   `retry` block (`backoffCoefficient` + an explicit `maximumAttempts: 2`)
+ *   rather than inheriting anything from this layer. If the merge were deep
+ *   (field-by-field), the lower layer's `maximumAttempts: 1` would survive
+ *   inside the merged `retry` and the activity would be allowed exactly one
+ *   attempt — permanently failing, since the implementation only succeeds on
+ *   the second call. Because the real merge is shallow, the override's
+ *   `retry` object replaces the contract-level one *wholesale*: this
+ *   layer's `maximumAttempts: 1` is gone, the override's own `2` applies
+ *   instead, a second attempt happens, and the workflow completes.
+ *
+ *   Whether the time-skipping server also skips retry BACKOFF DELAY the same
+ *   way it skips workflow timers is a claim this suite does not rely on —
+ *   an earlier version of this comment asserted it from an informal, un-
+ *   reproduced probe, which is not evidence this test's correctness should
+ *   depend on. The explicit `maximumAttempts: 2` on the override makes that
+ *   moot either way: retries are bounded regardless of backoff timing, so a
+ *   merge-precedence regression fails the assertion instead of hanging the
+ *   test to its timeout.
  */
 const flakyActivity = defineActivity({
   input: z.object({}),

packages/worker/src/__tests__/activity-options.workflows.ts

@@ -43,10 +43,17 @@ export const resolvesLayeredOptions = declareWorkflow({
   activityOptions: { startToCloseTimeout: "30 seconds", retry: { maximumAttempts: 1 } },
   // `flakyActivity`'s contract-level `activityOptions` caps retries at 1
   // attempt. This override replaces that `retry` block wholesale (shallow
-  // merge — it does not carry `maximumAttempts` forward), so retries are
-  // effectively unbounded again; see the doc comment on `flakyActivity` in
-  // the contract for the full argument.
-  activityOptionsByName: { flakyActivity: { retry: { backoffCoefficient: 1 } } },
+  // merge — it does not carry the lower layer's `maximumAttempts: 1`
+  // forward); see the doc comment on `flakyActivity` in the contract for the
+  // full argument. The override supplies its OWN `maximumAttempts: 2` rather
+  // than leaving it unset: `flakyActivity`'s implementation fails once then
+  // succeeds, so 2 attempts is exactly what the happy path needs, and capping
+  // it (instead of falling through to Temporal's unbounded default) turns a
+  // merge-precedence regression that broke the "succeeds on retry" path into
+  // a fast assertion failure instead of a 120s test-timeout hang.
+  activityOptionsByName: {
+    flakyActivity: { retry: { backoffCoefficient: 1, maximumAttempts: 2 } },
+  },
   implementation: async (context, args) => {
     const [contractTimeout, usesDefault, flaky, globalTimeout] = await Promise.all([
       context.activities.contractTimeoutActivity({ sleepMs: args.sleepMs }),