deepline 0.3.88 → 0.3.90

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/sandbox-cleanup/job.ts

@@ -0,0 +1,142 @@
+import type {
+  SandboxCleanupInput,
+  SandboxCleanupJob,
+  SandboxCleanupOutcome,
+} from '../../play-runs/sandbox-cleanup/contracts';
+import type { SandboxCleanupPorts } from '../../play-runs/sandbox-cleanup/ports';
+
+/**
+ * Creates the Sandbox Cleanup job.
+ *
+ * Capacity ends only after a provider-confirmed deletion or documented
+ * already-absent result. Every other provider result retains the durable
+ * cleanup obligation and schedules a fenced retry.
+ */
+export function createSandboxCleanupJob(
+  ports: SandboxCleanupPorts,
+): SandboxCleanupJob {
+  return {
+    async reconcile(
+      input: SandboxCleanupInput,
+    ): Promise<SandboxCleanupOutcome> {
+      validate(input);
+      if (
+        input.resource.provider === 'modal' &&
+        !input.resource.routingDomain?.trim()
+      ) {
+        const reason =
+          'missing_routing_domain: Modal cleanup requires its persisted app id.';
+        const blocked = await ports.store.block({
+          resource: input.resource,
+          reason,
+        });
+        return blocked === 'blocked'
+          ? { kind: 'blocked', reason }
+          : { kind: 'completion_rejected', completion: 'missing_obligation' };
+      }
+
+      try {
+        const deletion = await ports.deletion.delete(input);
+        if (deletion.kind === 'failed') {
+          if (deletion.code === 'missing_routing_domain') {
+            const reason = `missing_routing_domain: ${deletion.detail}`.slice(
+              0,
+              2_000,
+            );
+            const blocked = await ports.store.block({
+              resource: input.resource,
+              reason,
+            });
+            return blocked === 'blocked'
+              ? { kind: 'blocked', reason }
+              : {
+                  kind: 'completion_rejected',
+                  completion: 'missing_obligation',
+                };
+          }
+          return await scheduleRetry(ports, input, deletion.detail);
+        }
+
+        // A control-plane retry must never keep a provider-confirmed-deleted
+        // resource consuming capacity. This precedes cleanup row completion.
+        await ports.store.releaseCapacity({ resource: input.resource });
+        const completion = await ports.store.complete({
+          resource: input.resource,
+          providerOutcome: deletion.kind,
+          observedRoutingDomain: deletion.routingDomain,
+        });
+        if (
+          completion === 'completed' ||
+          completion === 'late_success_accepted' ||
+          completion === 'already_deleted'
+        ) {
+          return {
+            kind: 'completed',
+            providerOutcome: deletion.kind,
+            completion,
+          };
+        }
+        // A provider confirmation from the wrong routing domain is not a
+        // completion rejection: it is a real external-side-effect ambiguity.
+        // Preserve the obligation and retry through its existing claim fence.
+        if (completion === 'wrong_routing_domain') {
+          return await scheduleRetry(
+            ports,
+            input,
+            `${input.resource.provider} sandbox ${input.resource.sandboxId} cleanup confirmation used the wrong routing domain.`,
+          );
+        }
+        return { kind: 'completion_rejected', completion };
+      } catch (error) {
+        return await scheduleRetry(
+          ports,
+          input,
+          error instanceof Error ? error.message : String(error),
+        );
+      }
+    },
+  };
+}
+
+async function scheduleRetry(
+  ports: SandboxCleanupPorts,
+  input: SandboxCleanupInput,
+  error: string,
+): Promise<SandboxCleanupOutcome> {
+  const retryAfterMs = retryDelay(input.resource.failureCount + 1);
+  const scheduled = await ports.store.retry({
+    resource: input.resource,
+    error,
+    retryAfterMs,
+  });
+  return scheduled === 'retry_scheduled'
+    ? { kind: 'retry_scheduled', retryAfterMs }
+    : { kind: 'retry_rejected' };
+}
+
+function retryDelay(nextFailureCount: number): number {
+  return Math.min(
+    5 * 60_000,
+    1_000 * 2 ** Math.min(8, Math.max(0, nextFailureCount - 1)),
+  );
+}
+
+function validate(input: SandboxCleanupInput): void {
+  const { resource } = input;
+  if (!resource.sandboxId.trim() || !resource.runId.trim()) {
+    throw new Error('Sandbox Cleanup requires non-empty sandbox and run ids.');
+  }
+  if (!Number.isSafeInteger(resource.attempt) || resource.attempt < 1) {
+    throw new Error('Sandbox Cleanup requires a positive attempt number.');
+  }
+  if (
+    !Number.isSafeInteger(resource.cleanupAttempt) ||
+    resource.cleanupAttempt < 1 ||
+    !Number.isSafeInteger(resource.failureCount) ||
+    resource.failureCount < 0 ||
+    !Number.isFinite(input.timeoutMs) ||
+    input.timeoutMs <= 0
+  ) {
+    throw new Error('Sandbox Cleanup received invalid cleanup state.');
+  }
+}

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/sandbox-cleanup/ports.ts

@@ -0,0 +1,42 @@
+import type {
+  SandboxCleanupDeleteOutcome,
+  SandboxCleanupResource,
+} from '../../play-runs/sandbox-cleanup/contracts';
+
+/** Provider delete proof. A timeout must be reported as `failed`, never cast to deletion. */
+export type SandboxDeletion = {
+  delete(input: {
+    resource: SandboxCleanupResource;
+    timeoutMs: number;
+  }): Promise<SandboxCleanupDeleteOutcome>;
+};
+
+/** Durable cleanup state transitions, all fenced by the claim represented in `resource`. */
+export type SandboxCleanupStore = {
+  releaseCapacity(input: { resource: SandboxCleanupResource }): Promise<void>;
+  complete(input: {
+    resource: SandboxCleanupResource;
+    providerOutcome: 'deleted' | 'already_absent';
+    observedRoutingDomain: string | null;
+  }): Promise<
+    | 'completed'
+    | 'late_success_accepted'
+    | 'already_deleted'
+    | 'missing_obligation'
+    | 'wrong_routing_domain'
+  >;
+  retry(input: {
+    resource: SandboxCleanupResource;
+    error: string;
+    retryAfterMs: number;
+  }): Promise<'retry_scheduled' | 'rejected'>;
+  block(input: {
+    resource: SandboxCleanupResource;
+    reason: string;
+  }): Promise<'blocked' | 'rejected'>;
+};
+
+export type SandboxCleanupPorts = {
+  deletion: SandboxDeletion;
+  store: SandboxCleanupStore;
+};

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/sandbox-cleanup/postgres-adapter.ts

@@ -0,0 +1,102 @@
+import {
+  blockPostgresSchedulerSandboxCleanupJob,
+  completePostgresSchedulerSandboxCleanupJob,
+  retryPostgresSchedulerSandboxCleanupJob,
+  type PostgresSchedulerOptions,
+  type PostgresSchedulerQueryClient,
+} from '../../scheduler-backends/postgres';
+import { releaseRuntimeSandboxCapacityLeaseForSandbox } from '../../scheduler-backends/runtime-sandbox-capacity';
+
+import type { SandboxCleanupPorts } from '../../play-runs/sandbox-cleanup/ports';
+
+export type SandboxCleanupPostgresAdapterInput = {
+  runWithClient: <T>(
+    fn: (client: PostgresSchedulerQueryClient) => Promise<T>,
+  ) => Promise<T>;
+  leaseOwner: string;
+  schedulerOptions?: Pick<PostgresSchedulerOptions, 'schema'>;
+};
+
+/**
+ * Runtime-Postgres Adapter for SandboxCleanup. The Job owns the state
+ * machine; this Adapter only translates its fenced transitions into the
+ * existing durable tables and capacity ledger.
+ */
+export function createPostgresSandboxCleanupStore(
+  input: SandboxCleanupPostgresAdapterInput,
+): SandboxCleanupPorts['store'] {
+  const options = input.schedulerOptions ?? {};
+  return {
+    async releaseCapacity({ resource }) {
+      await input.runWithClient(async (client) => {
+        await releaseRuntimeSandboxCapacityLeaseForSandbox(
+          client,
+          {
+            runId: resource.runId,
+            provider: resource.provider,
+            sandboxId: resource.sandboxId,
+            routingDomain: resource.routingDomain,
+          },
+          options,
+        );
+      });
+    },
+    async complete({ resource, providerOutcome, observedRoutingDomain }) {
+      return await input.runWithClient(
+        async (client) =>
+          await completePostgresSchedulerSandboxCleanupJob(
+            client,
+            {
+              provider: resource.provider,
+              sandboxId: resource.sandboxId,
+              routingDomain: resource.routingDomain,
+              runId: resource.runId,
+              attempt: resource.attempt,
+              cleanupAttempt: resource.cleanupAttempt,
+              leaseOwner: input.leaseOwner,
+              providerOutcome,
+              observedRoutingDomain,
+            },
+            options,
+          ),
+      );
+    },
+    async retry({ resource, error, retryAfterMs }) {
+      const outcome = await input.runWithClient(
+        async (client) =>
+          await retryPostgresSchedulerSandboxCleanupJob(
+            client,
+            {
+              provider: resource.provider,
+              sandboxId: resource.sandboxId,
+              routingDomain: resource.routingDomain,
+              leaseOwner: input.leaseOwner,
+              claimGeneration: resource.cleanupAttempt,
+              error,
+              retryAfterMs,
+            },
+            options,
+          ),
+      );
+      return outcome === 'retry_scheduled' ? outcome : 'rejected';
+    },
+    async block({ resource, reason }) {
+      const outcome = await input.runWithClient(
+        async (client) =>
+          await blockPostgresSchedulerSandboxCleanupJob(
+            client,
+            {
+              provider: resource.provider,
+              sandboxId: resource.sandboxId,
+              routingDomain: resource.routingDomain,
+              leaseOwner: input.leaseOwner,
+              claimGeneration: resource.cleanupAttempt,
+              reason,
+            },
+            options,
+          ),
+      );
+      return outcome === 'blocked' ? outcome : 'rejected';
+    },
+  };
+}

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/terminal/contracts.ts

@@ -0,0 +1,60 @@
+import {
+  directCompletedTerminalContract,
+  type DirectCompletedTerminalContract,
+} from '../../scheduler-backends/terminal-contract';
+
+/**
+ * The authenticated authority for one runner attempt to write the Play Run's
+ * terminal state. It is intentionally a terminal concept: it carries neither
+ * scheduler-row handles nor transport headers.
+ */
+export type PlayRunTerminalAuthority = {
+  terminalContract: DirectCompletedTerminalContract;
+  leaseToken: string;
+};
+
+/** Parse ingress-only values into the authority the terminal job accepts. */
+export function resolvePlayRunTerminalAuthority(input: {
+  terminalContract?: unknown;
+  leaseToken?: unknown;
+}): PlayRunTerminalAuthority | null {
+  const terminalContract = directCompletedTerminalContract(
+    input.terminalContract,
+  );
+  if (
+    terminalContract === null ||
+    typeof input.leaseToken !== 'string' ||
+    !input.leaseToken.trim()
+  ) {
+    return null;
+  }
+  return {
+    terminalContract,
+    leaseToken: input.leaseToken.trim(),
+  };
+}
+
+/** The only terminal results visible to an ingress caller. */
+export type PlayRunTerminalOutcome =
+  | { kind: 'direct_completed' }
+  | { kind: 'stale_attempt_cleaned' }
+  | { kind: 'already_terminal' }
+  | { kind: 'compatibility_wake_queued' }
+  | { kind: 'not_found_or_fence_rejected' };
+
+/**
+ * One detached runner's attempt to settle a Play Run. The queue name belongs
+ * here because a compatibility wake is a terminal delivery obligation, not a
+ * caller-side scheduler detail.
+ */
+export type PlayRunTerminalInput = {
+  queueName: string;
+  runId: string;
+  attempt: number;
+  authority?: PlayRunTerminalAuthority | null;
+  result: unknown;
+};
+
+export type PlayRunTerminalJob = {
+  accept(input: PlayRunTerminalInput): Promise<PlayRunTerminalOutcome>;
+};

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/terminal/index.ts

@@ -0,0 +1,16 @@
+export { resolvePlayRunTerminalAuthority } from '../../play-runs/terminal/contracts';
+export { createPlayRunTerminalJob } from '../../play-runs/terminal/job';
+export { createPostgresPlayRunTerminalPorts } from '../../play-runs/terminal/postgres-adapter';
+export type {
+  PlayRunTerminalAuthority,
+  PlayRunTerminalInput,
+  PlayRunTerminalJob,
+  PlayRunTerminalOutcome,
+} from '../../play-runs/terminal/contracts';
+export type {
+  CompatibilityTerminalRecorder,
+  DirectTerminalCommitOutcome,
+  DirectTerminalCommitter,
+  PlayRunTerminalPorts,
+  RunnerTerminalWakePublisher,
+} from '../../play-runs/terminal/ports';

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/terminal/job.ts

@@ -0,0 +1,78 @@
+import {
+  resolvePlayRunTerminalAuthority,
+  type PlayRunTerminalInput,
+  type PlayRunTerminalJob,
+  type PlayRunTerminalOutcome,
+} from '../../play-runs/terminal/contracts';
+import type { PlayRunTerminalPorts } from '../../play-runs/terminal/ports';
+
+/**
+ * Play Run Terminal Job.
+ *
+ * The job owns the terminal transition law:
+ *
+ *   atomic direct transition → terminal outcome
+ *   otherwise durable compatibility receipt → wake
+ *
+ * Infrastructure only supplies the three capabilities. In particular, no
+ * caller can accidentally publish a wake before the compatibility receipt is
+ * durable, or publish after a stale fence rejected its write.
+ */
+export function createPlayRunTerminalJob(
+  ports: PlayRunTerminalPorts,
+): PlayRunTerminalJob {
+  return {
+    async accept(input: PlayRunTerminalInput): Promise<PlayRunTerminalOutcome> {
+      // The public compatibility facade historically accepted a manually
+      // constructed authority as well as the parsed ingress value. Normalize
+      // it again here so whitespace cannot turn an invalid lease into a direct
+      // terminal write when a caller bypasses the parser.
+      const authority = resolvePlayRunTerminalAuthority(input.authority ?? {});
+      const direct = authority
+        ? await ports.directCommitter.commit({
+            runId: input.runId,
+            attempt: input.attempt,
+            authority,
+            result: input.result,
+            queueName: input.queueName,
+            // An authority exists only for the one terminal contract this
+            // build recognizes, and that contract is what proves the durable
+            // compute-billing controller. An absent or unrecognized contract
+            // never reaches here: it resolves to null above and wakes instead.
+            allowCappedCompletion: true,
+          })
+        : 'wake_required';
+
+      if (direct === 'not_found') {
+        return { kind: 'not_found_or_fence_rejected' };
+      }
+      if (direct === 'completed') {
+        return { kind: 'direct_completed' };
+      }
+      if (direct === 'stale_cleaned') {
+        return { kind: 'stale_attempt_cleaned' };
+      }
+      if (direct === 'already_terminal') {
+        // Mixed-version recovery is first-write-wins. Re-emitting can retire a
+        // historical parked invocation whose prior transition predates atomic
+        // retirement-event recording.
+        await ports.wakePublisher.publish(input);
+        return { kind: 'already_terminal' };
+      }
+
+      const recorded = await ports.compatibilityRecorder.record({
+        runId: input.runId,
+        attempt: input.attempt,
+        result: input.result,
+      });
+      if (!recorded) {
+        return { kind: 'not_found_or_fence_rejected' };
+      }
+
+      // The event carries no terminal payload. A resumed attempt reads truth
+      // from its durable store rather than trusting a message body.
+      await ports.wakePublisher.publish(input);
+      return { kind: 'compatibility_wake_queued' };
+    },
+  };
+}

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/terminal/ports.ts

@@ -0,0 +1,54 @@
+import type {
+  PlayRunTerminalAuthority,
+  PlayRunTerminalInput,
+} from '../../play-runs/terminal/contracts';
+
+/** The result of the atomic terminal-transition capability. */
+export type DirectTerminalCommitOutcome =
+  | 'completed'
+  | 'stale_cleaned'
+  | 'already_terminal'
+  | 'not_found'
+  | 'wake_required';
+
+/**
+ * Capability for the modern atomic terminal transition. An implementation
+ * commits run truth, cleanup/billing obligations, terminal log outbox, and
+ * retirement event as one transaction when it returns `completed`.
+ */
+export type DirectTerminalCommitter = {
+  commit(input: {
+    runId: string;
+    attempt: number;
+    authority: PlayRunTerminalAuthority;
+    result: unknown;
+    queueName: string;
+    allowCappedCompletion: boolean;
+  }): Promise<DirectTerminalCommitOutcome>;
+};
+
+/**
+ * Compatibility-only durable write. It persists a runner terminal before the
+ * wake is published; false means a stale/missing attempt won and no event may
+ * be emitted.
+ */
+export type CompatibilityTerminalRecorder = {
+  record(input: {
+    runId: string;
+    attempt: number;
+    result: unknown;
+  }): Promise<boolean>;
+};
+
+/** Publishes the wake only after terminal truth has become durable. */
+export type RunnerTerminalWakePublisher = {
+  publish(
+    input: Pick<PlayRunTerminalInput, 'queueName' | 'runId' | 'attempt'>,
+  ): Promise<void>;
+};
+
+export type PlayRunTerminalPorts = {
+  directCommitter: DirectTerminalCommitter;
+  compatibilityRecorder: CompatibilityTerminalRecorder;
+  wakePublisher: RunnerTerminalWakePublisher;
+};

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/terminal/postgres-adapter.ts

@@ -0,0 +1,71 @@
+import { ABSURD_WAKE_CHANNEL } from '@deepline/absurd/sdk';
+
+import { absurdRunnerTerminalEventName } from '../../scheduler-backends/absurd-shared';
+import {
+  directCompletePostgresSchedulerRunnerTerminal,
+  recordPostgresSchedulerRunnerTerminal,
+  type PostgresSchedulerQueryClient,
+} from '../../scheduler-backends/postgres';
+import type { PlayRunTerminalPorts } from '../../play-runs/terminal/ports';
+
+/**
+ * Postgres implementation of the Play Run Terminal capabilities.
+ *
+ * This adapter is intentionally the only place this module knows scheduler
+ * SQL, the Absurd event name, or PostgreSQL notification transport.
+ */
+export function createPostgresPlayRunTerminalPorts(input: {
+  client: PostgresSchedulerQueryClient;
+  schema?: string;
+}): PlayRunTerminalPorts {
+  const options = input.schema ? { schema: input.schema } : undefined;
+  return {
+    directCommitter: {
+      async commit(terminal) {
+        return await directCompletePostgresSchedulerRunnerTerminal(
+          input.client,
+          {
+            runId: terminal.runId,
+            attempt: terminal.attempt,
+            leaseToken: terminal.authority.leaseToken,
+            result: terminal.result,
+            terminalLogOutbox: 'ctx_log_tail',
+            allowCappedCompletion: terminal.allowCappedCompletion,
+            engineWake: {
+              queueName: terminal.queueName,
+              eventName: absurdRunnerTerminalEventName(
+                terminal.runId,
+                terminal.attempt,
+              ),
+              wakeChannel: ABSURD_WAKE_CHANNEL,
+            },
+          },
+          options,
+        );
+      },
+    },
+    compatibilityRecorder: {
+      async record(terminal) {
+        return await recordPostgresSchedulerRunnerTerminal(
+          input.client,
+          terminal,
+          options,
+        );
+      },
+    },
+    wakePublisher: {
+      async publish(terminal) {
+        await input.client.query(
+          `WITH emitted AS (
+             SELECT absurd.emit_event($1, $2, 'null'::jsonb)
+           )
+           SELECT pg_notify('${ABSURD_WAKE_CHANNEL}', $1) FROM emitted`,
+          [
+            terminal.queueName,
+            absurdRunnerTerminalEventName(terminal.runId, terminal.attempt),
+          ],
+        );
+      },
+    },
+  };
+}

package/dist/bundling-sources/shared_libs/play-runtime/play-runtime-batching-registry.ts

@@ -1,8 +1,10 @@
+import { bouncebanBatchStrategies } from './/bounceban-batching';
 import type { AnyBatchOperationStrategy } from './batching-types';
 import { bettercontactBatchStrategies } from './bettercontact-batching';
 import { DEFAULT_PLAY_RUNTIME_BATCH_STRATEGIES } from './default-batch-strategies';
 import { fullenrichBatchStrategies } from './fullenrich-batching';
 import { opensosdataBatchStrategies } from './opensosdata-batching';
+import { zerobounceBatchStrategies } from './zerobounce-batching';
 import { testAsyncBatchStrategies } from './test-async-batching';
 
 export const PLAY_RUNTIME_BATCH_OPERATION_REGISTRY: Record<
@@ -11,9 +13,11 @@ export const PLAY_RUNTIME_BATCH_OPERATION_REGISTRY: Record<
 > = {
   ...DEFAULT_PLAY_RUNTIME_BATCH_STRATEGIES,
   ...bettercontactBatchStrategies,
+  ...bouncebanBatchStrategies,
   ...fullenrichBatchStrategies,
   ...opensosdataBatchStrategies,
   ...testAsyncBatchStrategies,
+  ...zerobounceBatchStrategies,
 };
 
 export function getPlayRuntimeBatchStrategy(

package/dist/bundling-sources/shared_libs/play-runtime/play-runtime-semantics.ts

@@ -34,6 +34,9 @@ export type PlayRuntimeSemantics = Readonly<{
      */
     receiptIdentityEdition: PlayAuthoringContractEdition | null;
   }>;
+  slackHitl: Readonly<{
+    defaultTimeoutMs: number;
+  }>;
 }>;
 
 function definePlayRuntimeSemantics(
@@ -43,6 +46,7 @@ function definePlayRuntimeSemantics(
     ...semantics,
     secrets: Object.freeze({ ...semantics.secrets }),
     fetch: Object.freeze({ ...semantics.fetch }),
+    slackHitl: Object.freeze({ ...semantics.slackHitl }),
   });
 }
 
@@ -66,6 +70,14 @@ const PLAINTEXT_SECRET_SEMANTICS = {
   secrets: { value: 'plaintext_promise' },
 } as const;
 
+const LEGACY_SLACK_HITL_SEMANTICS = {
+  defaultTimeoutMs: 24 * 60 * 60 * 1000,
+} as const;
+
+const WEEK_LONG_SLACK_HITL_SEMANTICS = {
+  defaultTimeoutMs: 7 * 24 * 60 * 60 * 1000,
+} as const;
+
 /**
  * Exhaustive compatibility registry for worker-visible Play behavior.
  *
@@ -77,22 +89,27 @@ const PLAY_RUNTIME_SEMANTICS_BY_EDITION = {
   1: definePlayRuntimeSemantics({
     authoringContractEdition: 1,
     ...LEGACY_SEMANTICS,
+    slackHitl: LEGACY_SLACK_HITL_SEMANTICS,
   }),
   2: definePlayRuntimeSemantics({
     authoringContractEdition: 2,
     ...STRICT_SEMANTICS,
+    slackHitl: LEGACY_SLACK_HITL_SEMANTICS,
   }),
   3: definePlayRuntimeSemantics({
     authoringContractEdition: 3,
     ...STRICT_SEMANTICS,
+    slackHitl: LEGACY_SLACK_HITL_SEMANTICS,
   }),
   4: definePlayRuntimeSemantics({
     authoringContractEdition: 4,
     ...PLAINTEXT_SECRET_SEMANTICS,
+    slackHitl: LEGACY_SLACK_HITL_SEMANTICS,
   }),
   5: definePlayRuntimeSemantics({
     authoringContractEdition: 5,
     ...PLAINTEXT_SECRET_SEMANTICS,
+    slackHitl: LEGACY_SLACK_HITL_SEMANTICS,
     fetch: {
       httpFailure: 'throw_typed_error',
       persistHttpFailure: false,
@@ -102,6 +119,7 @@ const PLAY_RUNTIME_SEMANTICS_BY_EDITION = {
   6: definePlayRuntimeSemantics({
     authoringContractEdition: 6,
     ...PLAINTEXT_SECRET_SEMANTICS,
+    slackHitl: LEGACY_SLACK_HITL_SEMANTICS,
     fetch: {
       httpFailure: 'throw_typed_error',
       persistHttpFailure: false,
@@ -110,6 +128,16 @@ const PLAY_RUNTIME_SEMANTICS_BY_EDITION = {
       receiptIdentityEdition: 6,
     },
   }),
+  7: definePlayRuntimeSemantics({
+    authoringContractEdition: 7,
+    ...PLAINTEXT_SECRET_SEMANTICS,
+    slackHitl: WEEK_LONG_SLACK_HITL_SEMANTICS,
+    fetch: {
+      httpFailure: 'throw_typed_error',
+      persistHttpFailure: false,
+      receiptIdentityEdition: 6,
+    },
+  }),
 } satisfies Record<PlayAuthoringContractEdition, PlayRuntimeSemantics>;
 
 export function resolvePlayRuntimeSemantics(

package/dist/bundling-sources/shared_libs/play-runtime/protocol.ts

@@ -152,6 +152,10 @@ export interface PlayRunnerContextConfig {
   workflowId?: string;
   playId?: string;
   runId?: string;
+  /** Original run for an explicit user-requested replay. */
+  replayedFromRunId?: string | null;
+  /** Shared governance/billing root. Differs from runId for async children. */
+  rootRunId?: string;
   runAttempt?: number | null;
   playName?: string;
   userEmail?: string;