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

package/dist/index.js

@@ -19,7 +19,7 @@ import {
   startContextCompactionPendingMonitor,
   startSessionRecoveryMonitor,
   startTurnCapacityMonitor
-} from "./chunk-BARTLVBK.js";
+} from "./chunk-A4XQWVZK.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-VVK7RA7F.js")).createControlActivities(dependencies) : (await import("./activities-turn-FOIZYY56.js")).createTurnActivities(dependencies);
+  return role === "control" ? (await import("./activities-control-JUBMDBDZ.js")).createControlActivities(dependencies) : (await import("./activities-turn-I2ZKGZE6.js")).createTurnActivities(dependencies);
 }
 function resolveOpenGeniWorkflowDefinition(moduleUrl = import.meta.url) {
   const modulePath = fileURLToPath(moduleUrl).replaceAll("\\", "/");

package/dist/observability-metrics.d.ts

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

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

@@ -1,4 +1,5 @@
-import type { ObjectStorage } from "@opengeni/storage";
+import { type ObjectStorage } from "@opengeni/storage";
+import type { VerifiedHostWorkspaceArchive } from "@opengeni/runtime/sandbox";
 import { type WorkspaceArchiveDescriptor, type WorkspaceArchiveObjectRef } from "@opengeni/contracts";
 export declare class WorkspaceArchiveObjectStorageRequiredError extends Error {
     readonly code: "workspace_archive_object_storage_required";
@@ -13,15 +14,26 @@ 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: {
+    archive: VerifiedHostWorkspaceArchive | {
         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.1-canary.0",
+  "version": "0.28.3-canary.0",
   "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.24",
-    "@opengeni/capabilities": "^0.3.3-canary.6",
-    "@opengeni/codemode": "^0.5.4-canary.0",
-    "@opengeni/codex": "^0.2.22-canary.6",
-    "@opengeni/config": "^1.1.0-canary.0",
-    "@opengeni/contracts": "^3.0.0-canary.0",
-    "@opengeni/core": "^2.9.1-canary.0",
-    "@opengeni/db": "^4.3.0-canary.0",
-    "@opengeni/documents": "^0.8.24-canary.0",
-    "@opengeni/events": "^0.4.22-canary.0",
-    "@opengeni/github": "^0.7.8-canary.0",
-    "@opengeni/network": "^0.3.1-canary.6",
-    "@opengeni/observability": "^0.8.24-canary.0",
-    "@opengeni/runtime": "^2.5.1-canary.0",
-    "@opengeni/storage": "^0.2.125-canary.0",
-    "@opengeni/xai-subscription": "^0.1.4-canary.6",
+    "@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",
     "@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(attempt.turnId);
+  turnLifecycleMetricsFor(observability).start({ attemptId: input.attemptId });
   // §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(attempt.turnId!);
+      turnLifecycleMetricsFor(observability).progress({ attemptId: input.attemptId });
     }
     activityContext?.heartbeat({
       ...heartbeatDetails,
@@ -515,7 +515,7 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
       return false;
     }
     recordCanonicalStartupMilestones(result.canonicalStartupMilestones);
-    turnLifecycleMetricsFor(observability).progress(attempt.turnId!);
+    turnLifecycleMetricsFor(observability).progress({ attemptId: input.attemptId });
     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,12 +745,17 @@ export async function finalizeTurnAttempt(deps: TurnFinalizationDeps): Promise<v
       status: finalizationError ? "cleanup_failed" : control.activityStatus,
       durationSeconds,
     });
-    if (attempt.turnId && control.activityStatus !== "unknown") {
-      turnLifecycleMetricsFor(observability).finish(
-        attempt.turnId,
-        control.turnMetricOutcome,
+    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,
         durationSeconds,
-      );
+      });
     }
     activitySpan.end({
       attributes: {

package/src/activities/agent-turn/model-usage.ts

@@ -129,8 +129,17 @@ export const createSessionTitleModelUsageEventState = createCompactionModelUsage
 
 export function modelResponseContextSignal(
   state: ModelResponseEventState,
+  responseCountBeforeStream = 0,
 ): { revision: number; totalTokens: number } | null {
-  return state.contextSignal;
+  const signal = state.contextSignal;
+  // A compaction retry creates a new SDK request counter, but usage identities
+  // remain activity-wide. Never bind a pre-stream report to a reused request
+  // ordinal; translate only this stream's reports without mutating usage state.
+  if (!signal || signal.revision <= responseCountBeforeStream) return null;
+  return {
+    revision: signal.revision - responseCountBeforeStream,
+    totalTokens: signal.totalTokens,
+  };
 }
 
 export function assertModelResponseLatencyMode(input: {

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

@@ -865,7 +865,8 @@ export async function runTurnStreamAttempt(
                 },
               }
             : {}),
-          contextCompactionSignal: () => modelResponseContextSignal(modelResponseState),
+          contextCompactionSignal: () =>
+            modelResponseContextSignal(modelResponseState, responseCountBeforeStream),
           contextCompactionRequested: () =>
             isSessionCompactionRequested(db, input.workspaceId, input.sessionId),
           onModelPreparationPhase: (measurement) => {
@@ -1061,7 +1062,7 @@ export async function runTurnStreamAttempt(
           currentToolBatchCallIds = new Set<string>();
           currentToolBatchCompletedCallIds = new Set<string>();
           await historySink.reconcileConversationTruth();
-          turnLifecycleMetricsFor(observability).progress(attempt.turnId!);
+          turnLifecycleMetricsFor(observability).progress({ attemptId: input.attemptId });
           modelCheckpointMemoryCollector.schedule(observability);
           try {
             await ensureRunAllowed(

package/src/activities/goals.ts

@@ -286,6 +286,8 @@ export function goalContinuationPrompt(
     "Continuation behavior:",
     "- This goal persists across turns. A runtime boundary can end one turn without shrinking the objective; the next continuation resumes the same full objective.",
     "- Keep working until the requested end state is true and verified. Do not end the turn merely because one useful action completed, and do not redefine success around a smaller or easier task.",
+    "- An incomplete-status report is not a substitute for continuing the work. If the remaining problem can be investigated or addressed within your current authority, continue that work in this turn rather than returning another equivalent status-only final.",
+    "- Distinguish unfinished work from a blocker that actually requires human input or external change; use the existing waiting and blocked audits only when their conditions hold.",
     "- Temporary rough edges are acceptable while the work is moving in the right direction. Completion still requires the requested end state to be true and verified.",
     "",
     "Work from evidence:",

package/src/activities/sandbox-lease.ts

@@ -82,7 +82,10 @@ 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.
-  captureVerifiedWorkspaceArchive,
+  captureWorkspaceArchiveForStorage,
+  disposeWorkspaceArchive,
+  type VerifiedWorkspaceArchivePayload,
+  type VerifiedHostWorkspaceArchive,
   cancelSelfhostedOp,
   assertConsistentSandboxProviderIdentity,
   createSandboxClientForBackend,
@@ -160,9 +163,7 @@ import {
 } from "../opensandbox-kubernetes-inventory";
 import type { ObjectStorage } from "@opengeni/storage";
 import {
-  collectWorkspaceArchiveObjectKeys,
-  deleteUnpublishedWorkspaceArchiveObject,
-  deleteWorkspaceArchiveObjectKeys,
+  persistWorkspaceArchiveCandidate,
   putVersion1TarArchiveOrInline,
 } from "../sandbox-archive-storage";
 
@@ -210,7 +211,7 @@ type DrainSandboxClient = {
  * aborts the terminate before client.delete()).
  */
 export type PersistArchiveFn = (
-  archiveBase64: string | null,
+  archiveBase64: string | VerifiedHostWorkspaceArchive | null,
   archiveMetadata?: WorkspaceArchiveDescriptor,
   providerSession?: unknown,
   providerBinding?: Awaited<
@@ -247,6 +248,7 @@ export type TerminateBoxFn = (
   providerCaptureRequestId?: string,
   captureDisposition?: DrainCaptureDisposition,
   capturePolicy?: ProviderWorkspaceCapturePolicy | null,
+  diskBackedArchives?: boolean,
 ) => Promise<boolean | ProviderTerminationOutcome>;
 
 export type SweepModalOrphansFn = (
@@ -479,6 +481,7 @@ export function createSandboxLeaseActivities(
       providerCaptureRequestId,
       captureDisposition,
       capturePolicy,
+      diskBackedArchives,
     ) =>
       await terminateProviderBox(
         settings,
@@ -490,6 +493,7 @@ export function createSandboxLeaseActivities(
         providerCaptureRequestId,
         captureDisposition,
         capturePolicy,
+        diskBackedArchives,
       ));
   const sweepModalOrphans: SweepModalOrphansFn =
     options.sweepModalOrphans ?? sweepModalOrphansForConfiguredBackend;
@@ -2675,7 +2679,7 @@ async function terminateDrainableBox(
       ? (lease.recovery.archive.current?.revision ?? null)
       : null;
   const persistArchive: PersistArchiveFn = async (
-    archiveBase64: string | null,
+    archiveBase64: string | VerifiedHostWorkspaceArchive | null,
     archiveMetadata?: WorkspaceArchiveDescriptor,
     _providerSession?: unknown,
     providerBinding?: Awaited<
@@ -2691,6 +2695,7 @@ 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" ||
@@ -2735,59 +2740,33 @@ async function terminateDrainableBox(
       if (!archiveMetadata) {
         throw new Error("Sandbox snapshot publication requires a verified archive descriptor");
       }
-      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;
-      }
+      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 } : {}),
+          }),
+      });
     }
     if (!result.wrote && checkpointArtifactId) {
       await markSandboxCheckpointArtifactDeletePending(db, {
@@ -2823,6 +2802,7 @@ async function terminateDrainableBox(
         captureClaim?.providerRequestId ?? attempt.operationId,
         captureDisposition,
         capturePolicy,
+        Boolean(objectStorage),
       );
   const terminated = typeof termination === "boolean" ? termination : termination.terminated;
   if (!terminated) {
@@ -2955,6 +2935,7 @@ 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;
@@ -3147,7 +3128,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: Awaited<ReturnType<typeof captureVerifiedWorkspaceArchive>> | undefined;
+  let verifiedArchive: VerifiedWorkspaceArchivePayload | undefined;
   const sessionWorkspacePersistence = (
     session as { state?: { workspacePersistence?: unknown } } | undefined
   )?.state?.workspacePersistence;
@@ -3162,10 +3143,15 @@ export async function terminateProviderBox(
       : null;
   try {
     if (captureDisposition !== "archive_published" && session?.persistWorkspace) {
-      const capture = captureVerifiedWorkspaceArchive(session, Date.now(), {
-        requestId: providerCaptureRequestId ?? randomUUID(),
-        strategy: liveCapturePolicy.strategy,
-      });
+      const capture = captureWorkspaceArchiveForStorage(
+        session,
+        Date.now(),
+        {
+          requestId: providerCaptureRequestId ?? randomUUID(),
+          strategy: liveCapturePolicy.strategy,
+        },
+        diskBackedArchives,
+      );
       verifiedArchive = await awaitProviderCaptureWithLatePublication({
         capture,
         timeoutMs: settings.sandboxSnapshotTimeoutMs,
@@ -3179,7 +3165,7 @@ export async function terminateProviderBox(
         publishLate: async (archive) => {
           try {
             const result = await persistArchive(
-              archive.base64,
+              archive.kind === "host_spool" ? archive : archive.base64,
               archive.descriptor,
               session,
               checkpointBinding,
@@ -3197,6 +3183,8 @@ export async function terminateProviderBox(
               ...logIdentity,
               error: error instanceof Error ? error.message : String(error),
             });
+          } finally {
+            await disposeWorkspaceArchive(archive);
           }
         },
         observeLateFailure: (error) => {
@@ -3237,12 +3225,17 @@ export async function terminateProviderBox(
       ...logIdentity,
     });
   } else if (verifiedArchive) {
-    const { wrote } = await persistArchive(
-      verifiedArchive.base64,
-      verifiedArchive.descriptor,
-      session,
-      checkpointBinding,
-    );
+    let wrote: boolean;
+    try {
+      ({ wrote } = await persistArchive(
+        verifiedArchive.kind === "host_spool" ? verifiedArchive : verifiedArchive.base64,
+        verifiedArchive.descriptor,
+        session,
+        checkpointBinding,
+      ));
+    } finally {
+      await disposeWorkspaceArchive(verifiedArchive);
+    }
     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 turns = new Map<string, { startedAt: number; lastProgressAt: number }>();
+  private readonly attempts = new Map<string, { startedAt: number; lastProgressAt: number }>();
   private timer: ReturnType<typeof setInterval> | null = null;
 
   constructor(
@@ -424,42 +424,46 @@ export class TurnLifecycleMetrics {
     } = {},
   ) {}
 
-  start(turnId: string): void {
+  start(input: { attemptId: string }): void {
     const now = this.now();
-    this.turns.set(turnId, { startedAt: now, lastProgressAt: now });
+    this.attempts.set(input.attemptId, { startedAt: now, lastProgressAt: now });
     this.ensureTimer();
     this.refreshGauges();
   }
 
-  progress(turnId: string): void {
-    const turn = this.turns.get(turnId);
-    if (!turn) return;
-    turn.lastProgressAt = this.now();
+  progress(input: { attemptId: string }): void {
+    const attempt = this.attempts.get(input.attemptId);
+    if (!attempt) return;
+    attempt.lastProgressAt = this.now();
   }
 
-  finish(turnId: string, outcome: TurnOutcome | null, durationSeconds?: number): void {
-    const startedAt = this.turns.get(turnId)?.startedAt;
+  finish(input: {
+    attemptId: string;
+    outcome: TurnOutcome | null;
+    durationSeconds?: number;
+  }): void {
+    const startedAt = this.attempts.get(input.attemptId)?.startedAt;
     if (startedAt !== undefined) {
-      this.turns.delete(turnId);
+      this.attempts.delete(input.attemptId);
     }
-    if (outcome) {
+    if (input.outcome) {
       const observedDuration =
-        durationSeconds ??
+        input.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 },
+        labels: { outcome: input.outcome },
       });
       this.observability.observeHistogram({
         name: "opengeni_turn_duration_seconds",
         help: "Agent turn duration in seconds by terminal outcome.",
-        labels: { outcome },
+        labels: { outcome: input.outcome },
         value: observedDuration,
       });
     }
     this.refreshGauges();
-    if (this.turns.size === 0) {
+    if (this.attempts.size === 0) {
       this.stopTimer();
     }
   }
@@ -467,42 +471,42 @@ export class TurnLifecycleMetrics {
   refreshGauges(): void {
     this.observability.setGauge({
       name: "opengeni_turns_inflight",
-      help: "Current number of in-flight agent turns in this worker process.",
-      value: this.turns.size,
+      help: "Current number of in-flight physical agent-turn attempts in this worker process.",
+      value: this.attempts.size,
     });
     this.observability.setGauge({
       name: "opengeni_turn_oldest_inflight_age_seconds",
-      help: "Age in seconds of the oldest in-flight agent turn in this worker process.",
+      help: "Age in seconds of the oldest in-flight physical agent-turn attempt 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 turn.",
+      help: "Seconds since durable progress for the least recently progressing in-flight physical agent-turn attempt.",
       value: this.oldestNoProgressAgeSeconds(),
     });
   }
 
   stop(): void {
-    this.turns.clear();
+    this.attempts.clear();
     this.refreshGauges();
     this.stopTimer();
   }
 
   private oldestInflightAgeSeconds(): number {
-    if (this.turns.size === 0) {
+    if (this.attempts.size === 0) {
       return 0;
     }
     let oldest = Number.POSITIVE_INFINITY;
-    for (const { startedAt } of this.turns.values()) {
+    for (const { startedAt } of this.attempts.values()) {
       oldest = Math.min(oldest, startedAt);
     }
     return Math.max(0, (this.now() - oldest) / 1000);
   }
 
   private oldestNoProgressAgeSeconds(): number {
-    if (this.turns.size === 0) return 0;
+    if (this.attempts.size === 0) return 0;
     let leastRecentProgress = Number.POSITIVE_INFINITY;
-    for (const { lastProgressAt } of this.turns.values()) {
+    for (const { lastProgressAt } of this.attempts.values()) {
       leastRecentProgress = Math.min(leastRecentProgress, lastProgressAt);
     }
     return Math.max(0, (this.now() - leastRecentProgress) / 1000);