@opengeni/worker-bundle 0.28.3-canary.0 → 0.28.3

package/dist/index.js

@@ -19,7 +19,7 @@ import {
   startContextCompactionPendingMonitor,
   startSessionRecoveryMonitor,
   startTurnCapacityMonitor
-} from "./chunk-A4XQWVZK.js";
+} from "./chunk-BARTLVBK.js";
 
 // src/index.ts
 import {
@@ -781,7 +781,7 @@ function temporalWorkflowExecutionNotFound(error) {
   return isGrpcServiceError(error) && error.code === 5;
 }
 async function createDefaultWorkerActivities(role, dependencies = {}) {
-  return role === "control" ? (await import("./activities-control-JUBMDBDZ.js")).createControlActivities(dependencies) : (await import("./activities-turn-I2ZKGZE6.js")).createTurnActivities(dependencies);
+  return role === "control" ? (await import("./activities-control-UXGPMDL3.js")).createControlActivities(dependencies) : (await import("./activities-turn-NOYDE7PX.js")).createTurnActivities(dependencies);
 }
 function resolveOpenGeniWorkflowDefinition(moduleUrl = import.meta.url) {
   const modulePath = fileURLToPath(moduleUrl).replaceAll("\\", "/");

package/dist/observability-metrics.d.ts

@@ -91,23 +91,15 @@ export declare function recordWorkerDeathRecoveryMetrics(observability: Observab
 export declare class TurnLifecycleMetrics {
     private readonly observability;
     private readonly options;
-    private readonly attempts;
+    private readonly turns;
     private timer;
     constructor(observability: Observability, options?: {
         now?: () => number;
         refreshIntervalMs?: number;
     });
-    start(input: {
-        attemptId: string;
-    }): void;
-    progress(input: {
-        attemptId: string;
-    }): void;
-    finish(input: {
-        attemptId: string;
-        outcome: TurnOutcome | null;
-        durationSeconds?: number;
-    }): void;
+    start(turnId: string): void;
+    progress(turnId: string): void;
+    finish(turnId: string, outcome: TurnOutcome | null, durationSeconds?: number): void;
     refreshGauges(): void;
     stop(): void;
     private oldestInflightAgeSeconds;

package/dist/sandbox-archive-storage.d.ts

@@ -1,5 +1,4 @@
-import { type ObjectStorage } from "@opengeni/storage";
-import type { VerifiedHostWorkspaceArchive } from "@opengeni/runtime/sandbox";
+import type { ObjectStorage } from "@opengeni/storage";
 import { type WorkspaceArchiveDescriptor, type WorkspaceArchiveObjectRef } from "@opengeni/contracts";
 export declare class WorkspaceArchiveObjectStorageRequiredError extends Error {
     readonly code: "workspace_archive_object_storage_required";
@@ -14,26 +13,15 @@ export declare function putTarWorkspaceArchiveObject(input: {
     archive: {
         bytes: Uint8Array;
         descriptor: WorkspaceArchiveDescriptor;
-    } | VerifiedHostWorkspaceArchive;
+    };
 }): Promise<WorkspaceArchiveObjectRef>;
-/** The caller owns a fresh candidate returned by this module. A thrown or lost
- * database response is UNKNOWN: it may have committed, so never delete on catch.
- * Only the transaction's exact candidate disposition can authorize cleanup. */
-export declare function persistWorkspaceArchiveCandidate<T extends {
-    wrote: boolean;
-    candidateDisposition?: "adopted" | "already_referenced" | "unused";
-}>(input: {
-    objectStorage?: ObjectStorage | null;
-    ref?: WorkspaceArchiveObjectRef;
-    persist: () => Promise<T>;
-}): Promise<T>;
 export declare function putVersion1TarArchiveOrInline(input: {
     backend: string;
     objectStorage?: ObjectStorage | null | undefined;
     accountId: string;
     workspaceId: string;
     sandboxGroupId: string;
-    archive: VerifiedHostWorkspaceArchive | {
+    archive: {
         bytes: Uint8Array;
         descriptor: WorkspaceArchiveDescriptor;
         base64: string;

package/dist/sandbox-resume.d.ts

@@ -1,7 +1,7 @@
 import { type Settings } from "@opengeni/config";
 import { readLease, reinstateTurnLeaseHolder, SandboxLeaseSupersededError, type Database, type LeaseHolderKind } from "@opengeni/db";
 import { establishSandboxSessionFromEnvelope, type EstablishedSandboxSession, type RuntimeMetricsHooks } from "@opengeni/runtime";
-import { type ObjectStorage } from "@opengeni/storage";
+import type { ObjectStorage } from "@opengeni/storage";
 import type { Observability } from "@opengeni/observability";
 export type ResumeHolderKind = LeaseHolderKind;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/worker-bundle",
-  "version": "0.28.3-canary.0",
+  "version": "0.28.3",
   "description": "OpenGeni worker entry and reusable embedded lifecycle, shipped with a release-coherent pre-bundled Temporal workflow artifact.",
   "license": "Apache-2.0",
   "repository": {
@@ -54,22 +54,22 @@
   },
   "dependencies": {
     "@llamaindex/liteparse": "2.14.2",
-    "@opengeni/agent-proto": "^0.5.1-canary.25",
-    "@opengeni/capabilities": "^0.3.3-canary.7",
-    "@opengeni/codemode": "^0.5.5-canary.0",
-    "@opengeni/codex": "^0.2.22-canary.7",
-    "@opengeni/config": "^1.1.1-canary.0",
-    "@opengeni/contracts": "^3.0.1-canary.0",
-    "@opengeni/core": "^2.9.3-canary.0",
-    "@opengeni/db": "^4.3.2-canary.0",
-    "@opengeni/documents": "^0.8.26-canary.0",
-    "@opengeni/events": "^0.4.24-canary.0",
-    "@opengeni/github": "^0.7.9-canary.0",
-    "@opengeni/network": "^0.3.1-canary.7",
-    "@opengeni/observability": "^0.8.25-canary.0",
-    "@opengeni/runtime": "^2.5.2-canary.0",
-    "@opengeni/storage": "^0.2.126-canary.0",
-    "@opengeni/xai-subscription": "^0.1.4-canary.7",
+    "@opengeni/agent-proto": "^0.5.1",
+    "@opengeni/capabilities": "^0.3.3",
+    "@opengeni/codemode": "^0.5.5",
+    "@opengeni/codex": "^0.2.22",
+    "@opengeni/config": "^1.1.1",
+    "@opengeni/contracts": "^3.0.1",
+    "@opengeni/core": "^2.9.3",
+    "@opengeni/db": "^4.3.2",
+    "@opengeni/documents": "^0.8.26",
+    "@opengeni/events": "^0.4.24",
+    "@opengeni/github": "^0.7.9",
+    "@opengeni/network": "^0.3.1",
+    "@opengeni/observability": "^0.8.25",
+    "@opengeni/runtime": "^2.5.2",
+    "@opengeni/storage": "^0.2.126",
+    "@opengeni/xai-subscription": "^0.1.4",
     "@temporalio/activity": "^1.17.0",
     "@temporalio/client": "^1.17.0",
     "@temporalio/worker": "^1.17.0",

package/src/activities/agent-turn/claim.ts

@@ -347,7 +347,7 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
     });
     return attached.action === "claimed" && attached.turn.id === turn.id;
   };
-  turnLifecycleMetricsFor(observability).start({ attemptId: input.attemptId });
+  turnLifecycleMetricsFor(observability).start(attempt.turnId);
   // §7.5 P3 — pass the accepted billing attribution (externally funded turns
   // bypass OpenGeni credit/token gates)
   // AND the optional host `entitlements` port (when bound, its admitRun replaces
@@ -451,7 +451,7 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
     }
     recordCanonicalStartupMilestones(appended.canonicalStartupMilestones);
     if (inputs.length > 0) {
-      turnLifecycleMetricsFor(observability).progress({ attemptId: input.attemptId });
+      turnLifecycleMetricsFor(observability).progress(attempt.turnId!);
     }
     activityContext?.heartbeat({
       ...heartbeatDetails,
@@ -515,7 +515,7 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
       return false;
     }
     recordCanonicalStartupMilestones(result.canonicalStartupMilestones);
-    turnLifecycleMetricsFor(observability).progress({ attemptId: input.attemptId });
+    turnLifecycleMetricsFor(observability).progress(attempt.turnId!);
     await publishDurableSessionEvents(bus, input.workspaceId, input.sessionId, result.events);
     if (inputSettlement.turnStatus === "requires_action") {
       // The settlement transaction committed the parent's child_requires_action

package/src/activities/agent-turn/finalization.ts

@@ -745,17 +745,12 @@ export async function finalizeTurnAttempt(deps: TurnFinalizationDeps): Promise<v
       status: finalizationError ? "cleanup_failed" : control.activityStatus,
       durationSeconds,
     });
-    if (attempt.turnId) {
-      // This registry describes physical activity ownership, not durable turn
-      // settlement. Always clear the exact attempt when its activity unwinds,
-      // even when failure settlement could not classify an outcome. Otherwise
-      // a recovered successor can make progress while the predecessor leaves a
-      // process-local false stuck-turn alert behind.
-      turnLifecycleMetricsFor(observability).finish({
-        attemptId: input.attemptId,
-        outcome: control.turnMetricOutcome,
+    if (attempt.turnId && control.activityStatus !== "unknown") {
+      turnLifecycleMetricsFor(observability).finish(
+        attempt.turnId,
+        control.turnMetricOutcome,
         durationSeconds,
-      });
+      );
     }
     activitySpan.end({
       attributes: {

package/src/activities/agent-turn/stream-attempt.ts

@@ -1062,7 +1062,7 @@ export async function runTurnStreamAttempt(
           currentToolBatchCallIds = new Set<string>();
           currentToolBatchCompletedCallIds = new Set<string>();
           await historySink.reconcileConversationTruth();
-          turnLifecycleMetricsFor(observability).progress({ attemptId: input.attemptId });
+          turnLifecycleMetricsFor(observability).progress(attempt.turnId!);
           modelCheckpointMemoryCollector.schedule(observability);
           try {
             await ensureRunAllowed(

package/src/activities/sandbox-lease.ts

@@ -82,10 +82,7 @@ import {
   // box is typed as provider loss. Stale capture reconciliation separately uses
   // establishSandboxSessionFromEnvelope in strict resume-only mode so it can
   // reuse the runtime's provider-ready proof without ever cold-restoring.
-  captureWorkspaceArchiveForStorage,
-  disposeWorkspaceArchive,
-  type VerifiedWorkspaceArchivePayload,
-  type VerifiedHostWorkspaceArchive,
+  captureVerifiedWorkspaceArchive,
   cancelSelfhostedOp,
   assertConsistentSandboxProviderIdentity,
   createSandboxClientForBackend,
@@ -163,7 +160,9 @@ import {
 } from "../opensandbox-kubernetes-inventory";
 import type { ObjectStorage } from "@opengeni/storage";
 import {
-  persistWorkspaceArchiveCandidate,
+  collectWorkspaceArchiveObjectKeys,
+  deleteUnpublishedWorkspaceArchiveObject,
+  deleteWorkspaceArchiveObjectKeys,
   putVersion1TarArchiveOrInline,
 } from "../sandbox-archive-storage";
 
@@ -211,7 +210,7 @@ type DrainSandboxClient = {
  * aborts the terminate before client.delete()).
  */
 export type PersistArchiveFn = (
-  archiveBase64: string | VerifiedHostWorkspaceArchive | null,
+  archiveBase64: string | null,
   archiveMetadata?: WorkspaceArchiveDescriptor,
   providerSession?: unknown,
   providerBinding?: Awaited<
@@ -248,7 +247,6 @@ export type TerminateBoxFn = (
   providerCaptureRequestId?: string,
   captureDisposition?: DrainCaptureDisposition,
   capturePolicy?: ProviderWorkspaceCapturePolicy | null,
-  diskBackedArchives?: boolean,
 ) => Promise<boolean | ProviderTerminationOutcome>;
 
 export type SweepModalOrphansFn = (
@@ -481,7 +479,6 @@ export function createSandboxLeaseActivities(
       providerCaptureRequestId,
       captureDisposition,
       capturePolicy,
-      diskBackedArchives,
     ) =>
       await terminateProviderBox(
         settings,
@@ -493,7 +490,6 @@ export function createSandboxLeaseActivities(
         providerCaptureRequestId,
         captureDisposition,
         capturePolicy,
-        diskBackedArchives,
       ));
   const sweepModalOrphans: SweepModalOrphansFn =
     options.sweepModalOrphans ?? sweepModalOrphansForConfiguredBackend;
@@ -2679,7 +2675,7 @@ async function terminateDrainableBox(
       ? (lease.recovery.archive.current?.revision ?? null)
       : null;
   const persistArchive: PersistArchiveFn = async (
-    archiveBase64: string | VerifiedHostWorkspaceArchive | null,
+    archiveBase64: string | null,
     archiveMetadata?: WorkspaceArchiveDescriptor,
     _providerSession?: unknown,
     providerBinding?: Awaited<
@@ -2695,7 +2691,6 @@ async function terminateDrainableBox(
     const archiveMetrics = runtimeMetricsHooksForObservability(observability);
     let checkpointArtifactId: string | null = null;
     if (
-      typeof archiveBase64 === "string" &&
       archiveBase64 &&
       archiveMetadata?.version === 2 &&
       (archiveMetadata.provider === "modal_snapshot_filesystem" ||
@@ -2740,33 +2735,59 @@ async function terminateDrainableBox(
       if (!archiveMetadata) {
         throw new Error("Sandbox snapshot publication requires a verified archive descriptor");
       }
-      const published = await putVersion1TarArchiveOrInline({
-        backend: lease.backend,
-        objectStorage,
-        accountId,
-        workspaceId: row.workspaceId,
-        sandboxGroupId: row.sandboxGroupId,
-        archive:
-          typeof archiveBase64 === "object"
-            ? archiveBase64
-            : {
-                bytes: Buffer.from(archiveBase64, "base64"),
-                descriptor: archiveMetadata,
-                base64: archiveBase64,
-              },
-        metrics: archiveMetrics,
-      });
-      result = await persistWorkspaceArchiveCandidate({
-        objectStorage,
-        ...(published.workspaceArchiveRef ? { ref: published.workspaceArchiveRef } : {}),
-        persist: () =>
-          persistDrainSnapshot(db, {
-            ...baseInput,
-            workspaceArchiveMeta: archiveMetadata,
-            ...published,
-            ...(checkpointArtifactId ? { checkpointArtifactId } : {}),
-          }),
-      });
+      const priorKeys = collectWorkspaceArchiveObjectKeys(
+        (lease.resumeState as Record<string, unknown> | null | undefined) ?? null,
+      );
+      let workspaceArchiveRef:
+        | Awaited<ReturnType<typeof putVersion1TarArchiveOrInline>>["workspaceArchiveRef"]
+        | undefined;
+      try {
+        const published = await putVersion1TarArchiveOrInline({
+          backend: lease.backend,
+          objectStorage,
+          accountId,
+          workspaceId: row.workspaceId,
+          sandboxGroupId: row.sandboxGroupId,
+          archive: {
+            bytes: Buffer.from(archiveBase64, "base64"),
+            descriptor: archiveMetadata,
+            base64: archiveBase64,
+          },
+          metrics: archiveMetrics,
+        });
+        workspaceArchiveRef = published.workspaceArchiveRef;
+        result = await persistDrainSnapshot(db, {
+          ...baseInput,
+          workspaceArchiveMeta: archiveMetadata,
+          ...published,
+          ...(checkpointArtifactId ? { checkpointArtifactId } : {}),
+        });
+        if (published.workspaceArchiveRef && objectStorage) {
+          if (!result.wrote) {
+            await deleteUnpublishedWorkspaceArchiveObject(
+              objectStorage,
+              published.workspaceArchiveRef,
+              archiveMetrics,
+            );
+          } else {
+            const afterLease = await readLease(db, row.workspaceId, row.sandboxGroupId);
+            const afterKeys = collectWorkspaceArchiveObjectKeys(
+              (afterLease?.resumeState as Record<string, unknown> | null | undefined) ?? null,
+            );
+            await deleteWorkspaceArchiveObjectKeys(
+              objectStorage,
+              [...priorKeys].filter((key) => !afterKeys.has(key)),
+            ).catch(() => undefined);
+          }
+        }
+      } catch (error) {
+        await deleteUnpublishedWorkspaceArchiveObject(
+          objectStorage,
+          workspaceArchiveRef,
+          archiveMetrics,
+        );
+        throw error;
+      }
     }
     if (!result.wrote && checkpointArtifactId) {
       await markSandboxCheckpointArtifactDeletePending(db, {
@@ -2802,7 +2823,6 @@ async function terminateDrainableBox(
         captureClaim?.providerRequestId ?? attempt.operationId,
         captureDisposition,
         capturePolicy,
-        Boolean(objectStorage),
       );
   const terminated = typeof termination === "boolean" ? termination : termination.terminated;
   if (!terminated) {
@@ -2935,7 +2955,6 @@ export async function terminateProviderBox(
   providerCaptureRequestId?: string,
   captureDisposition: DrainCaptureDisposition = "capture_required",
   claimedCapturePolicy?: ProviderWorkspaceCapturePolicy | null,
-  diskBackedArchives = false,
 ): Promise<ProviderTerminationOutcome> {
   const durableBackendId = (lease.resumeBackendId ?? lease.backend) as string;
   const backend = sandboxBackendForSdkBackendId(durableBackendId) ?? durableBackendId;
@@ -3128,7 +3147,7 @@ export async function terminateProviderBox(
   // snapshot must re-throw BEFORE any terminate so files are never lost — the next
   // sweep retries, the provider idle-timeout is the backstop. A NotFound here (the
   // box raced gone between resume and persist) is success: nothing to persist.
-  let verifiedArchive: VerifiedWorkspaceArchivePayload | undefined;
+  let verifiedArchive: Awaited<ReturnType<typeof captureVerifiedWorkspaceArchive>> | undefined;
   const sessionWorkspacePersistence = (
     session as { state?: { workspacePersistence?: unknown } } | undefined
   )?.state?.workspacePersistence;
@@ -3143,15 +3162,10 @@ export async function terminateProviderBox(
       : null;
   try {
     if (captureDisposition !== "archive_published" && session?.persistWorkspace) {
-      const capture = captureWorkspaceArchiveForStorage(
-        session,
-        Date.now(),
-        {
-          requestId: providerCaptureRequestId ?? randomUUID(),
-          strategy: liveCapturePolicy.strategy,
-        },
-        diskBackedArchives,
-      );
+      const capture = captureVerifiedWorkspaceArchive(session, Date.now(), {
+        requestId: providerCaptureRequestId ?? randomUUID(),
+        strategy: liveCapturePolicy.strategy,
+      });
       verifiedArchive = await awaitProviderCaptureWithLatePublication({
         capture,
         timeoutMs: settings.sandboxSnapshotTimeoutMs,
@@ -3165,7 +3179,7 @@ export async function terminateProviderBox(
         publishLate: async (archive) => {
           try {
             const result = await persistArchive(
-              archive.kind === "host_spool" ? archive : archive.base64,
+              archive.base64,
               archive.descriptor,
               session,
               checkpointBinding,
@@ -3183,8 +3197,6 @@ export async function terminateProviderBox(
               ...logIdentity,
               error: error instanceof Error ? error.message : String(error),
             });
-          } finally {
-            await disposeWorkspaceArchive(archive);
           }
         },
         observeLateFailure: (error) => {
@@ -3225,17 +3237,12 @@ export async function terminateProviderBox(
       ...logIdentity,
     });
   } else if (verifiedArchive) {
-    let wrote: boolean;
-    try {
-      ({ wrote } = await persistArchive(
-        verifiedArchive.kind === "host_spool" ? verifiedArchive : verifiedArchive.base64,
-        verifiedArchive.descriptor,
-        session,
-        checkpointBinding,
-      ));
-    } finally {
-      await disposeWorkspaceArchive(verifiedArchive);
-    }
+    const { wrote } = await persistArchive(
+      verifiedArchive.base64,
+      verifiedArchive.descriptor,
+      session,
+      checkpointBinding,
+    );
     if (!wrote) {
       observability.info(
         "sandbox reaper: lease re-armed during persist — leaving box RUNNING (no terminate)",

package/src/observability-metrics.ts

@@ -413,7 +413,7 @@ export function recordWorkerDeathRecoveryMetrics(
 }
 
 export class TurnLifecycleMetrics {
-  private readonly attempts = new Map<string, { startedAt: number; lastProgressAt: number }>();
+  private readonly turns = new Map<string, { startedAt: number; lastProgressAt: number }>();
   private timer: ReturnType<typeof setInterval> | null = null;
 
   constructor(
@@ -424,46 +424,42 @@ export class TurnLifecycleMetrics {
     } = {},
   ) {}
 
-  start(input: { attemptId: string }): void {
+  start(turnId: string): void {
     const now = this.now();
-    this.attempts.set(input.attemptId, { startedAt: now, lastProgressAt: now });
+    this.turns.set(turnId, { startedAt: now, lastProgressAt: now });
     this.ensureTimer();
     this.refreshGauges();
   }
 
-  progress(input: { attemptId: string }): void {
-    const attempt = this.attempts.get(input.attemptId);
-    if (!attempt) return;
-    attempt.lastProgressAt = this.now();
+  progress(turnId: string): void {
+    const turn = this.turns.get(turnId);
+    if (!turn) return;
+    turn.lastProgressAt = this.now();
   }
 
-  finish(input: {
-    attemptId: string;
-    outcome: TurnOutcome | null;
-    durationSeconds?: number;
-  }): void {
-    const startedAt = this.attempts.get(input.attemptId)?.startedAt;
+  finish(turnId: string, outcome: TurnOutcome | null, durationSeconds?: number): void {
+    const startedAt = this.turns.get(turnId)?.startedAt;
     if (startedAt !== undefined) {
-      this.attempts.delete(input.attemptId);
+      this.turns.delete(turnId);
     }
-    if (input.outcome) {
+    if (outcome) {
       const observedDuration =
-        input.durationSeconds ??
+        durationSeconds ??
         (startedAt === undefined ? 0 : Math.max(0, (this.now() - startedAt) / 1000));
       this.observability.incrementCounter({
         name: "opengeni_turns_total",
         help: "Total agent turns by terminal outcome.",
-        labels: { outcome: input.outcome },
+        labels: { outcome },
       });
       this.observability.observeHistogram({
         name: "opengeni_turn_duration_seconds",
         help: "Agent turn duration in seconds by terminal outcome.",
-        labels: { outcome: input.outcome },
+        labels: { outcome },
         value: observedDuration,
       });
     }
     this.refreshGauges();
-    if (this.attempts.size === 0) {
+    if (this.turns.size === 0) {
       this.stopTimer();
     }
   }
@@ -471,42 +467,42 @@ export class TurnLifecycleMetrics {
   refreshGauges(): void {
     this.observability.setGauge({
       name: "opengeni_turns_inflight",
-      help: "Current number of in-flight physical agent-turn attempts in this worker process.",
-      value: this.attempts.size,
+      help: "Current number of in-flight agent turns in this worker process.",
+      value: this.turns.size,
     });
     this.observability.setGauge({
       name: "opengeni_turn_oldest_inflight_age_seconds",
-      help: "Age in seconds of the oldest in-flight physical agent-turn attempt in this worker process.",
+      help: "Age in seconds of the oldest in-flight agent turn in this worker process.",
       value: this.oldestInflightAgeSeconds(),
     });
     this.observability.setGauge({
       name: "opengeni_turn_oldest_no_progress_age_seconds",
-      help: "Seconds since durable progress for the least recently progressing in-flight physical agent-turn attempt.",
+      help: "Seconds since durable progress for the least recently progressing in-flight turn.",
       value: this.oldestNoProgressAgeSeconds(),
     });
   }
 
   stop(): void {
-    this.attempts.clear();
+    this.turns.clear();
     this.refreshGauges();
     this.stopTimer();
   }
 
   private oldestInflightAgeSeconds(): number {
-    if (this.attempts.size === 0) {
+    if (this.turns.size === 0) {
       return 0;
     }
     let oldest = Number.POSITIVE_INFINITY;
-    for (const { startedAt } of this.attempts.values()) {
+    for (const { startedAt } of this.turns.values()) {
       oldest = Math.min(oldest, startedAt);
     }
     return Math.max(0, (this.now() - oldest) / 1000);
   }
 
   private oldestNoProgressAgeSeconds(): number {
-    if (this.attempts.size === 0) return 0;
+    if (this.turns.size === 0) return 0;
     let leastRecentProgress = Number.POSITIVE_INFINITY;
-    for (const { lastProgressAt } of this.attempts.values()) {
+    for (const { lastProgressAt } of this.turns.values()) {
       leastRecentProgress = Math.min(leastRecentProgress, lastProgressAt);
     }
     return Math.max(0, (this.now() - leastRecentProgress) / 1000);