deepline 0.3.452 → 0.3.454

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/modal.ts

@@ -24,7 +24,10 @@ import {
 } from '../../modal-runtime-config';
 import type { PlaySandboxRuntimeLimits } from '../../../plays/sandbox-runtime-limits';
 import { validateDaytonaExecutionContext } from './daytona-lifecycle';
-import { stageRunnerPayload } from './daytona-payload-transport';
+import {
+  stageRunnerPayload,
+  withRunnerSandboxProvider,
+} from './daytona-payload-transport';
 import { captureDetachedDaytonaRunnerReadinessBaseline } from './daytona-session-execution';
 import {
   isPlayRunRecoveryError,
@@ -594,7 +597,7 @@ export const modalPlayRunnerBackend: PlayRunnerBackend = {
                 }),
             },
             bundlePromise: buildPlayRunnerBundle(),
-            config,
+            config: withRunnerSandboxProvider(config, 'modal'),
             workDir: modalConfig.workdir,
             startedAt,
             emitStage: (stage, extra) =>

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/absurd-runtime-worker.ts

@@ -839,12 +839,9 @@ export type AbsurdRuntimeWorkerDeps = {
    * detached runner that lost its gateway. This never executes customer code:
    * it can only recover the result the sandbox already emitted before exit.
    */
-  inspectDetachedRunner?: (suspension: DetachedRunnerSuspension) => Promise<{
-    exitCode: number | null;
-    result: PlayRunnerResult | null;
-    // Written by the runner, possibly an older build: readers default it.
-    diagnosis?: { stage: string; detail: string | null };
-  } | null>;
+  inspectDetachedRunner?: (
+    suspension: DetachedRunnerSuspension,
+  ) => Promise<DetachedRunnerInspection | null>;
   readSandboxCrashDiagnostic?: (
     request: PostgresSchedulerSandboxCrashDiagnosticRequest,
     routingDomain: string | null,
@@ -1332,6 +1329,49 @@ function signalData(
 }
 
 const LIVENESS_CONFIRMATION_SLICES_PER_CADENCE = 4;
+const LIVENESS_RECHECK_INTERVAL_CADENCES = 2;
+const LIVENESS_RECHECK_MIN_INTERVAL_MS = 1_000;
+const LIVENESS_PARK_MAX_REARMS_PER_WAKE = 8;
+const LIVENESS_REPLAY_READ_REUSE_MS = 100;
+
+/**
+ * Suspensions the park proved gone in this handler invocation, with the
+ * inspection that proved it when this leg made one. The resolver reuses it
+ * rather than asking the provider twice, and honors it rather than re-deciding:
+ * re-parking on a disagreeing inspection would meet the same cached proof and
+ * spin.
+ */
+const detachedRunnerProvenGone = new WeakMap<
+  DetachedRunnerSuspension,
+  DetachedRunnerInspection | null
+>();
+
+type DetachedRunnerInspection = {
+  exitCode: number | null;
+  result: PlayRunnerResult | null;
+  // Written by the runner, possibly an older build: readers default it.
+  diagnosis?: { stage: string; detail: string | null };
+};
+
+/**
+ * Whether a provider inspection proves the runner can no longer act. A stale
+ * heartbeat alone never does: the gateway can lose heartbeats from a healthy
+ * runner, and the provider can be unreachable while the sandbox still runs.
+ * Only a recoverable result, a recorded process exit, or a missing or stopped
+ * sandbox counts. Anything else leaves the run parked, bounded by its hard
+ * ceiling.
+ */
+export function detachedRunnerInspectionProvesGone(
+  inspection: DetachedRunnerInspection | null,
+): boolean {
+  if (!inspection) return false;
+  if (inspection.result && inspection.result.status !== 'suspended') {
+    return true;
+  }
+  if (inspection.exitCode !== null) return true;
+  const stage = inspection.diagnosis?.stage;
+  return stage === 'sandbox_missing' || stage === 'sandbox_stopped';
+}
 
 /**
  * A stale heartbeat proves a lost runner only if the runner could have renewed
@@ -1340,8 +1380,11 @@ const LIVENESS_CONFIRMATION_SLICES_PER_CADENCE = 4;
  * counts only short sleep slices that woke on time, and decides after two
  * heartbeat cadences of such observed availability. A late slice counts for
  * nothing. Slice times and lateness are checkpointed, so replay is
- * deterministic. Returns true when the runner stayed silent or the hard
- * ceiling arrived, false as soon as it renewed or pushed its terminal.
+ * deterministic.
+ *
+ * Silence is still not loss, so the worker then asks the provider, and keeps
+ * asking on a paced schedule until the provider proves the runner gone, the
+ * runner responds, or the hard ceiling arrives.
  */
 async function confirmDetachedRunnerSilence(input: {
   ctx: AbsurdSuspensionContext;
@@ -1349,6 +1392,79 @@ async function confirmDetachedRunnerSilence(input: {
   cadenceMs: number;
   ceilingDeadlineMs: number;
   runnerResponded: () => Promise<boolean>;
+  inspectDetachedRunner?: (
+    suspension: DetachedRunnerSuspension,
+  ) => Promise<DetachedRunnerInspection | null>;
+  suspension: DetachedRunnerSuspension;
+}): Promise<'responded' | 'gone' | 'ceiling'> {
+  if (!(await confirmSilenceWindow(input))) return 'responded';
+  if (Date.now() >= input.ceilingDeadlineMs) return 'ceiling';
+  const inspect = input.inspectDetachedRunner;
+  if (!inspect) {
+    detachedRunnerProvenGone.set(input.suspension, null);
+    return 'gone';
+  }
+  const recheckMs = Math.max(
+    LIVENESS_RECHECK_MIN_INTERVAL_MS,
+    LIVENESS_RECHECK_INTERVAL_CADENCES * input.cadenceMs,
+  );
+  for (let round = 1; ; round += 1) {
+    const stepName = `${input.stepPrefix}:evidence:${round}`;
+    let inspected: DetachedRunnerInspection | null = null;
+    const gone = await input.ctx.step(`${stepName}:gone`, async () => {
+      // Deferred so a synchronous throw, such as an unreadable persisted
+      // sandbox ref, is an unproven inspection rather than a failed park.
+      const inspection = await Promise.resolve()
+        .then(() => inspect(input.suspension))
+        .catch((error: unknown) => {
+          console.warn(
+            '[absurd-runtime.worker] detached_runner_liveness_evidence_failed',
+            JSON.stringify({
+              sandboxId: input.suspension.sandboxId,
+              round,
+              error: error instanceof Error ? error.message : String(error),
+            }),
+          );
+          return null;
+        });
+      inspected = inspection;
+      const proved = detachedRunnerInspectionProvesGone(inspection);
+      if (!proved) {
+        console.warn(
+          '[absurd-runtime.worker] detached_runner_liveness_unproven',
+          JSON.stringify({
+            runnerAttempt: input.suspension.runnerAttempt,
+            sandboxId: input.suspension.sandboxId,
+            round,
+            diagnosis: inspection?.diagnosis?.stage ?? 'unavailable',
+          }),
+        );
+      }
+      return proved;
+    });
+    if (gone) {
+      detachedRunnerProvenGone.set(input.suspension, inspected);
+      return 'gone';
+    }
+    // Jitter stops runners silenced together from being inspected together.
+    const wakeAtMs = await input.ctx.step(`${stepName}:at`, async () =>
+      Math.min(
+        input.ceilingDeadlineMs,
+        Date.now() + recheckMs * (1 + Math.random() / 2),
+      ),
+    );
+    await input.ctx.sleepUntil(stepName, new Date(wakeAtMs));
+    if (await input.runnerResponded()) return 'responded';
+    if (wakeAtMs >= input.ceilingDeadlineMs) return 'ceiling';
+  }
+}
+
+async function confirmSilenceWindow(input: {
+  ctx: AbsurdSuspensionContext;
+  stepPrefix: string;
+  cadenceMs: number;
+  ceilingDeadlineMs: number;
+  runnerResponded: () => Promise<boolean>;
 }): Promise<boolean> {
   const sliceMs = Math.floor(
     input.cadenceMs / LIVENESS_CONFIRMATION_SLICES_PER_CADENCE,
@@ -1398,6 +1514,11 @@ export async function parkAndResolveSuspension(input: {
     updatedAt: string | null;
     status: string;
   } | null>;
+  /** Provider evidence the park requires before it reports a silent runner as
+   * gone. Without it, silence alone ends the park. */
+  inspectDetachedRunner?: (
+    suspension: DetachedRunnerSuspension,
+  ) => Promise<DetachedRunnerInspection | null>;
 }): Promise<PlayCheckpoint> {
   const { ctx, suspension, checkpoint, runId } = input;
 
@@ -1430,8 +1551,11 @@ export async function parkAndResolveSuspension(input: {
         ? configuredHeartbeatTimeoutMs
         : RUNTIME_CLAIM_LEASE_SECONDS * 1000;
     const ceilingDeadlineMs = suspension.startedAtMs + suspension.ceilingMs;
+    const readRunnerTerminal = input.readRunnerTerminal;
+    const readRunnerLiveness = input.readRunnerLiveness;
+    let rearms = 0;
     for (;;) {
-      const liveness = await input.readRunnerLiveness(suspension.runnerAttempt);
+      const liveness = await readRunnerLiveness(suspension.runnerAttempt);
       const heartbeatAtMs = liveness?.heartbeatAt
         ? Date.parse(liveness.heartbeatAt)
         : Number.NaN;
@@ -1441,26 +1565,33 @@ export async function parkAndResolveSuspension(input: {
           : suspension.startedAtMs) + heartbeatTimeoutMs;
       const deadlineMs = Math.min(ceilingDeadlineMs, heartbeatDeadlineMs);
       const remainingMs = Math.max(0, deadlineMs - Date.now());
+      let timedOut = false;
       try {
         // The deadline is part of the durable step identity. A new persisted
         // heartbeat produces a new deadline/step and parks again without
         // allocating a new scheduler attempt; the live sandbox keeps its
         // original attempt-scoped executor token and heartbeat identity.
+        // Absurd floors this to whole seconds, so round up: a timer that
+        // fires early must not reach the liveness decision below.
         await ctx.awaitEvent(
           absurdRunnerTerminalEventName(runId, suspension.runnerAttempt),
           {
             stepName: `${suspension.boundaryId}:deadline:${deadlineMs}`,
-            timeout: remainingMs / 1000,
+            timeout: Math.ceil(remainingMs / 1000),
           },
         );
-        break;
       } catch (error) {
         if (!(error instanceof TimeoutError)) {
           // SuspendTask (park) and any real error propagate.
           throw error;
         }
+        timedOut = true;
       }
-      const renewed = await input.readRunnerLiveness(suspension.runnerAttempt);
+      // A returned wait proves nothing. After a timed-out wake the run row
+      // keeps its wake_event, so the next wait on this event returns null
+      // instead of suspending. Only the persisted terminal ends the park.
+      if (await readRunnerTerminal(suspension.runnerAttempt)) break;
+      const renewed = await readRunnerLiveness(suspension.runnerAttempt);
       const renewedAtMs = renewed?.heartbeatAt
         ? Date.parse(renewed.heartbeatAt)
         : Number.NaN;
@@ -1470,29 +1601,45 @@ export async function parkAndResolveSuspension(input: {
           heartbeatTimeoutMs,
       );
       if (renewedDeadlineMs > Date.now()) {
-        if (renewedDeadlineMs === deadlineMs) break;
+        // This deadline's step has already timed out, so waiting on it again
+        // here would be a different step. The resolver re-parks from a new leg.
+        if (timedOut && renewedDeadlineMs === deadlineMs) break;
+        rearms += 1;
+        if (rearms > LIVENESS_PARK_MAX_REARMS_PER_WAKE) {
+          throw new Error(
+            `Detached runner park for ${runId}/${suspension.runnerAttempt} woke ${rearms} times without a terminal or an expired deadline.`,
+          );
+        }
         continue;
       }
       if (ceilingDeadlineMs <= Date.now()) break;
-      const readRunnerTerminal = input.readRunnerTerminal;
-      const readRunnerLiveness = input.readRunnerLiveness;
-      const silent = await confirmDetachedRunnerSilence({
+      let quietUntilMs = 0;
+      const verdict = await confirmDetachedRunnerSilence({
         ctx,
         stepPrefix: `${suspension.boundaryId}:liveness-confirm:${Number.isFinite(renewedAtMs) ? renewedAtMs : 'none'}`,
         cadenceMs: Math.floor(
           heartbeatTimeoutMs / RUNTIME_CLAIM_HEARTBEAT_DIVISOR,
         ),
         ceilingDeadlineMs,
+        inspectDetachedRunner: input.inspectDetachedRunner,
+        suspension,
         runnerResponded: async () => {
+          // A wake replays every finished slice. One read per replay is enough.
+          if (Date.now() < quietUntilMs) return false;
           if (await readRunnerTerminal(suspension.runnerAttempt)) return true;
           const current = await readRunnerLiveness(suspension.runnerAttempt);
           const currentAtMs = current?.heartbeatAt
             ? Date.parse(current.heartbeatAt)
             : Number.NaN;
-          return Number.isFinite(currentAtMs) && !(currentAtMs <= renewedAtMs);
+          if (Number.isFinite(currentAtMs) && !(currentAtMs <= renewedAtMs)) {
+            return true;
+          }
+          quietUntilMs = Date.now() + LIVENESS_REPLAY_READ_REUSE_MS;
+          return false;
         },
       });
-      if (silent) break;
+      if (verdict === 'responded') continue;
+      break;
     }
     // Truth is the persisted terminal (read by the caller's wake path); the
     // absurd event carries no payload we trust.
@@ -1594,6 +1741,9 @@ export function createAbsurdEngineSuspensionAdapter(input: {
     updatedAt: string | null;
     status: string;
   } | null>;
+  inspectDetachedRunner?: (
+    suspension: DetachedRunnerSuspension,
+  ) => Promise<DetachedRunnerInspection | null>;
 }): PlayRunAttemptEngineSuspensionPort {
   let parkedSignal: SuspendTask | null = null;
   return {
@@ -1609,6 +1759,7 @@ export function createAbsurdEngineSuspensionAdapter(input: {
             claimSignal: input.claimSignal,
             readRunnerTerminal: input.readRunnerTerminal,
             readRunnerLiveness: input.readRunnerLiveness,
+            inspectDetachedRunner: input.inspectDetachedRunner,
           }),
         };
       } catch (error) {
@@ -3376,6 +3527,7 @@ async function executeAssignedAbsurdAttempt(input: {
             options,
           ),
         ),
+      inspectDetachedRunner: deps.inspectDetachedRunner,
     });
     const finalizeSuspensionProgress = () =>
       runWithAbsurdExecutionLeaseHeartbeat({
@@ -3582,6 +3734,7 @@ async function executeAssignedAbsurdAttempt(input: {
             options,
           ),
         ),
+      inspectDetachedRunner: deps.inspectDetachedRunner,
     });
     const running = await deps.runWithClient((client) =>
       markPostgresSchedulerAttemptRunning(
@@ -5015,9 +5168,10 @@ export async function enforceRuntimeTrafficPolicyBeforeSandboxStart(input: {
  * Truth ladder:
  *  1. The runner's pushed terminal persisted on its attempt row.
  *  2. A fresh heartbeat re-parks the same detached runner.
- *  3. A stale heartbeat or hard ceiling writes one failed terminal without
- *     asking Daytona. Cleanup observes Daytona only after durable terminal
- *     truth exists.
+ *  3. A captured result recovered from the sandbox.
+ *  4. A hard ceiling, or a stale heartbeat the provider proves is final,
+ *     writes one failed terminal. A stale heartbeat without that proof
+ *     re-parks: a heartbeat gap alone never ends a run.
  *
  * A detached runner terminal is always terminal for its scheduler attempt.
  * By the time a sandbox can push an outcome, customer code may have started
@@ -5035,7 +5189,7 @@ export async function enforceRuntimeTrafficPolicyBeforeSandboxStart(input: {
  *    `resolveRunnerSuspension` persists its obligation before typed waiting.
  *    Provider deletion never delays publishing the user's wait.
  */
-async function resolveDetachedRunnerOutcome(input: {
+export async function resolveDetachedRunnerOutcome(input: {
   runId: string;
   suspension: DetachedRunnerSuspension;
   checkpoint: PlayCheckpoint;
@@ -5080,7 +5234,16 @@ async function resolveDetachedRunnerOutcome(input: {
     result: PlayRunnerResult,
   ): Promise<PlayRunnerResult> => {
     await recordWorkCompletion(result);
-    return result;
+    // `runtimeBackend` is the launch's selector and fallback can leave it
+    // pointing at a provider that never ran this sandbox. Record the one that
+    // did, including on terminals the runner never got to write.
+    return {
+      ...result,
+      stats: {
+        ...result.stats,
+        sandboxProvider: suspension.sandboxProvider ?? 'daytona',
+      },
+    };
   };
   const settleFirstWriteWinner = async (
     candidate: PlayRunnerResult,
@@ -5112,9 +5275,9 @@ async function resolveDetachedRunnerOutcome(input: {
     return settle(stored);
   }
 
-  // No pushed terminal. The scheduler owns this decision: never make a
-  // terminal depend on a Daytona lookup, because Daytona may be the failed
-  // component. A concurrent terminal remains allowed to win below.
+  // No pushed terminal. A provider outage must not fail a run, so only a
+  // positive provider answer does; an unavailable provider leaves the hard
+  // ceiling to end it. A concurrent terminal remains allowed to win below.
   const now = Date.now();
   // A liveness-store outage is not evidence that the sandbox died. Let the
   // worker retry this read rather than producing a false terminal failure.
@@ -5138,43 +5301,47 @@ async function resolveDetachedRunnerOutcome(input: {
     configuredHeartbeatTimeoutMs >= 0
       ? configuredHeartbeatTimeoutMs
       : RUNTIME_CLAIM_LEASE_SECONDS * 1000;
+  const reparkDetachedRunner = (): PlayRunnerResult => ({
+    status: 'suspended',
+    suspension,
+    logs: [],
+    stats: {},
+    steps: [],
+    checkpoint: input.checkpoint,
+    tableNamespace: null,
+  });
   if (!reachedCeiling && heartbeatAgeMs !== null) {
     if (heartbeatAgeMs < heartbeatTimeoutMs) {
       // We woke on an older deadline while the runner renewed liveness. Park
       // again from the new durable timestamp; do not touch Daytona.
-      return {
-        status: 'suspended',
-        suspension,
-        logs: [],
-        stats: {},
-        steps: [],
-        checkpoint: input.checkpoint,
-        tableNamespace: null,
-      };
+      return reparkDetachedRunner();
     }
   }
-  // This event is consumed directly by the operational-health dashboard.
-  // Keep its second argument strict JSON so Fly's text log stream remains an
-  // executable producer contract, independent of Bun's object-inspect format.
-  console.error(
-    '[absurd-runtime.worker] detached_runner_liveness_expired',
-    JSON.stringify({
-      runId: input.runId,
-      runnerAttempt: suspension.runnerAttempt,
-      sandboxId: suspension.sandboxId,
-      sessionId: suspension.sessionId,
-      cmdId: suspension.cmdId,
-      startedAtMs: suspension.startedAtMs,
-      heartbeatTimeoutMs,
-      ceilingMs: suspension.ceilingMs,
-      observedAtMs: now,
-      reachedCeiling,
-      liveness,
-      heartbeatAgeMs,
-      pushedTerminalPresent: false,
-    }),
-  );
+  const reportLivenessExpired = () => {
+    // This event is consumed directly by the operational-health dashboard.
+    // Keep its second argument strict JSON so Fly's text log stream remains an
+    // executable producer contract, independent of Bun's object-inspect format.
+    console.error(
+      '[absurd-runtime.worker] detached_runner_liveness_expired',
+      JSON.stringify({
+        runId: input.runId,
+        runnerAttempt: suspension.runnerAttempt,
+        sandboxId: suspension.sandboxId,
+        sessionId: suspension.sessionId,
+        cmdId: suspension.cmdId,
+        startedAtMs: suspension.startedAtMs,
+        heartbeatTimeoutMs,
+        ceilingMs: suspension.ceilingMs,
+        observedAtMs: now,
+        reachedCeiling,
+        liveness,
+        heartbeatAgeMs,
+        pushedTerminalPresent: false,
+      }),
+    );
+  };
   if (reachedCeiling) {
+    reportLivenessExpired();
     return settleFirstWriteWinner({
       status: 'failed',
       error: `${runtimeLimitExceededCause(runtimeLimitSeconds)} Detached runner reached its hard execution ceiling without a terminal result. Sandbox ${suspension.sandboxId}. The run was stopped and was not retried; completed row state remains persisted.`,
@@ -5189,17 +5356,14 @@ async function resolveDetachedRunnerOutcome(input: {
   // bounded terminal push. A receipt-gateway outage can exhaust that push and
   // expire liveness even though the sandbox cleanly stopped itself. Recover
   // only that already-written result before synthesizing RUNNER_LOST: this
-  // does not execute customer code, and an unavailable inspection preserves
-  // the existing conservative failure below.
-  let inspection: {
-    exitCode: number | null;
-    result: PlayRunnerResult | null;
-    diagnosis?: { stage: string; detail: string | null };
-  } | null = null;
+  // does not execute customer code.
+  const provenGone = detachedRunnerProvenGone.has(suspension);
+  let inspection = detachedRunnerProvenGone.get(suspension) ?? null;
+  detachedRunnerProvenGone.delete(suspension);
   let inspectionFailed = false;
   if (input.inspectDetachedRunner) {
     try {
-      inspection = await input.inspectDetachedRunner(suspension);
+      inspection ??= await input.inspectDetachedRunner(suspension);
       if (inspection?.result && inspection.result.status !== 'suspended') {
         console.info(
           '[absurd-runtime.worker] detached_runner_liveness_salvaged',
@@ -5240,6 +5404,32 @@ async function resolveDetachedRunnerOutcome(input: {
       );
     }
   }
+  // Inspection takes seconds. A terminal or heartbeat that landed meanwhile
+  // outranks everything read before it.
+  const storedDuringInspection = parseDetachedRunnerResult(
+    await input.readRunnerTerminal(suspension.runnerAttempt),
+  );
+  if (storedDuringInspection) {
+    return settle(storedDuringInspection);
+  }
+  const latestLiveness = await input.readRunnerLiveness();
+  const latestHeartbeatAtMs = latestLiveness?.heartbeatAt
+    ? Date.parse(latestLiveness.heartbeatAt)
+    : Number.NaN;
+  if (
+    Number.isFinite(latestHeartbeatAtMs) &&
+    !(latestHeartbeatAtMs <= heartbeatAtMs)
+  ) {
+    return reparkDetachedRunner();
+  }
+  if (
+    input.inspectDetachedRunner &&
+    !provenGone &&
+    !detachedRunnerInspectionProvesGone(inspection)
+  ) {
+    return reparkDetachedRunner();
+  }
+  reportLivenessExpired();
   const safeDiagnosticLabel = (value: unknown): string =>
     typeof value === 'string' && /^[a-z0-9_]{1,80}$/i.test(value)
       ? value

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/postgres.ts

@@ -15346,9 +15346,17 @@ export function attachRunnerWorkProgressMetadata(
     ...outputWarnings,
     ...ctxFetchHttpWarnings,
   ].slice(0, 16);
+  const sandboxProvider = (
+    runnerResult as { stats?: { sandboxProvider?: unknown } }
+  ).stats?.sandboxProvider;
+  const provenSandboxProvider =
+    sandboxProvider === 'daytona' || sandboxProvider === 'modal'
+      ? sandboxProvider
+      : null;
   if (
     (total === null || skipped === null || metadata?.workProgress) &&
     !runLogTail &&
+    !provenSandboxProvider &&
     !runtimeResources &&
     !runtimeCounters &&
     !metadata?.runtimeCounters &&
@@ -15390,6 +15398,9 @@ export function attachRunnerWorkProgressMetadata(
       ...(rowOutcomes ? { rowOutcomes } : {}),
       ...(runLogTail ? { runLogTail } : {}),
       ...(runtimeResources ? { runtimeResources } : {}),
+      ...(provenSandboxProvider
+        ? { sandboxProvider: provenSandboxProvider }
+        : {}),
       ...(mergedOutputWarnings.length > 0
         ? { outputWarnings: mergedOutputWarnings }
         : {}),

package/dist/cli/auth-GUZWKNXM.js

@@ -0,0 +1,40 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk33FEF4RHjs = require('./chunk-33FEF4RH.js');
+require('./chunk-SJH66N73.js');
+require('./chunk-VXBEHDM6.js');
+require('./chunk-ALJJRZNJ.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-DIAWYWT5.js');
+require('./chunk-7V3OKSB2.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunk33FEF4RHjs.EXIT_WORKSPACE_MISMATCH; exports.authStatusLine = _chunk33FEF4RHjs.authStatusLine; exports.clearPendingClaim = _chunk33FEF4RHjs.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunk33FEF4RHjs.clearSatisfiedPendingClaim; exports.handleRegister = _chunk33FEF4RHjs.handleRegister; exports.handleStatus = _chunk33FEF4RHjs.handleStatus; exports.handleWait = _chunk33FEF4RHjs.handleWait; exports.httpJson = _chunk33FEF4RHjs.httpJson; exports.readPendingAuthClaim = _chunk33FEF4RHjs.readPendingAuthClaim; exports.readStatusBanner = _chunk33FEF4RHjs.readStatusBanner; exports.registerAuthCommands = _chunk33FEF4RHjs.registerAuthCommands; exports.reportSetupCompleted = _chunk33FEF4RHjs.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunk33FEF4RHjs.resolvePendingAuthClaimForResume; exports.statusBannerLine = _chunk33FEF4RHjs.statusBannerLine;

package/dist/cli/{auth-DKZLB6GN.mjs → auth-YNPT3IER.mjs}

@@ -13,13 +13,13 @@ import {
   reportSetupCompleted,
   resolvePendingAuthClaimForResume,
   statusBannerLine
-} from "./chunk-KQUDU3ZE.mjs";
-import "./chunk-PBQSX6ES.mjs";
-import "./chunk-SM5RZ5JC.mjs";
+} from "./chunk-DCZSJON4.mjs";
+import "./chunk-RDAUQGPG.mjs";
+import "./chunk-TECW24CR.mjs";
 import "./chunk-4QF2K7TM.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import "./chunk-HBL4PM5Q.mjs";
-import "./chunk-RFDIXLRX.mjs";
+import "./chunk-LWYOJG66.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {

package/dist/cli/{billing-DOFXWAZR.mjs → billing-TLRVAOXB.mjs}

@@ -2,7 +2,7 @@ import {
   DeeplineClient,
   iterateCursorPages,
   requireBillingIdempotencyKey
-} from "./chunk-2SICEJBN.mjs";
+} from "./chunk-YXCLG3KB.mjs";
 import "./chunk-L2VKAASU.mjs";
 import "./chunk-FAG4DFUC.mjs";
 import "./chunk-EIMG75BT.mjs";
@@ -13,8 +13,8 @@ import {
   openInBrowser,
   printCommandEnvelope,
   shouldEmitJson
-} from "./chunk-PBQSX6ES.mjs";
-import "./chunk-SM5RZ5JC.mjs";
+} from "./chunk-RDAUQGPG.mjs";
+import "./chunk-TECW24CR.mjs";
 import {
   AuthError,
   ConfigError
@@ -23,7 +23,7 @@ import "./chunk-DLIRSHV6.mjs";
 import {
   DeeplineError
 } from "./chunk-HBL4PM5Q.mjs";
-import "./chunk-RFDIXLRX.mjs";
+import "./chunk-LWYOJG66.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 
@@ -200,13 +200,26 @@ function parseSince(raw) {
 function humanize(value) {
   return String(value || "").split("_").filter(Boolean).map((token) => token[0]?.toUpperCase() + token.slice(1)).join(" ") || "Unknown";
 }
+var MONITOR_CHARGE_LABELS = {
+  provider_execution: "preview",
+  webhook_event: "match",
+  create: "setup",
+  reactivate: "reactivation",
+  periodic_renewal: "renewal",
+  subscription_renewal: "renewal"
+};
+function usageOperationLabel(operation) {
+  const [prefix, phase, , tool] = String(operation || "").split(".");
+  const label = phase ? MONITOR_CHARGE_LABELS[phase] : void 0;
+  return prefix === "monitor" && label && tool ? `Monitor ${label}: ${humanize(tool)}` : humanize(operation);
+}
 function recentUsageLines(entries) {
   if (entries.length === 0) {
     return ["Recent activity: none yet"];
   }
   const lines = ["Recent activity:"];
   for (const entry of entries) {
-    const op = `${humanize(entry.provider)} ${humanize(entry.operation)}`.trim();
+    const op = `${humanize(entry.provider)} ${usageOperationLabel(entry.operation)}`.trim();
     const roughUsd = Number(entry.rough_usd_cost);
     const credits = entry.credits !== null && entry.credits !== void 0 && String(entry.credits).trim().length > 0 && Number.isFinite(Number(entry.credits)) ? Number(entry.credits) : null;
     const temporaryHold = entry.charge_state === "temporary_hold";