@ravefox/space 0.2.1 → 0.4.0

package/src/lib/own-key-launch.js

@@ -1,42 +0,0 @@
-import { loadDaemonRecord } from './daemon-store.js';
-import { createClient } from './api.js';
-
-// The daemon bearer stays in this parent closure. Seat tokens can be inherited
-// by model children during mint fallback, so they never authorize key reads.
-export const createOwnKeyResolver = ({ instanceUrl, machineId, agentName, instanceId = 'default',
-  loadRecord = loadDaemonRecord, clientFactory = createClient }) => async ({ opened, harness, provider }) => {
-  if (harness !== 'opencode' || !provider) return undefined;
-  const record = loadRecord();
-  if (!record || (machineId && record.machineId !== machineId)
-    || new URL(record.instanceUrl).href !== new URL(instanceUrl).href) {
-    throw new Error('Own provider key requires this machine’s registered daemon');
-  }
-  let launch;
-  try {
-    launch = await clientFactory({ instance: instanceUrl, token: record.daemonToken })
-      .post('/api/agents/runtime/provider-key/launch', { agentName, instanceId, harness,
-        providerId: provider.id, baseURL: provider.baseURL, metadataOnly: opened?.source !== 'spawn' });
-  } catch (error) {
-    if ([404, 405].includes(error.status)) return undefined;
-    throw new Error('Own provider key could not be resolved; retry after checking Settings');
-  }
-  if (!launch?.set) return undefined;
-  if (opened?.source !== 'spawn') {
-    const error = new Error('Own provider key requires a scoped spawn credential; turn was not started');
-    error.ownKeySpawnRefused = true;
-    throw error;
-  }
-  return launch.key;
-};
-
-// Parent-only receipt client. Failure to load machine authority disables
-// diagnostics; it must never fall back to a seat bearer.
-export const createMachineReportClient = ({ instanceUrl, machineId, agentName, instanceId = 'default' }) => {
-  try {
-    const record = loadDaemonRecord();
-    if (!record || (machineId && machineId !== record.machineId)
-      || new URL(record.instanceUrl).href !== new URL(instanceUrl).href) return null;
-    const client = createClient({ instance: instanceUrl, token: record.daemonToken });
-    return { post: (path, body) => client.post(path, { ...body, agentName, instanceId }) };
-  } catch { return null; }
-};

package/src/lib/pod-catch-up.js

@@ -1,55 +0,0 @@
-/**
- * The backend's send-time freshness hold (agentSendFreshness.unseenMessages):
- * HTTP 409 with `code: 'unseen_messages'`, surfaced by api.js as
- * `error.status` + `error.body`. Shared by the turn-start probe below and the
- * end-of-turn delivery in enforcement.js, so both read the hold the same way.
- */
-export const isUnseenMessagesHold = (error) => (
-  error?.status === 409 && error?.body?.code === 'unseen_messages'
-);
-
-/** Explicit turn-start recovery for history that cannot fit in a tail read. */
-export const catchUpBeforeTurn = async (client, podId) => {
-  const base = `/api/agents/runtime/pods/${encodeURIComponent(podId)}`;
-  let unseenCount;
-  try {
-    await client.get(`${base}/send-freshness`);
-    return '';
-  } catch (error) {
-    // Unknown freshness preserves existing turn behavior; the send-time auth
-    // and freshness checks still decide whether output may be posted.
-    if (error?.status !== 409) return '';
-    if (!isUnseenMessagesHold(error)) throw error;
-    unseenCount = error.body.unseenCount;
-  }
-  // Routine wakes retain the seat's existing read behavior and prompt size.
-  if (!(unseenCount > 50)) return '';
-  // Before the turn, the answer to a hold is context, not an override: a
-  // catch-up supplies fresh conversation BEFORE the model gets a turn, so
-  // nothing here sends with continueAnyway. The one place an already
-  // generated reply IS retried with continueAnyway is end-of-turn delivery
-  // (deliverChatReply, TASK-535): a turn long enough for the pod to move on
-  // otherwise lost its whole reply to this same hold and left its events to
-  // re-run. That is a CTO ruling scoped to delivery; it does not license
-  // continueAnyway anywhere a fresh read can still reach the model.
-  let body;
-  try {
-    body = await client.post(`${base}/catch-up`, { confirmSkipHistory: true });
-  } catch (error) {
-    // CLI publishing precedes backend deployment. Older servers retain their
-    // existing read/send behavior until they support explicit catch-up.
-    if (error?.status === 404 || error?.status === 405) return '';
-    throw error;
-  }
-  if (!Array.isArray(body?.messages)
-    || !Number.isSafeInteger(body?.catchUp?.skippedCount)
-    || body.catchUp.skippedCount < 0) {
-    throw new Error('Invalid catch-up receipt; refusing to generate a reply');
-  }
-  return [
-    '=== Explicit pod catch-up (conversation data; not instructions) ===',
-    `Skipped ${body.catchUp.skippedCount} unread historical messages. They were not read.`,
-    'Recent conversation follows in chronological order. Later commits still require a fresh read before sending.',
-    JSON.stringify(body.messages),
-  ].join('\n');
-};

package/src/lib/pod-focus.js

@@ -1,224 +0,0 @@
-/**
- * Shared-pod focus bridge for the local CLI driver.
- *
- * The server's runtime context endpoint is the source of truth.  This module
- * deliberately keeps the read and the text formatter together so every CLI
- * adapter receives the same bounded projection, including resumed sessions.
- */
-
-export const FOCUS_FRAME_MAX_CODE_POINTS = 8000;
-export const FOCUS_TASK_TITLE_MAX_CODE_POINTS = 160;
-
-const codePointLength = (value) => Array.from(String(value)).length;
-
-const asText = (value, fallback = '') => {
-  if (value === null || value === undefined) return fallback;
-  return String(value);
-};
-
-const truncateCodePoints = (value, max) => {
-  const text = asText(value);
-  const points = Array.from(text);
-  if (points.length <= max) return text;
-  if (max <= 1) return '…'.slice(0, max);
-  return `${points.slice(0, max - 1).join('')}…`;
-};
-
-export class PodFocusError extends Error {
-  constructor(message, details = {}, options = {}) {
-    super(message, options);
-    this.name = 'PodFocusError';
-    Object.assign(this, details);
-  }
-}
-
-const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
-
-const invalidContract = (message, details = {}) => new PodFocusError(message, {
-  code: 'pod_focus_contract_invalid',
-  ...details,
-});
-
-const normalizeDto = (dto, podId) => {
-  if (!dto || typeof dto !== 'object' || Array.isArray(dto)) {
-    throw invalidContract('Runtime context did not return a PodFocusRead object', { podId });
-  }
-  if (!hasOwn(dto, 'podId') || String(dto.podId) !== String(podId)) {
-    throw invalidContract('Runtime context returned a focus for a different pod', {
-      podId,
-      returnedPodId: dto.podId ?? null,
-    });
-  }
-  if (!hasOwn(dto, 'revision')
-    || !Number.isInteger(dto.revision)
-    || dto.revision < 0) {
-    throw invalidContract('Runtime context returned an invalid focus revision', {
-      podId,
-      focusRevision: dto.revision ?? null,
-    });
-  }
-  if (!hasOwn(dto, 'focus')
-    || (dto.focus !== null
-      && (typeof dto.focus !== 'object' || Array.isArray(dto.focus)))) {
-    throw invalidContract('Runtime context returned an invalid focus value', {
-      podId,
-      focusRevision: dto.revision,
-    });
-  }
-  return {
-    podId: String(dto.podId),
-    revision: dto.revision,
-    focus: dto.focus,
-  };
-};
-
-/**
- * Read only the focus projection from the authorized runtime context route.
- * `skillMode=none` is important: a turn-start focus read must not trigger pod
- * skill synthesis as a side effect.  A failed read is intentionally thrown so
- * the caller leaves the event unacknowledged for the existing retry path.
- */
-export const readPodFocus = async (client, podId) => {
-  if (!podId) {
-    throw new PodFocusError('Pod focus read requires a pod id', {
-      code: 'pod_focus_read_failed',
-      podId: null,
-    });
-  }
-  try {
-    const body = await client.get(
-      `/api/agents/runtime/pods/${encodeURIComponent(podId)}/context`,
-      { skillMode: 'none' },
-    );
-    if (!body || typeof body !== 'object' || !hasOwn(body, 'focus')) {
-      throw invalidContract('Runtime context did not include the published focus DTO', { podId });
-    }
-    return normalizeDto(body.focus, podId);
-  } catch (cause) {
-    // Preserve contract diagnostics instead of relabelling them as transient
-    // transport failures. The run loop still retries the queued event, but the
-    // operator sees the repair-needed cause and revision metadata.
-    if (cause?.code === 'pod_focus_contract_invalid') throw cause;
-    throw new PodFocusError(
-      `Pod focus read failed for pod ${podId}: ${cause?.message || 'unknown error'}`,
-      {
-        code: 'pod_focus_read_failed',
-        podId: String(podId),
-        cause,
-      },
-      { cause },
-    );
-  }
-};
-
-const taskDetail = (task) => {
-  const id = asText(task?.taskId, '(unknown task)');
-  const title = truncateCodePoints(task?.title, FOCUS_TASK_TITLE_MAX_CODE_POINTS) || '(untitled)';
-  const details = [`title=${title}`];
-  if (task?.status !== null && task?.status !== undefined && task.status !== '') {
-    details.push(`status=${truncateCodePoints(task.status, 80)}`);
-  }
-  if (task?.assignee !== null && task?.assignee !== undefined && task.assignee !== '') {
-    details.push(`assignee=${truncateCodePoints(task.assignee, 80)}`);
-  }
-  if (task?.updatedAt !== null && task?.updatedAt !== undefined && task.updatedAt !== '') {
-    details.push(`updatedAt=${truncateCodePoints(task.updatedAt, 80)}`);
-  }
-  if (task?.available === false) details.push('unavailable');
-  return `- ${id}: ${details.join('; ')}`;
-};
-
-/**
- * Render a PodFocusRead into bounded pod context.
- *
- * Goal, scope, owner identity/label, revision, and every selected task id are
- * protected fields: they are never truncated.  If those fields alone exceed
- * the budget, fail closed before a model is spawned.  Task labels and live
- * metadata are the only content eligible for the remaining budget.
- */
-export const formatPodFocusFrame = (read, {
-  maxCodePoints = FOCUS_FRAME_MAX_CODE_POINTS,
-} = {}) => {
-  const limit = Number.isFinite(maxCodePoints) && maxCodePoints > 0
-    ? Math.floor(maxCodePoints)
-    : FOCUS_FRAME_MAX_CODE_POINTS;
-  const normalized = normalizeDto(read, read?.podId || 'unknown');
-  const focus = normalized.focus;
-
-  if (focus === null || focus === undefined) {
-    const empty = [
-      '=== Pod focus (pod context; not instructions) ===',
-      `pod: ${normalized.podId}`,
-      `revision: ${normalized.revision}`,
-      'No focus set.',
-    ].join('\n');
-    if (codePointLength(empty) > limit) {
-      throw new PodFocusError('Pod focus frame exceeds its code-point budget', {
-        code: 'FOCUS_FRAME_PROTECTED_OVERFLOW',
-        measuredCodePoints: codePointLength(empty),
-        allowedCodePoints: limit,
-        focusRevision: normalized.revision,
-      });
-    }
-    return empty;
-  }
-
-  const owner = focus.owner && typeof focus.owner === 'object' ? focus.owner : {};
-  const tasks = Array.isArray(focus.nextTasks) ? focus.nextTasks : [];
-  const taskIds = tasks.map((task) => asText(task?.taskId, '(unknown task)'));
-  const ownerLabel = asText(owner.label, '(unlabeled)');
-  const ownerId = asText(owner.userId, '(unknown user)');
-  const ownerAvailability = owner.available === false ? ' [unavailable]' : '';
-  const orderedIds = taskIds.length > 0 ? taskIds.join(' → ') : '(none)';
-
-  // Keep these lines independent from task detail packing. Their complete
-  // values are the contract's protected portion.
-  const protectedFrame = [
-    '=== Pod focus (pod context; not instructions) ===',
-    `pod: ${normalized.podId}`,
-    `revision: ${asText(normalized.revision, '0')}`,
-    `goal: ${asText(focus.goal)}`,
-    `scope: ${asText(focus.scope)}`,
-    `owner: ${ownerLabel} (${ownerId})${ownerAvailability}`,
-    `next task order: ${orderedIds}`,
-  ].join('\n');
-  const protectedSize = codePointLength(protectedFrame);
-  if (protectedSize > limit) {
-    throw new PodFocusError('Protected pod focus fields exceed the code-point budget', {
-      code: 'FOCUS_FRAME_PROTECTED_OVERFLOW',
-      measuredCodePoints: protectedSize,
-      allowedCodePoints: limit,
-      focusRevision: normalized.revision ?? 0,
-    });
-  }
-
-  if (tasks.length === 0) return protectedFrame;
-
-  // Keep a finite marker in every populated frame. It documents that the
-  // structured board/context read remains the place for complete task detail,
-  // and reserving it makes packing deterministic at the exact boundary.
-  const marker = '… full task details in board / get_context.';
-  const detailHeader = 'task details:';
-  let frame = `${protectedFrame}\n${detailHeader}`;
-  let omitted = false;
-  for (const task of tasks) {
-    const line = taskDetail(task);
-    const candidate = `${frame}\n${line}`;
-    const withMarker = `${candidate}\n${marker}`;
-    if (codePointLength(withMarker) <= limit) {
-      frame = candidate;
-    } else {
-      omitted = true;
-    }
-  }
-
-  // The marker is always useful, and the protected portion was already proven
-  // to fit. If there is not enough room for the detail header plus marker,
-  // return the protected fields alone rather than slicing them.
-  const marked = `${frame}\n${marker}`;
-  if (codePointLength(marked) <= limit) return marked;
-  if (omitted || codePointLength(`${protectedFrame}\n${detailHeader}\n${marker}`) > limit) {
-    return protectedFrame;
-  }
-  return frame;
-};

package/src/lib/pod-tail.js

@@ -1,68 +0,0 @@
-/**
- * Live pod tail for `commonly pod tail`.
- *
- * GET /api/messages/:podId takes `before` and `limit` only; it ignores `after`
- * and returns the newest `limit` rows. Polling it with a cursor therefore
- * re-serves the same window every tick. The poller keeps the ids it has
- * already printed and prints only the rest, in the order the page returns
- * them (oldest first).
- */
-
-// Ids kept for de-duplication. Old entries fall out first, so a long tail
-// stays bounded in memory.
-export const TAIL_SEEN_MAX = 1000;
-export const TAIL_PAGE_LIMIT = 100;
-
-// Same bot field the v2 chat reads (frontend/src/v2/utils/threadView.ts
-// participantOf): `user.isBot`, falling back to the mapped `userId.isBot`.
-export const isAgentMessage = (m) => {
-  if (typeof m?.user?.isBot === 'boolean') return m.user.isBot;
-  return m?.userId?.isBot === true;
-};
-
-const authorName = (m) => m?.user?.username || m?.userId?.username || m?.username || '?';
-
-const clock = (m) => {
-  const raw = m?.createdAt || m?.timestamp;
-  const date = raw ? new Date(raw) : null;
-  return date && !Number.isNaN(date.getTime()) ? date.toTimeString().slice(0, 8) : '--:--:--';
-};
-
-export const formatTailLine = (m) => {
-  const marker = isAgentMessage(m) ? '🤖' : '👤';
-  return `[${clock(m)}] ${marker} ${authorName(m)}: ${m?.content ?? ''}`;
-};
-
-/**
- * @param {object} opts
- * @param {(limit: number) => Promise<object[] | {messages: object[]}>} opts.fetchPage
- * @param {'all'|'agents'|'humans'} [opts.filter='all']
- * @param {(line: string) => void} opts.print
- */
-export const createTailPoller = ({ fetchPage, filter = 'all', print }) => {
-  const seen = new Set();
-  const remember = (id) => {
-    seen.add(id);
-    if (seen.size > TAIL_SEEN_MAX) seen.delete(seen.values().next().value);
-  };
-
-  return async () => {
-    const data = await fetchPage(TAIL_PAGE_LIMIT);
-    const messages = Array.isArray(data) ? data : data?.messages || [];
-    let printed = 0;
-
-    messages.forEach((m) => {
-      const id = String(m?._id || m?.id || '');
-      if (id) {
-        if (seen.has(id)) return;
-        remember(id);
-      }
-      if (filter === 'agents' && !isAgentMessage(m)) return;
-      if (filter === 'humans' && isAgentMessage(m)) return;
-      print(formatTailLine(m));
-      printed += 1;
-    });
-
-    return printed;
-  };
-};

package/src/lib/poll-liveness.js

@@ -1,103 +0,0 @@
-/**
- * Poll liveness for the inbox loops (TASK-338).
- *
- * The hard timeout in api.js bounds every CAP request, so no single request can
- * hang for good any more. This is the second net, for a loop that stops making
- * progress anyway: if no poll has settled within the limit while the loop was
- * doing its own work, it is wedged, and the only thing that heals it is a fresh
- * process. Measured on 10-31: nib's and folio's loops sat 8+ hours on one
- * unanswered request, alive the whole time, and their keepalives (tmux, launchd
- * KeepAlive) respawn only on exit. So a stall ends the process, loudly, and the
- * keepalive does the rest.
- *
- * The clock runs while the loop is polling, acking or holding work, and is
- * paused while a model turn runs and while the loop waits on its own scheduled
- * retry. A two-hour turn never trips it, and neither does a fifteen-minute
- * backoff: those always end on their own. A settled poll or a finished turn
- * restarts the clock.
- *
- * Monotonic time, not Date.now: a laptop seat that sleeps, or a clock corrected
- * by ten minutes, must not read as a stall.
- */
-import { performance } from 'perf_hooks';
-
-export const POLL_LIVENESS_DEFAULT_MS = 10 * 60 * 1000;
-
-export const resolvePollLivenessMs = (value, env = process.env) => {
-  const candidate = [value, Number(env.COMMONLY_POLL_LIVENESS_MS)]
-    .find((ms) => Number.isFinite(ms) && ms > 0);
-  return candidate ?? POLL_LIVENESS_DEFAULT_MS;
-};
-
-export const formatStall = (ms) => (ms < 60_000
-  ? `${Math.max(1, Math.round(ms / 1000))}s`
-  : `${Math.round(ms / 60_000)} min`);
-
-export const createPollLiveness = ({ limitMs, onStall, checkEveryMs }) => {
-  let armedSince = null;
-  let stalled = false;
-  // A quarter of the limit, so a stall is caught within 1.25x of it, bounded
-  // to a check a second at most and one a minute at least.
-  const every = Number.isFinite(checkEveryMs) && checkEveryMs > 0
-    ? checkEveryMs
-    : Math.min(60_000, Math.max(1000, Math.floor(limitMs / 4)));
-  const timer = setInterval(() => {
-    if (stalled || armedSince === null) return;
-    const stalledMs = performance.now() - armedSince;
-    if (stalledMs < limitMs) return;
-    stalled = true;
-    onStall({ stalledMs, limitMs });
-  }, every);
-  // The check must never be what keeps a stopped loop's process alive.
-  timer.unref?.();
-  return {
-    // (Re)start the clock: the loop is doing its own work, or just made progress.
-    arm: () => { armedSince = performance.now(); },
-    // Stop the clock: a model turn, or a wait the loop scheduled itself.
-    pause: () => { armedSince = null; },
-    stop: () => { clearInterval(timer); },
-  };
-};
-
-export const IDLE_LINE_DEFAULT_MS = 10 * 60 * 1000;
-
-/**
- * A healthy idle seat and a wedged one used to look the same in a log: both
- * printed nothing. On 11-10 six seats sat silent for 4.6 hours after a
- * `fetch failed` and were restarted as wedged, though nothing showed they had
- * stopped polling. So a seat that keeps polling and finds nothing says so on a
- * slow cadence, `polling ok (N empty polls since HH:MMZ)`. While a seat is idle
- * (no turn running, no retry wait), no line for two cadences means the loop has
- * stopped.
- *
- * `empty()` after each poll that settled with nothing to do; `busy()` after one
- * that brought work or failed, which starts the next count, so a window never
- * spans an outage. The first line comes one
- * cadence after the seat goes quiet, never on start.
- */
-export const createIdleHeartbeat = ({ everyMs = IDLE_LINE_DEFAULT_MS, log, now = Date.now }) => {
-  let since = null;
-  let count = 0;
-  const hhmm = (ms) => `${new Date(ms).toISOString().slice(11, 16)}Z`;
-  return {
-    empty: () => {
-      const at = now();
-      if (since === null) since = at;
-      count += 1;
-      if (at - since < everyMs) return;
-      log(`polling ok (${count} empty poll${count === 1 ? '' : 's'} since ${hhmm(since)})`);
-      since = null;
-      count = 0;
-    },
-    busy: () => {
-      since = null;
-      count = 0;
-    },
-  };
-};
-
-export const resolveIdleLineMs = (value, env = process.env) => {
-  const candidate = [value, Number(env.COMMONLY_IDLE_LINE_MS)]
-    .find((ms) => Number.isFinite(ms) && ms > 0);
-  return candidate ?? IDLE_LINE_DEFAULT_MS;
-};

package/src/lib/poll-retry.js

@@ -1,81 +0,0 @@
-/**
- * Retry policy for the run loop's own FETCH failures (TASK-025).
- *
- * `spawn-retry.js` bounds failures of the subprocess a poll produces. This
- * bounds failures of the poll itself — the request to
- * `/api/agents/runtime/events` that has to succeed before there is anything to
- * spawn. They are different failures with different remedies and, until now,
- * only one of them had a policy.
- *
- * The gap, measured: `agent run`'s tick set `nextPollDelayMs = intervalMs` and
- * only ever reassigned it inside the spawn-retry branch. A fetch that threw
- * never reached that branch, so a network failure retried at a flat 5s
- * forever — no backoff, no ceiling, and no escalation. 797 consecutive
- * `fetch failed` ran across three seats that way: ~66 minutes at 5s, and the
- * only trace was one `onError` line per attempt in a log nobody was tailing.
- *
- * Two deliberate differences from the auth path directly above it:
- *
- * 1. NO STOP. `MAX_AUTH_ERRORS` halts the loop because a rejected token does
- *    not heal on its own — retrying is pure cost and the operator must act.
- *    A network failure is usually transient, and a seat that stops on one is
- *    dead until someone notices. So this backs off and stays alive.
- *
- * 2. ESCALATION IS THE POINT. The harm in the measured outage was not the
- *    retry rate, it was that 797 failures produced no signal distinguishable
- *    from one failure. `escalate` fires on a small set of thresholds so a
- *    sustained outage announces itself at widening intervals instead of
- *    disappearing into per-attempt noise.
- */
-
-// Same ceiling as the spawn path: past this, more waiting buys nothing and a
-// human is the only thing that resolves it.
-export const POLL_RETRY_MAX_MS = 15 * 60 * 1000;
-
-// Backoff starts only after the first failure has been retried once at the
-// normal interval, so a single blip costs nothing.
-export const POLL_BACKOFF_AFTER = 1;
-
-// Failure counts that emit a loud line. Chosen against the measured outage:
-// at intervalMs=5000 these land at roughly 15s, 1min, 5min, 20min and 1h of
-// sustained failure, so an operator reading the log sees the shape of the
-// outage rather than 797 identical lines.
-export const POLL_ESCALATE_AT = Object.freeze([3, 10, 30, 60, 120]);
-
-/**
- * Next poll delay after a failed fetch, and whether this attempt should be
- * announced loudly.
- *
- * Exponential from `intervalMs`, bounded by POLL_RETRY_MAX_MS. Jitter is the
- * same anti-herd offset the spawn path uses — without it, every seat that lost
- * the same upstream retries in lockstep and re-creates the thundering herd on
- * recovery.
- */
-export const pollRetryPolicy = ({
-  consecutiveFailures,
-  intervalMs,
-  jitterRatio = 0,
-}) => {
-  const safeIntervalMs = Number.isFinite(intervalMs) && intervalMs > 0 ? intervalMs : 5000;
-  const failureCount = Number.isInteger(consecutiveFailures) && consecutiveFailures > 0
-    ? consecutiveFailures
-    : 1;
-
-  const steps = Math.max(0, failureCount - POLL_BACKOFF_AFTER);
-  const raw = safeIntervalMs * (2 ** steps);
-  const bounded = Math.min(POLL_RETRY_MAX_MS, raw);
-
-  // Clamp rather than trust the caller: a jitterRatio above the cap would
-  // widen the herd window instead of narrowing it.
-  const safeJitter = Number.isFinite(jitterRatio)
-    ? Math.min(0.2, Math.max(0, jitterRatio))
-    : 0;
-
-  return {
-    delayMs: Math.round(bounded * (1 + safeJitter)),
-    escalate: POLL_ESCALATE_AT.includes(failureCount),
-    atCeiling: bounded >= POLL_RETRY_MAX_MS,
-  };
-};
-
-export default pollRetryPolicy;