deepline 0.3.480 → 0.3.481

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

@@ -72,9 +72,7 @@ import {
   RuntimeResourceFenceLostError,
   type PlayRunnerRuntimeResource,
 } from '../runner-backends/types';
-import {
-  daytonaSandboxMatchesOperationIdentity,
-} from '../runner-backends/backends/daytona-labels';
+import { daytonaSandboxMatchesOperationIdentity } from '../runner-backends/backends/daytona-labels';
 import type { PlayBundleArtifact } from '../../plays/artifact-types';
 import {
   readRuntimeSheetRowOutcomeCounts,
@@ -279,7 +277,6 @@ import {
   absurdIntegrationEventBoundaryOutput,
   absurdIntegrationEventName,
   absurdAdoptionQueuesForReleases,
-  absurdContinuationWorkerId,
   absurdQueueNameForRelease,
   absurdReleaseIdForLaunch,
   absurdRuntimeApiFromLaunch,
@@ -2020,9 +2017,15 @@ export async function executeAbsurdRuntimeLaunch(
   params: AbsurdPlayRunTaskParams,
   ctx: TaskContext,
   deps: AbsurdRuntimeWorkerDeps,
+  queueName = ABSURD_RUNS_QUEUE,
 ): Promise<AbsurdRuntimeResult> {
   try {
-    return await createAbsurdAttemptAdapter({ params, ctx, deps }).execute();
+    return await createAbsurdAttemptAdapter({
+      params,
+      ctx,
+      deps,
+      queueName,
+    }).execute();
   } catch (error) {
     if (!isRuntimeSchedulerCapacityError(error)) throw error;
     throw new DeferTask(
@@ -2673,10 +2676,16 @@ export function createAbsurdAttemptAdapter(input: {
   params: AbsurdPlayRunTaskParams;
   ctx: TaskContext;
   deps: AbsurdRuntimeWorkerDeps;
+  queueName?: string;
 }): AbsurdAttemptAdapter {
   return {
     execute: () =>
-      executeAbsurdAttemptAdapter(input.params, input.ctx, input.deps),
+      executeAbsurdAttemptAdapter(
+        input.params,
+        input.ctx,
+        input.deps,
+        input.queueName,
+      ),
   };
 }
 
@@ -2689,6 +2698,7 @@ async function prepareAbsurdAttempt(input: {
   deps: AbsurdRuntimeWorkerDeps;
   options: Pick<PostgresSchedulerOptions, 'schema'>;
   runId: string;
+  queueName: string;
 }) {
   return input.deps.runWithClient(
     async (client) => {
@@ -2742,7 +2752,7 @@ async function prepareAbsurdAttempt(input: {
         runReleaseId,
         workerReleaseId,
         laneClaiming: laneState.laneClaiming,
-        parkedInAdoptableWait: laneState.parkedInAdoptableWait,
+        claimedQueue: input.queueName,
       });
       if (disposition.kind === 'refuse') {
         // Reuse the one operator-actionable message and remediation.
@@ -2753,7 +2763,16 @@ async function prepareAbsurdAttempt(input: {
         });
       }
       if (disposition.kind === 'defer') {
-        throw new DeferTask(disposition.reason, disposition.delaySeconds);
+        console.info('[absurd-runtime.worker] rearmed_lane_deferred', {
+          runId: input.runId,
+          runReleaseId,
+          workerReleaseId,
+          queue: input.queueName,
+        });
+        throw new DeferTask(
+          `Run ${input.runId} lane resumed claiming; yielding its queue claim.`,
+          30,
+        );
       }
       const adoptedParkedWake =
         disposition.kind === 'adopt'
@@ -2823,6 +2842,37 @@ async function prepareAbsurdAttempt(input: {
         };
       }
 
+      if (laneState.waitKind === 'detached_runner') {
+        // State changed or its fence is unavailable. A live external execution
+        // must never fall through to fresh assignment after a failed resume.
+        const current = await readPostgresSchedulerResult(
+          client,
+          input.runId,
+          input.options,
+        );
+        if (
+          current &&
+          ['completed', 'failed', 'cancelled'].includes(current.status)
+        ) {
+          return {
+            kind: 'already_terminal' as const,
+            launch,
+            existing: current,
+          };
+        }
+        console.error('[runtime.scheduler.detached_resume_authority_lost]', {
+          runId: input.runId,
+          attempt: preparation.nextAttempt - 1,
+          runReleaseId,
+          workerReleaseId,
+          status: current?.status ?? null,
+        });
+        throw new DeferTask(
+          `Run ${input.runId} detached runner lacks resumable attempt authority; inspect its persisted fence.`,
+          30,
+        );
+      }
+
       const generation = preparation.nextAttempt;
       const leaseToken = randomUUID();
       const initialRuntimeResource = isManagedSandboxRuntimeBackend(
@@ -2882,6 +2932,7 @@ async function prepareAbsurdAttemptForTask(input: {
   deps: AbsurdRuntimeWorkerDeps;
   options: Pick<PostgresSchedulerOptions, 'schema'>;
   runId: string;
+  queueName: string;
 }) {
   try {
     return await prepareAbsurdAttempt(input);
@@ -2966,6 +3017,7 @@ async function executeAbsurdAttemptAdapter(
   params: AbsurdPlayRunTaskParams,
   ctx: TaskContext,
   deps: AbsurdRuntimeWorkerDeps,
+  queueName = ABSURD_RUNS_QUEUE,
 ): Promise<AbsurdRuntimeResult> {
   const schedulerOptions: AbsurdSchedulerOptions =
     normalizeAbsurdSchedulerOptions({ schema: params.schedulerSchema ?? null });
@@ -2974,7 +3026,7 @@ async function executeAbsurdAttemptAdapter(
   const runId = params.runId;
 
   const prepareAttempt = () =>
-    prepareAbsurdAttemptForTask({ ctx, deps, options, runId });
+    prepareAbsurdAttemptForTask({ ctx, deps, options, runId, queueName });
   let prepared = await prepareAttempt();
   while (prepared.kind === 'created_projection_pending') {
     const delaySeconds = prepared.delaySeconds;
@@ -4666,8 +4718,7 @@ async function executeAssignedAbsurdAttempt(input: {
                       client,
                       {
                         operationKey: intent.leaseId,
-                        providerOperationToken:
-                          intent.providerOperationToken,
+                        providerOperationToken: intent.providerOperationToken,
                         orgId: intent.orgId,
                         runId: intent.runId,
                         sandboxId: intent.sandboxId,
@@ -6417,6 +6468,7 @@ export function createAbsurdRuntimeTasks(
       params as AbsurdPlayRunTaskParams,
       ctx,
       resolved,
+      queue,
     ),
   );
   // Register on both the current lane and every adopted continuation lane.
@@ -7964,6 +8016,62 @@ export const ABSURD_LANE_ADOPTION_SLOTS = 2;
 /** Upper bound on simultaneously attached retired lanes. */
 export const ABSURD_LANE_ADOPTION_MAX_QUEUES = 4;
 
+export async function discoverAbsurdAdoptionReleaseIds(
+  client: PostgresSchedulerQueryClient,
+  input: {
+    environment: 'preview' | 'production';
+    excludeReleaseIds: string[];
+  },
+  options: Pick<PostgresSchedulerOptions, 'schema'> = {},
+): Promise<string[]> {
+  const lanes = await listPostgresSchedulerAdoptableReleaseLanes(
+    client,
+    input,
+    options,
+  );
+  if (lanes.length === 0) return [];
+  // Historical scheduler rows do not prove an engine task is runnable. In
+  // particular, never manufacture empty queues for orphaned Run records.
+  const presence = await client.query<{ queue: string; present: boolean }>(
+    `SELECT queue,
+            to_regclass(format('absurd.%I', 't_' || queue)) IS NOT NULL
+            AND to_regclass(format('absurd.%I', 'r_' || queue)) IS NOT NULL
+            AND EXISTS (
+              SELECT 1 FROM pg_attribute
+              WHERE attrelid = to_regclass(format('absurd.%I', 't_' || queue))
+                AND attname = 'cancel_at' AND NOT attisdropped
+            ) AS present
+       FROM unnest($1::text[]) AS queues(queue)`,
+    [lanes.map((lane) => absurdQueueNameForRelease(lane.releaseId))],
+  );
+  const existing = new Set(
+    presence.rows.filter((row) => row.present).map((row) => row.queue),
+  );
+  const due: string[] = [];
+  for (const lane of lanes) {
+    const queue = absurdQueueNameForRelease(lane.releaseId);
+    if (!existing.has(queue)) continue;
+    // Cancelled engine tasks cannot be claimed. Keep their existing durable
+    // cancellation owner progressing without spending consumer attachments.
+    await reconcileAbsurdRuntimeCancellations({
+      client,
+      queue,
+      schedulerOptions: options,
+    });
+    const next = await readAbsurdQueueNextDue(client, queue);
+    if (next.dueAt && next.dueAt.getTime() <= Date.now()) {
+      due.push(lane.releaseId);
+    }
+  }
+  if (existing.size < lanes.length) {
+    console.warn('[absurd-runtime.worker] adoption_engine_queue_unreadable', {
+      candidateQueues: lanes.length,
+      unreadableQueues: lanes.length - existing.size,
+    });
+  }
+  return due;
+}
+
 export type AbsurdAdoptedLaneWorker = {
   queue: string;
   close: () => Promise<void>;
@@ -8023,13 +8131,9 @@ export function absurdAdoptedLaneWorkerOptions(input: {
   onError: (error: Error) => void;
 }): WorkerOptions {
   return {
-    // The `:continuations` suffix is the engine-side half of the adoption
-    // rule: `claim_task` admits this worker only for runs still sleeping
-    // or carrying an event-wake payload.
-    workerId: absurdContinuationWorkerId({
-      workerBase: input.workerBase,
-      queue: input.queue,
-    }),
+    // Drain the stopped queue through ordinary engine claims, including fresh
+    // queued work and retries. No second continuation-only engine filter.
+    workerId: `${input.workerBase}:${input.queue}:drain`,
     concurrency: ABSURD_LANE_ADOPTION_SLOTS,
     claimTimeout: HEARTBEAT_CLAIM_TIMEOUT_SECONDS,
     pollInterval: ABSURD_IDLE_POLL_INTERVAL_SECONDS,
@@ -9946,7 +10050,7 @@ export async function startRuntimeWorkerHost(
   }
 
   // One live version (lane handoff): attach the queues of lanes that have stopped
-  // claiming and still hold parked durable waits, so a retired lane does not
+  // claiming and still hold due unfinished engine work, so a retired lane does not
   // have to stay alive until its last sleeping run wakes. A draining lane
   // attaches nothing — it is on its way out itself.
   const adoptionStop = new AbortController();
@@ -9960,8 +10064,8 @@ export async function startRuntimeWorkerHost(
       workerReleaseId: releaseId,
       signal: adoptionStop.signal,
       discoverAdoptableReleaseIds: async () => {
-        const lanes = await withRuntimeSchedulerClient(poolOptions, (client) =>
-          listPostgresSchedulerAdoptableReleaseLanes(
+        return withRuntimeSchedulerClient(poolOptions, (client) =>
+          discoverAbsurdAdoptionReleaseIds(
             client,
             {
               environment: releaseEnvironment,
@@ -9970,7 +10074,6 @@ export async function startRuntimeWorkerHost(
             schedulerOptions.schema ? { schema: schedulerOptions.schema } : {},
           ),
         );
-        return lanes.map((lane) => lane.releaseId);
       },
       startAdoptionWorker: async (adoptedQueue) => {
         const adoptedClient = createAbsurdRuntimeClient(

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

@@ -282,56 +282,27 @@ export function assertAbsurdReleaseLaneMatches(input: {
   throw new Error(
     `absurd release lane mismatch for run ${input.runId}: the run was launched ` +
       `on release "${input.runReleaseId}" but this worker serves release ` +
-      `"${input.workerReleaseId}". A run must finish on the release that ` +
-      `launched it. Remediation: start a lane machine for "${input.runReleaseId}" ` +
+      `"${input.workerReleaseId}" while its admission lane still claims. ` +
+      `Remediation: reconcile the claiming switch or serve "${input.runReleaseId}" ` +
       `(queue ${absurdQueueNameForRelease(input.runReleaseId)}).`,
   );
 }
 
-/**
- * Seconds a foreign, non-adoptable task is parked for before the owning lane
- * gets another chance at it. Matches the historical release-guard deferral so
- * the observable retry cadence is unchanged.
- */
-export const ABSURD_LANE_ADOPTION_DEFER_SECONDS = 30;
-
-/** Absurd worker-id suffix that opts a poll loop into cross-lane claims. */
-export const ABSURD_CONTINUATION_WORKER_SUFFIX = ':continuations';
-
-/**
- * Worker id for an adoption poll loop. The `:continuations` suffix is load
- * bearing: vendored `claim_task` patch (g) admits such a worker only for runs
- * still `sleeping` or carrying a non-null event-wake payload, so a fresh or
- * ordinary retry-pending task on the adopted queue is never handed to it.
- */
-export function absurdContinuationWorkerId(input: {
-  workerBase: string;
-  queue: string;
-}): string {
-  return `${input.workerBase}:${input.queue}${ABSURD_CONTINUATION_WORKER_SUFFIX}`;
-}
-
 export type AbsurdReleaseLaneDisposition =
   /** The run belongs to this worker's own lane. */
   | { kind: 'own' }
-  /** A retired lane's parked durable wait resumes on this newer release. */
+  /** A stopped lane drains on this compatible release. */
   | { kind: 'adopt'; adoptedReleaseId: string }
-  /** Foreign, not adoptable: park it without spending a task attempt. */
-  | { kind: 'defer'; reason: string; delaySeconds: number }
-  /** Foreign lane that still claims — operator error, fail loudly. */
+  /** An attached drainer yields after its lane resumes claiming. */
+  | { kind: 'defer' }
+  /** The claimed queue does not belong to the active foreign lane. */
   | { kind: 'refuse' };
 
 /**
- * Decide what this worker may do with a claimed run, given the durable lane
- * facts read from the scheduler Postgres.
- *
- * This is the adapter half of the adoption rule (lane handoff). The engine's
- * `:continuations` fence already stops most cross-lane claims; this decides the
- * cases the engine cannot see, because `sleeping` in the engine covers durable
- * suspensions, retry backoff, and capacity deferrals alike.
- *
- * `laneClaiming` and `parkedInAdoptableWait` come from
- * `readPostgresSchedulerRunLaneState`, never from a timer or a machine count.
+ * Admission ownership ends when a lane stops claiming. Thereafter the existing
+ * engine claim and attempt fence authorize compatible workers to drain it.
+ * A rearmed lane keeps its own work; attached drainers yield until discovery
+ * detaches them. A mismatched physical queue remains an operator error.
  */
 export function resolveAbsurdReleaseLaneDisposition(input: {
   runId: string;
@@ -339,8 +310,8 @@ export function resolveAbsurdReleaseLaneDisposition(input: {
   workerReleaseId: string;
   /** Does the run's OWN lane still claim work off its queue? */
   laneClaiming: boolean;
-  /** Is the run parked in a sleep/integration-event wait right now? */
-  parkedInAdoptableWait: boolean;
+  /** Actual engine registration queue, never a caller-authored launch field. */
+  claimedQueue?: string;
 }): AbsurdReleaseLaneDisposition {
   if (
     input.runReleaseId === input.workerReleaseId ||
@@ -349,18 +320,10 @@ export function resolveAbsurdReleaseLaneDisposition(input: {
   ) {
     return { kind: 'own' };
   }
-  // A lane that still claims owns every one of its rows. Reaching this branch
-  // means a machine is polling a queue it does not serve; stay loud.
-  if (input.laneClaiming) return { kind: 'refuse' };
-  if (!input.parkedInAdoptableWait) {
-    return {
-      kind: 'defer',
-      reason:
-        `Run ${input.runId} rides retired release lane "${input.runReleaseId}" ` +
-        `but is not parked in an adoptable durable wait. Ordinary queued and ` +
-        `running work is never adopted; leaving it for its owning lane.`,
-      delaySeconds: ABSURD_LANE_ADOPTION_DEFER_SECONDS,
-    };
+  if (input.laneClaiming) {
+    return input.claimedQueue === absurdQueueNameForRelease(input.runReleaseId)
+      ? { kind: 'defer' }
+      : { kind: 'refuse' };
   }
   return { kind: 'adopt', adoptedReleaseId: input.runReleaseId };
 }

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

@@ -1036,6 +1036,8 @@ export function postgresSchedulerNotifyChannel(
   return `${channel.slice(0, 63 - fingerprint.length - 1)}_${fingerprint}`;
 }
 const DEFAULT_POLL_INTERVAL_MS = 1_000;
+const STARTUP_TERMINAL_POLL_INTERVAL_MS = 250;
+const STARTUP_TERMINAL_POLL_DURATION_MS = 2_000;
 const DEFAULT_RESULT_TIMEOUT_MS = 30_000;
 
 const POSTGRES_SCHEDULER_NOT_CONFIGURED_MESSAGE =
@@ -7228,23 +7230,8 @@ export async function withPostgresSchedulerClosedReleaseAdmission<T>(
   }
 }
 
-/**
- * Scheduler-run statuses and suspension kinds a newer release lane may adopt.
- *
- * A run is adoptable only while it is parked in a durable wait whose wake is
- * pure scheduler state: a timed sleep, or an integration/HITL event boundary.
- * `detached_runner` is deliberately absent — that suspension holds live sandbox
- * compute behind a lane-pinned executor token and a scheduler-owned heartbeat
- * deadline, so its wake belongs to the lane that started the runner.
- */
-export const POSTGRES_SCHEDULER_ADOPTABLE_WAIT_KINDS = [
-  'sleep',
-  'integration_event',
-  'integration_event_batch',
-] as const;
-
-export type PostgresSchedulerAdoptableWaitKind =
-  (typeof POSTGRES_SCHEDULER_ADOPTABLE_WAIT_KINDS)[number];
+/** Once admission stops, compatible workers drain all remaining Run states. */
+const ADOPTABLE_RUN_SQL = "runs.status IN ('queued', 'running', 'waiting')";
 
 const POSTGRES_SCHEDULER_RELEASE_CLAIMING_CONTROL_PREFIX =
   'runtime_release_claiming:';
@@ -7376,6 +7363,7 @@ export type PostgresSchedulerRunLaneState = {
   environment: 'preview' | 'production';
   status: string;
   waitKind: string | null;
+  /** Legacy projection name: all nonterminal work is resumable after admission stops. */
   parkedInAdoptableWait: boolean;
   laneClaiming: boolean;
 };
@@ -7393,9 +7381,6 @@ type RunLaneStateRow = {
 function runLaneStateSelectionSql(
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
 ): string {
-  const adoptableKinds = POSTGRES_SCHEDULER_ADOPTABLE_WAIT_KINDS.map(
-    (kind) => `'${kind}'`,
-  ).join(', ');
   return `
         nullif(btrim(runs.launch_json ->> 'absurdReleaseId'), '') AS release_id,
         coalesce(
@@ -7409,11 +7394,7 @@ function runLaneStateSelectionSql(
         ) AS environment,
         runs.status AS status,
         nullif(btrim(runs.suspension_json ->> 'kind'), '') AS wait_kind,
-        (
-          runs.status = 'waiting'
-          AND nullif(btrim(runs.suspension_json ->> 'kind'), '')
-              IN (${adoptableKinds})
-        ) AS parked,
+        ${ADOPTABLE_RUN_SQL} AS parked,
         (
           SELECT (control.value ->> 'claiming')::boolean
           FROM ${tableName('control', options)} AS control
@@ -7447,11 +7428,11 @@ function runLaneStateFromRow(
 
 /**
  * One transactional read of everything the lane guard needs about a claimed
- * run: which lane owns it, whether that lane still claims, and whether the run
- * is parked in a wait a newer lane may adopt.
+ * run: which lane owns it, whether that lane still claims, and whether a compatible worker may
+ * continue its existing work.
  *
- * The scheduler run row — not the engine task row — is the authority on "parked
- * in a durable wait". The engine cannot tell a durable suspension from a retry
+ * The scheduler run and attempt rows — not the engine task row — authorize
+ * continuation. The engine cannot tell a durable suspension from a retry
  * backoff or a capacity `DeferTask`, all of which sit in `sleeping`.
  */
 export async function readPostgresSchedulerRunLaneState(
@@ -7472,9 +7453,9 @@ export async function readPostgresSchedulerRunLaneState(
 }
 
 /**
- * Discover the lanes whose parked durable waits the caller may adopt: lanes
- * that have explicitly stopped claiming AND still hold at least one adoptable
- * parked run in the caller's own release environment.
+ * Discover stopped lanes with unfinished work in the caller's release
+ * environment. No wait-kind or retry-history classification is needed: the
+ * existing task claim and attempt ingress own execution authority.
  *
  * Both halves come from the runtime scheduler Postgres in one query, so a lane
  * cannot be attached on the strength of a stale registry projection.
@@ -7487,9 +7468,6 @@ export async function listPostgresSchedulerAdoptableReleaseLanes(
   },
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
 ): Promise<Array<{ releaseId: string; parkedRuns: number }>> {
-  const adoptableKinds = POSTGRES_SCHEDULER_ADOPTABLE_WAIT_KINDS.map(
-    (kind) => `'${kind}'`,
-  ).join(', ');
   const result = await client.query<{
     release_id: string;
     parked_runs: string;
@@ -7500,9 +7478,7 @@ export async function listPostgresSchedulerAdoptableReleaseLanes(
           nullif(btrim(runs.launch_json ->> 'absurdReleaseId'), '') AS release_id,
           count(*)::text AS parked_runs
         FROM ${tableName('runs', options)} AS runs
-        WHERE runs.status = 'waiting'
-          AND nullif(btrim(runs.suspension_json ->> 'kind'), '')
-              IN (${adoptableKinds})
+        WHERE ${ADOPTABLE_RUN_SQL}
           AND nullif(btrim(runs.launch_json ->> 'absurdReleaseId'), '') IS NOT NULL
           AND NOT (
             nullif(btrim(runs.launch_json ->> 'absurdReleaseId'), '')
@@ -7540,24 +7516,22 @@ export async function listPostgresSchedulerAdoptableReleaseLanes(
 
 /**
  * Retire-gate half for a lane that has stopped claiming: how much of its
- * remaining non-terminal work another lane has already taken responsibility
- * for. Retirement may ignore these rows because their wakes are adoptable.
+ * remaining work parked without live compute. This is deliberately stricter
+ * than claim eligibility: a transferable Run is not proof that its old machine
+ * can be retired. Keep engine-depth and resource-cleanup gates unchanged.
  */
 export async function countPostgresSchedulerAdoptableParkedRuns(
   client: PostgresSchedulerQueryClient,
   input: { releaseId: string },
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
 ): Promise<number> {
-  const adoptableKinds = POSTGRES_SCHEDULER_ADOPTABLE_WAIT_KINDS.map(
-    (kind) => `'${kind}'`,
-  ).join(', ');
   const result = await client.query<{ n: string }>(
     `
       SELECT count(*)::text AS n
       FROM ${tableName('runs', options)} AS runs
       WHERE runs.status = 'waiting'
-        AND nullif(btrim(runs.suspension_json ->> 'kind'), '')
-            IN (${adoptableKinds})
+        AND runs.suspension_json ->> 'kind'
+            IN ('sleep', 'integration_event', 'integration_event_batch')
         AND runs.launch_json ->> 'absurdReleaseId' = $1
     `,
     [input.releaseId],
@@ -25791,17 +25765,29 @@ export function postgresSchedulerRunHandle(
 
   return {
     runId,
-    observe: async function* observe({ signal } = {}) {
+    observe: async function* observe({ signal, startupPolling } = {}) {
       const poolOptions = resolve();
       const hubLease = acquireTerminalHub(poolOptions, options);
       const hub = hubLease?.hub ?? null;
+      const startupPollDeadline = startupPolling
+        ? Date.now() + STARTUP_TERMINAL_POLL_DURATION_MS
+        : 0;
       try {
         while (!signal?.aborted) {
+          const startupRemainingMs = startupPollDeadline - Date.now();
+          const pollIntervalMs =
+            startupRemainingMs > 0
+              ? Math.min(
+                  waitIntervalMs(hub),
+                  STARTUP_TERMINAL_POLL_INTERVAL_MS,
+                  startupRemainingMs,
+                )
+              : waitIntervalMs(hub);
           // Subscribe before reading so a notify between read and wait cannot
           // be missed.
           const hint = hub
-            ? waitForTerminalHint(hub, runId, waitIntervalMs(hub))
-            : waitForTerminalPoll(waitIntervalMs(hub));
+            ? waitForTerminalHint(hub, runId, pollIntervalMs)
+            : waitForTerminalPoll(pollIntervalMs);
           const cancelOnAbort = () => hint.cancel();
           signal?.addEventListener('abort', cancelOnAbort, { once: true });
           try {

package/dist/bundling-sources/shared_libs/security/receipt-admission-token.ts

@@ -337,6 +337,50 @@ export async function mintSqlListenerDispatchRetryToken(input: {
   });
 }
 
+/** A durable account-creation intent may prepare only its own Customer DB. */
+export async function mintCustomerDbPreparationToken(input: {
+  orgId: string;
+  requestId: string;
+  callbackOrigin: string;
+  nowMs?: number;
+}): Promise<string> {
+  const issuedAt = Math.floor((input.nowMs ?? Date.now()) / 1000);
+  return mint({
+    v: TOKEN_VERSION,
+    iss: TOKEN_ISSUER,
+    aud: 'deepline.customer_db.prepare',
+    purpose: 'customer_db_preparation',
+    org_id: input.orgId,
+    request_id: input.requestId,
+    callback_origin: input.callbackOrigin,
+    iat: issuedAt,
+    exp: issuedAt + TOKEN_TTL_SECONDS,
+  });
+}
+
+export async function verifyCustomerDbPreparationToken(
+  token: string,
+  callbackOrigin: string,
+  nowMs = Date.now(),
+): Promise<{ orgId: string; requestId: string }> {
+  const claims = await verifyObservationToken(
+    token,
+    'deepline.customer_db.prepare',
+    nowMs,
+  );
+  if (
+    claims.purpose !== 'customer_db_preparation' ||
+    claims.callback_origin !== callbackOrigin ||
+    typeof claims.org_id !== 'string' ||
+    !claims.org_id ||
+    typeof claims.request_id !== 'string' ||
+    claims.request_id !== `customer-db:${claims.org_id}`
+  ) {
+    throw new Error('Invalid Customer DB preparation authority.');
+  }
+  return { orgId: claims.org_id, requestId: claims.request_id };
+}
+
 /** Authorizes one invoice/threshold observation, never a payment, grant or fleet scan. */
 export async function mintBillingDeliveryToken(input: {
   stripeInvoiceId: string;

package/dist/cli/auth-EQWYBNIE.js

@@ -0,0 +1,43 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk6VKDKATOjs = require('./chunk-6VKDKATO.js');
+require('./chunk-6WWBVWFQ.js');
+require('./chunk-VBDR2DP6.js');
+require('./chunk-WF5QE2IW.js');
+require('./chunk-ALJJRZNJ.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-DIAWYWT5.js');
+require('./chunk-27BYXQU4.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunk6VKDKATOjs.EXIT_WORKSPACE_MISMATCH; exports.authStatusLine = _chunk6VKDKATOjs.authStatusLine; exports.clearPendingClaim = _chunk6VKDKATOjs.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunk6VKDKATOjs.clearSatisfiedPendingClaim; exports.handleRegister = _chunk6VKDKATOjs.handleRegister; exports.handleStatus = _chunk6VKDKATOjs.handleStatus; exports.handleWait = _chunk6VKDKATOjs.handleWait; exports.httpJson = _chunk6VKDKATOjs.httpJson; exports.readPendingAuthClaim = _chunk6VKDKATOjs.readPendingAuthClaim; exports.readStatusBanner = _chunk6VKDKATOjs.readStatusBanner; exports.registerAuthCommands = _chunk6VKDKATOjs.registerAuthCommands; exports.reportApprovalLinkShown = _chunk6VKDKATOjs.reportApprovalLinkShown; exports.reportSetupCompleted = _chunk6VKDKATOjs.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunk6VKDKATOjs.resolvePendingAuthClaimForResume; exports.statusBannerLine = _chunk6VKDKATOjs.statusBannerLine;

package/dist/cli/{auth-KMKFQX7X.mjs → auth-FYY65LYD.mjs}

@@ -14,14 +14,14 @@ import {
   reportSetupCompleted,
   resolvePendingAuthClaimForResume,
   statusBannerLine
-} from "./chunk-PM2CT7HZ.mjs";
-import "./chunk-53LLOGNV.mjs";
-import "./chunk-TXFURKHD.mjs";
-import "./chunk-T7EWDIVM.mjs";
+} from "./chunk-EJTU6X6C.mjs";
+import "./chunk-C7UIUKW6.mjs";
+import "./chunk-VRAOWHXJ.mjs";
+import "./chunk-PDJS6LFI.mjs";
 import "./chunk-4QF2K7TM.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import "./chunk-HBL4PM5Q.mjs";
-import "./chunk-FZ42SO3Q.mjs";
+import "./chunk-FXLMDAAY.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {