deepline 0.3.128 → 0.3.129

package/dist/bundling-sources/shared_libs/play-runtime/secret-redaction.ts

@@ -31,6 +31,23 @@ const SENSITIVE_FIELD_NAME_RE = new RegExp(
   `(^|[._-])(?:${SENSITIVE_FIELD_NAME})$`,
   'i',
 );
+
+// Receipt payloads repeat the same handful of field names once per row, so the
+// per-key verdict is memoized. The cap keeps a pathological payload of unique
+// keys from turning the cache into a leak.
+const SENSITIVE_FIELD_NAME_CACHE_MAX_ENTRIES = 4_096;
+const sensitiveFieldNameCache = new Map<string, boolean>();
+
+function isSensitiveFieldName(key: string): boolean {
+  const cached = sensitiveFieldNameCache.get(key);
+  if (cached !== undefined) return cached;
+  const sensitive = SENSITIVE_FIELD_NAME_RE.test(key);
+  if (sensitiveFieldNameCache.size >= SENSITIVE_FIELD_NAME_CACHE_MAX_ENTRIES) {
+    sensitiveFieldNameCache.clear();
+  }
+  sensitiveFieldNameCache.set(key, sensitive);
+  return sensitive;
+}
 const SERIALIZED_SECRET_FIELD_RE = new RegExp(
   `"(${SENSITIVE_FIELD_NAME})"\\s*:\\s*(?:"[^"\\\\]*"|\\{[^{}]*\\})`,
   'gi',
@@ -40,7 +57,61 @@ function escapeRegExp(value: string): string {
   return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
+/**
+ * Cheap superset gate for every rule `redactSecretLikeString` applies.
+ *
+ * Each rewrite above needs one of these markers to fire, so a string matching
+ * none of them is returned byte-identical by the full chain. Running one test
+ * instead of ten replaces is what makes receipt sanitization affordable: a
+ * 600 KiB provider result is thousands of strings, and almost none of them
+ * carry a credential.
+ *
+ * Extra matches only cost the full chain, while a missed marker would persist
+ * a live credential, so keep every entry looser than the rule it guards
+ * wherever JSON escaping or whitespace could hide one.
+ */
+const REDACTION_TRIGGER_RE = new RegExp(
+  [
+    // Sensitive field names, in object keys and in `name=`/`"name":` text.
+    'token',
+    'secret',
+    'password',
+    'authorization',
+    'cookie',
+    'credential',
+    // One `key` branch instead of `api[_-]?key`, `private[_-]?key` and `key_`.
+    // A regex alternation costs roughly one substring scan per branch, and a
+    // broader branch can only send more payloads down the exact path.
+    'key',
+    // Self-identifying credential prefixes.
+    'bearer',
+    'basic',
+    '-----BEGIN',
+    'xox[baprs]-',
+    '[prs]k_',
+    'pat_',
+    'ghp_',
+    // URL credentials: `//user:pass@host` userinfo and sensitive query params.
+    // The userinfo class excludes `/` exactly as the rule it guards does.
+    '//[^\\s/]{0,256}@',
+    '[?#&]sig',
+    // JWTs carry no keyword at all, so the shape itself is the marker. Anchor
+    // on the separating dot and drop JWT_RE's leading `{8,}` segment: a dot is
+    // rare enough for the engine to skip between candidates, which makes this
+    // gate roughly ten times cheaper than re-running JWT_RE itself, and
+    // dropping a required segment can only widen what it accepts.
+    '\\.[A-Za-z0-9_-]{1,16384}\\.[A-Za-z0-9_-]{8}',
+  ].join('|'),
+  'i',
+);
+
+/** True when any redaction rule could rewrite `value`. Never a false negative. */
+export function mightContainRedactableSecret(value: string): boolean {
+  return REDACTION_TRIGGER_RE.test(value);
+}
+
 export function redactSecretLikeString(value: string): string {
+  if (!mightContainRedactableSecret(value)) return value;
   const serializedRedacted = value.replace(
     SERIALIZED_SECRET_FIELD_RE,
     `"$1":"${SECRET_REDACTION_PLACEHOLDER}"`,
@@ -91,11 +162,39 @@ export function createSecretRedactionContext(
   initialValues: readonly string[] = [],
 ): SecretRedactionContext {
   const exactSecrets = new Set<string>();
+  // One compiled matcher per registered secret, built on first use. Rebuilding
+  // `new RegExp(escapeRegExp(secret))` for every string of every receipt was
+  // pure waste once a run registers more than a couple of credentials.
+  const exactSecretMatchers = new Map<
+    string,
+    { readonly literal: string; readonly matcher: RegExp }[]
+  >();
 
   function register(value: string): void {
     if (value.length > 0) exactSecrets.add(value);
   }
 
+  function matchersForSecret(
+    secret: string,
+  ): { readonly literal: string; readonly matcher: RegExp }[] {
+    const cached = exactSecretMatchers.get(secret);
+    if (cached) return cached;
+    const literals = [secret];
+    try {
+      const encoded = encodeURIComponent(secret);
+      if (encoded !== secret) literals.push(encoded);
+    } catch {
+      // encodeURIComponent only fails on malformed surrogate pairs. Exact
+      // redaction of the raw value still applies in that rare case.
+    }
+    const built = literals.map((literal) => ({
+      literal,
+      matcher: new RegExp(escapeRegExp(literal), 'g'),
+    }));
+    exactSecretMatchers.set(secret, built);
+    return built;
+  }
+
   for (const value of initialValues) register(value);
 
   function containsRegisteredSecret(
@@ -125,24 +224,20 @@ export function createSecretRedactionContext(
     return exactSecrets.has(value);
   }
 
+  /**
+   * Replace registered secrets in registration order, exactly as a per-secret
+   * replace chain would. `includes` is a native substring scan, so a value
+   * that carries no secret pays one scan per secret instead of compiling and
+   * running a fresh regex per secret.
+   */
   function redactRegisteredSecrets(value: string): string {
+    if (exactSecrets.size === 0) return value;
     let output = value;
     for (const secret of exactSecrets) {
-      output = output.replace(
-        new RegExp(escapeRegExp(secret), 'g'),
-        SECRET_REDACTION_PLACEHOLDER,
-      );
-      try {
-        const encoded = encodeURIComponent(secret);
-        if (encoded !== secret) {
-          output = output.replace(
-            new RegExp(escapeRegExp(encoded), 'g'),
-            SECRET_REDACTION_PLACEHOLDER,
-          );
-        }
-      } catch {
-        // encodeURIComponent only fails on malformed surrogate pairs. Exact
-        // redaction above still applies in that rare case.
+      for (const { literal, matcher } of matchersForSecret(secret)) {
+        if (!output.includes(literal)) continue;
+        matcher.lastIndex = 0;
+        output = output.replace(matcher, SECRET_REDACTION_PLACEHOLDER);
       }
     }
     return output;
@@ -153,17 +248,53 @@ export function createSecretRedactionContext(
     return redactSecretLikeString(output);
   }
 
+  /**
+   * Redact in place-preserving form: a plain object or array with nothing to
+   * redact is returned by reference instead of being rebuilt.
+   *
+   * This is what keeps receipt sanitization off the deep-clone path. A 600 KiB
+   * provider result almost never contains a credential, and cloning it only to
+   * re-serialize the identical value dominated gateway CPU.
+   *
+   * Non-plain objects (Date, Map, class instances) still go through the
+   * `Object.entries` rebuild, because collapsing them to plain objects is the
+   * long-standing persisted shape and changing it would rewrite stored data.
+   */
   function redact<T>(value: T): T {
     if (typeof value === 'string') return redactString(value) as T;
-    if (Array.isArray(value)) return value.map((entry) => redact(entry)) as T;
+    if (Array.isArray(value)) {
+      let changed = false;
+      const next = new Array(value.length);
+      for (let index = 0; index < value.length; index += 1) {
+        const entry = value[index];
+        const redacted = redact(entry);
+        next[index] = redacted;
+        if (redacted !== entry) changed = true;
+      }
+      return changed ? (next as T) : value;
+    }
     if (value && typeof value === 'object') {
+      const prototype = Object.getPrototypeOf(value);
+      // Only a plain object can be returned by reference; anything else must
+      // keep its historical projection to a plain object.
+      let changed = prototype !== Object.prototype && prototype !== null;
+      const source = value as Record<string, unknown>;
+      const keys = Object.keys(source);
+      const redactedValues = new Array<unknown>(keys.length);
+      for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index];
+        const entry = source[key];
+        const redacted = isSensitiveFieldName(key)
+          ? SECRET_REDACTION_PLACEHOLDER
+          : redact(entry);
+        redactedValues[index] = redacted;
+        if (redacted !== entry) changed = true;
+      }
+      if (!changed) return value;
+      // `Object.fromEntries` defines own properties, so a `__proto__` key stays
+      // data instead of reassigning the prototype of the rebuilt object.
       return Object.fromEntries(
-        Object.entries(value).map(([key, entry]) => [
-          key,
-          SENSITIVE_FIELD_NAME_RE.test(key)
-            ? SECRET_REDACTION_PLACEHOLDER
-            : redact(entry),
-        ]),
+        keys.map((key, index) => [key, redactedValues[index]]),
       ) as T;
     }
     return value;

package/dist/bundling-sources/shared_libs/play-runtime/tool-call/index.ts

@@ -20,6 +20,7 @@ export {
   type ToolCallReceiptCohortMember,
   type ToolCallReceiptCohortMemberState,
   type ToolCallReceiptCohortStore,
+  type ToolCallReceiptCohortTimings,
   type ToolCallReceiptRecord,
 } from './receipt-cohort';
 export {

package/dist/bundling-sources/shared_libs/play-runtime/tool-call/receipt-cohort.ts

@@ -20,10 +20,27 @@ export type ToolCallReceiptCohortMember = {
   waitMaxAttempts?: number;
 };
 
+/**
+ * One receipt's own durable outcome, reported as it settles rather than when
+ * the batch carrying it does.
+ */
+export type ToolCallReceiptCohortSettlement =
+  | { resultReceiptKey: string; status: 'stored' }
+  | { resultReceiptKey: string; status: 'failed'; error: unknown };
+
 export type ToolCallReceiptCohortStore = {
   read(input: {
     resultReceiptKeys: string[];
   }): Promise<ToolCallReceiptRecord[]>;
+  /**
+   * Publish these results to the completed-result cache.
+   *
+   * Deliberately returns nothing. A completed-result insert is immutable, so a
+   * caller that already executed keeps its own result whether or not it won
+   * the insert (see `flushPublications`). Materializing the stored rows here
+   * only bought a second deserialize-and-wrap of every result, inside the
+   * delivery interval a row is blocked on.
+   */
   complete(input: {
     ownerRunId: string;
     ownerAttempt: number;
@@ -32,7 +49,23 @@ export type ToolCallReceiptCohortStore = {
       lease: ToolCallReceiptLease;
       result: ToolExecuteResult;
     }>;
-  }): Promise<ToolCallReceiptRecord[]>;
+    /**
+     * Report each receipt the instant its OWN durable write settles.
+     *
+     * The cohort hands the store a coalesced wave, but the store batches by
+     * arrival underneath: two receipts of one wave can land in different
+     * batches, and the earlier one is durable a whole flight before the later
+     * one. Settling the wave together made every row in it wait for the last
+     * batch, so a store that can separate them calls this and each publication
+     * resolves on its own receipt.
+     *
+     * Optional. A store that cannot separate them simply resolves or rejects
+     * the returned promise, and every receipt it did not report settles at
+     * that point — successfully when the promise resolves, with its error
+     * when it rejects.
+     */
+    onReceiptSettled?(settlement: ToolCallReceiptCohortSettlement): void;
+  }): Promise<void>;
 };
 
 export type ToolCallReceiptCohortMemberState =
@@ -70,6 +103,21 @@ export type ToolCallReceiptCohort = {
   settle(): Promise<void>;
 };
 
+/**
+ * Measurement stamp for the end of a publication, which is otherwise invisible
+ * from outside: a coalesced `store.complete` settles here, and only the cohort
+ * knows which members it carried. A caller uses it to open its own `write
+ * settled -> row resumed` interval. Stamps only: nothing here is read by the
+ * cohort, and it fires on a failed write too, so the interval it opens is
+ * closed on both outcomes.
+ */
+export type ToolCallReceiptCohortTimings = {
+  onCompleteSettled?(input: {
+    memberIds: readonly string[];
+    atMs: number;
+  }): void;
+};
+
 export type ToolCallReceiptCohortJob = {
   acquire(input: {
     owner: { runId: string; attempt: number };
@@ -86,6 +134,7 @@ export type ToolCallReceiptCohortJob = {
  */
 export function createToolCallReceiptCohortJob(input: {
   store: ToolCallReceiptCohortStore;
+  timings?: ToolCallReceiptCohortTimings;
 }): ToolCallReceiptCohortJob {
   return {
     async acquire({ owner, members }) {
@@ -102,12 +151,20 @@ export function createToolCallReceiptCohortJob(input: {
       }
 
       const groups = groupMembers(members);
+      // A forced member deliberately discards any completed cache value and
+      // executes a fresh provider operation. Reading it first is not merely
+      // redundant: a large persisted result is fully hydrated and wrapped
+      // before the force branch below ignores it. Keep completed-result cache
+      // reads scoped to groups that can actually consume their values. This
+      // also leaves a mixed group correct: `groupMembers` marks it forced when
+      // any duplicate member explicitly requires fresh execution.
+      const cacheReadKeys = [...groups.values()]
+        .filter((group) => !group.force)
+        .map((group) => group.resultReceiptKey);
       const records = byKey(
-        await input.store.read({
-          resultReceiptKeys: [...groups.values()].map(
-            (group) => group.resultReceiptKey,
-          ),
-        }),
+        cacheReadKeys.length > 0
+          ? await input.store.read({ resultReceiptKeys: cacheReadKeys })
+          : [],
       );
       const states = new Map<string, ToolCallReceiptCohortMemberState>();
       const deferred = new Map<string, Deferred<ToolExecuteResult>>();
@@ -168,49 +225,128 @@ export function createToolCallReceiptCohortJob(input: {
         publicationFlushScheduled = false;
         const pending = pendingPublications.splice(0);
         if (pending.length === 0) return;
+        // Which receipts each publication is waiting on, resolved before the
+        // write so a publication can be settled the moment ITS receipts are
+        // durable rather than when the whole wave is. A lease lost between the
+        // queue and this flush is a pre-write fault of the wave, so it still
+        // rejects every publication in it.
+        const claims: PublicationClaim[] = [];
+        const requestedByKey = new Map<string, RequestedReceipt>();
         try {
-          const requested = ownedEntries(
-            pending.flatMap((publication) => publication.entries),
-            states,
-            owned,
-          );
-          const persisted = byKey(
-            await input.store.complete({
-              ownerRunId,
-              ownerAttempt: owner.attempt,
-              receipts: requested.map(({ group, lease, result }) => ({
-                resultReceiptKey: group.resultReceiptKey,
-                lease,
-                result,
-              })),
-            }),
-          );
-          const results = new Map<string, ToolExecuteResult>();
-          for (const entry of requested) {
-            // A completed-result insert is immutable: another independent
-            // cold miss may have published first. That does not retroactively
-            // turn this caller into a cache follower. It already executed, so
-            // return its own result and use the persisted entry only for later
-            // cache reads.
-            const result = entry.result;
-            owned.delete(entry.group.resultReceiptKey);
-            resolveGroup(entry.group, result);
-            for (const member of entry.group.members) {
-              results.set(member.memberId, result);
+          for (const publication of pending) {
+            const entries = ownedEntries(publication.entries, states, owned);
+            for (const entry of entries) {
+              const key = entry.group.resultReceiptKey;
+              if (!requestedByKey.has(key)) requestedByKey.set(key, entry);
             }
+            claims.push({
+              publication,
+              resultReceiptKeys: entries.map(
+                (entry) => entry.group.resultReceiptKey,
+              ),
+              settled: false,
+            });
           }
-          for (const publication of pending) {
-            publication.resolve(
+        } catch (error) {
+          for (const publication of pending) publication.reject(error);
+          return;
+        }
+        const requested = [...requestedByKey.values()];
+        const settledByKey = new Map<string, ReceiptSettlement>();
+        const results = new Map<string, ToolExecuteResult>();
+
+        const settleReadyClaims = () => {
+          for (const claim of claims) {
+            if (claim.settled) continue;
+            const settlements = claim.resultReceiptKeys.map((key) =>
+              settledByKey.get(key),
+            );
+            if (settlements.some((settlement) => settlement === undefined)) {
+              continue;
+            }
+            claim.settled = true;
+            const failed = settlements.find(
+              (settlement) => settlement?.failed === true,
+            );
+            if (failed) {
+              // Only this publication: a receipt that failed to persist says
+              // nothing about the other receipts of the same wave.
+              claim.publication.reject(failed.error);
+              continue;
+            }
+            claim.publication.resolve(
               new Map(
-                publication.entries.flatMap((entry) => {
+                claim.publication.entries.flatMap((entry) => {
                   const result = results.get(entry.memberId);
                   return result ? [[entry.memberId, result] as const] : [];
                 }),
               ),
             );
           }
+        };
+
+        const settleReceipt = (
+          resultReceiptKey: string,
+          settlement: ReceiptSettlement,
+        ) => {
+          if (settledByKey.has(resultReceiptKey)) return;
+          const entry = requestedByKey.get(resultReceiptKey);
+          if (!entry) return;
+          settledByKey.set(resultReceiptKey, settlement);
+          // Per receipt, not per wave: the interval a caller opens here is
+          // "this row's write settled -> this row resumed", and stamping it
+          // when the last receipt of the wave landed charged an earlier row
+          // for a later row's flight. Still stamped on failure too, so the
+          // interval it opens is closed on both outcomes.
+          input.timings?.onCompleteSettled?.({
+            memberIds: entry.group.members.map((member) => member.memberId),
+            atMs: Date.now(),
+          });
+          if (!settlement.failed) {
+            // A completed-result insert is immutable: another independent
+            // cold miss may have published first. That does not retroactively
+            // turn this caller into a cache follower. It already executed, so
+            // it returns its own result, and the stored row matters only to a
+            // later cache read.
+            owned.delete(resultReceiptKey);
+            resolveGroup(entry.group, entry.result);
+            for (const member of entry.group.members) {
+              results.set(member.memberId, entry.result);
+            }
+          }
+          settleReadyClaims();
+        };
+
+        try {
+          await input.store.complete({
+            ownerRunId,
+            ownerAttempt: owner.attempt,
+            receipts: requested.map(({ group, lease, result }) => ({
+              resultReceiptKey: group.resultReceiptKey,
+              lease,
+              result,
+            })),
+            onReceiptSettled: (settlement) =>
+              settleReceipt(
+                settlement.resultReceiptKey,
+                settlement.status === 'failed'
+                  ? { failed: true, error: settlement.error }
+                  : { failed: false, error: undefined },
+              ),
+          });
+          for (const entry of requested) {
+            settleReceipt(entry.group.resultReceiptKey, {
+              failed: false,
+              error: undefined,
+            });
+          }
         } catch (error) {
-          for (const publication of pending) publication.reject(error);
+          for (const entry of requested) {
+            settleReceipt(entry.group.resultReceiptKey, {
+              failed: true,
+              error,
+            });
+          }
         }
       };
 
@@ -353,6 +489,20 @@ type PendingPublication = {
   reject(error: unknown): void;
 };
 
+type RequestedReceipt = {
+  memberId: string;
+  result: ToolExecuteResult;
+} & OwnedGroup;
+
+/** One queued publication and the receipts it is waiting to become durable. */
+type PublicationClaim = {
+  publication: PendingPublication;
+  resultReceiptKeys: string[];
+  settled: boolean;
+};
+
+type ReceiptSettlement = { failed: boolean; error: unknown };
+
 function groupMembers(
   members: ToolCallReceiptCohortMember[],
 ): Map<string, Group> {

package/dist/bundling-sources/shared_libs/play-runtime/tool-call/runtime-step-receipts-adapter.ts

@@ -424,23 +424,38 @@ export function createRuntimeStepToolResultReceipts(
         if (record.force || !input.store.enabled) {
           return { kind: 'stored', result: candidate.result };
         }
-        const persisted = await hydrate(
-          async () =>
-            await input.store.complete(
-              record.resultReceiptKey,
-              ownerRunId,
-              serializeToolExecuteResult(candidate.result),
-              COMPLETED_RECEIPT_CACHE_INSERT_LEASE_ID,
-            ),
+        // A completion is a write, not a read. The bounded hydration window
+        // exists to cap how many stored payloads expand at once; holding one
+        // of its slots across this gateway round trip only queued unrelated
+        // rows behind this row's write, so the mutation runs outside it.
+        const persisted = await input.store.complete(
+          record.resultReceiptKey,
+          ownerRunId,
+          serializeToolExecuteResult(candidate.result),
+          COMPLETED_RECEIPT_CACHE_INSERT_LEASE_ID,
         );
-        // Completion transports may acknowledge only status/ownership. The
-        // durable row already has the full serialized result, so read it back
-        // below instead of mistaking an intentionally compact reply for a
-        // malformed completed receipt.
+        // Completion transports may acknowledge only status/ownership. A
+        // compact acknowledgement that says this insert won is complete
+        // information: the immutable stored result is the one just written, so
+        // the caller's own result is it. Nothing is read back and nothing
+        // hydrates.
+        if (
+          (persisted?.status === 'completed' ||
+            persisted?.status === 'skipped') &&
+          persisted.output === undefined &&
+          persisted.completionDisposition === 'persisted'
+        ) {
+          return { kind: 'stored', result: candidate.result };
+        }
+        // Anything else — a concurrent winner, or a gateway too old to say who
+        // won — really does need the durable row, so it decodes under the gate
+        // or is read back below.
         const result =
           persisted?.output === undefined
             ? null
-            : completedResult(persisted, record.resultReceiptKey);
+            : await hydrate(async () =>
+                completedResult(persisted, record.resultReceiptKey),
+              );
         if (result) {
           await input.onStored?.({
             result,

package/dist/bundling-sources/shared_libs/play-runtime/tool-execute-retry-policy.ts

@@ -50,6 +50,45 @@ export const TOOL_EXECUTE_GATEWAY_INVOCATION_IN_PROGRESS_CODE =
   'GATEWAY_INVOCATION_IN_PROGRESS';
 export const TOOL_EXECUTE_GATEWAY_INVOCATION_IN_PROGRESS_MAX_ATTEMPTS = 65;
 
+/**
+ * Runner-to-gateway capability advertisement. A runner sends the outcomes it
+ * can absorb; a gateway may only emit an outcome the caller in front of it
+ * understands. This exists because the runner ships inside a Play artifact, so
+ * a gateway is always talking to a mixture of runner generations and can never
+ * infer the caller's behavior from its own deploy.
+ */
+export const TOOL_EXECUTE_RUNNER_ACCEPTS_HEADER = 'x-deepline-runner-accepts';
+/**
+ * "I will pace on a Deepline concurrency shed instead of failing the row."
+ * Only a runner whose retry gate admits `concurrency_backpressure` for every
+ * tool — not just a transient-HTTP-safe or read-only one — may advertise this.
+ */
+export const TOOL_EXECUTE_RUNNER_ACCEPTS_CONCURRENCY_BACKPRESSURE =
+  'concurrency-backpressure';
+
+/** The capability tokens this runner build advertises on provider execute. */
+export const TOOL_EXECUTE_RUNNER_ACCEPTS_VALUE =
+  TOOL_EXECUTE_RUNNER_ACCEPTS_CONCURRENCY_BACKPRESSURE;
+
+/**
+ * Parse the advertisement as a comma-separated token list so a later runner can
+ * add a capability without a second header. An absent or unparsable value means
+ * "assume nothing": the gateway falls back to the behavior that is safe for the
+ * oldest deployed artifact.
+ */
+export function runnerAcceptsConcurrencyBackpressure(
+  headerValue: string | null | undefined,
+): boolean {
+  if (typeof headerValue !== 'string') return false;
+  return headerValue
+    .split(',')
+    .some(
+      (token) =>
+        token.trim().toLowerCase() ===
+        TOOL_EXECUTE_RUNNER_ACCEPTS_CONCURRENCY_BACKPRESSURE,
+    );
+}
+
 export class ToolExecuteAuthScopeChangedError extends Error {
   readonly code = TOOL_EXECUTE_AUTH_SCOPE_CHANGED_CODE;
   readonly status = 409;
@@ -503,6 +542,10 @@ export function classifyToolExecuteHttpFailure(input: {
       retryDecision.reason !== 'gateway_invocation_in_progress' &&
       retryDecision.reason !== 'concurrency_backpressure' &&
       retryDecision.reason !== 'runtime_scheduler_capacity',
-    knownNotDispatched: runtimeSchedulerCapacity,
+    // Scheduler capacity and the relay's explicit concurrency shed both occur
+    // before a provider request is dispatched. Carry that proof in the shared
+    // classification so the retry boundary can safely pace either response
+    // without asking a non-idempotent provider call to be replayed.
+    knownNotDispatched: runtimeSchedulerCapacity || concurrencyBackpressure,
   };
 }