deepline 0.1.61 → 0.1.63

package/dist/cli/index.js

@@ -220,10 +220,10 @@ function resolveConfig(options) {
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.61",
+  version: "0.1.63",
   apiContract: "2026-05-play-bootstrap-dataset-summary",
   supportPolicy: {
-    latest: "0.1.61",
+    latest: "0.1.63",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }

package/dist/cli/index.mjs

@@ -197,10 +197,10 @@ function resolveConfig(options) {
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.61",
+  version: "0.1.63",
   apiContract: "2026-05-play-bootstrap-dataset-summary",
   supportPolicy: {
-    latest: "0.1.61",
+    latest: "0.1.63",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }

package/dist/index.d.mts

@@ -1881,6 +1881,12 @@ type ToolResultExtractorDescriptor = {
     paths: readonly string[];
     transforms?: readonly string[];
     enum?: readonly string[];
+    overrides?: readonly ToolResultExtractorOverride[];
+};
+type ToolResultExtractorOverride = {
+    paths: readonly string[];
+    equals?: string | number | boolean | null;
+    value: string | number | boolean | null;
 };
 type ToolResultTargetAccessor<T = unknown> = ToolResultTargetMetadata & {
     get(): T | null;

package/dist/index.d.ts

@@ -1881,6 +1881,12 @@ type ToolResultExtractorDescriptor = {
     paths: readonly string[];
     transforms?: readonly string[];
     enum?: readonly string[];
+    overrides?: readonly ToolResultExtractorOverride[];
+};
+type ToolResultExtractorOverride = {
+    paths: readonly string[];
+    equals?: string | number | boolean | null;
+    value: string | number | boolean | null;
 };
 type ToolResultTargetAccessor<T = unknown> = ToolResultTargetMetadata & {
     get(): T | null;

package/dist/index.js

@@ -232,10 +232,10 @@ function resolveConfig(options) {
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.61",
+  version: "0.1.63",
   apiContract: "2026-05-play-bootstrap-dataset-summary",
   supportPolicy: {
-    latest: "0.1.61",
+    latest: "0.1.63",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }
@@ -2073,9 +2073,7 @@ function deriveListKeys(input) {
     return keys;
   }
   const listPrefix = input.listPath.replace(/\[\d+\]$/, "");
-  for (const [target, paths] of Object.entries(
-    input.targetGetters ?? {}
-  )) {
+  for (const [target, paths] of Object.entries(input.targetGetters ?? {})) {
     for (const rawPath of paths) {
       const path = String(rawPath || "").trim().replace(/^\./, "");
       if (!path) continue;
@@ -2121,21 +2119,20 @@ function buildTargets(result, extractors, targetGetters) {
   for (const [target, descriptor] of Object.entries(extractors ?? {})) {
     const fromExtractor = findFirstTargetByPath(result, descriptor.paths);
     if (!fromExtractor) continue;
+    const transformed = coerceToEnum(
+      applyExtractorTransforms(fromExtractor.value, descriptor),
+      descriptor
+    );
+    const override = findExtractorOverride(result, descriptor);
     targets[target] = {
       path: fromExtractor.path,
-      value: coerceToEnum(
-        applyExtractorTransforms(fromExtractor.value, descriptor),
-        descriptor
-      )
+      value: override?.value ?? transformed
     };
   }
   const metadataTargets = new Set(Object.keys(targetGetters ?? {}));
   for (const target of metadataTargets) {
     if (targets[target]) continue;
-    const fromMetadata = findFirstTargetByPath(
-      result,
-      targetGetters?.[target]
-    );
+    const fromMetadata = findFirstTargetByPath(result, targetGetters?.[target]);
     if (fromMetadata) {
       targets[target] = fromMetadata;
       continue;
@@ -2152,6 +2149,19 @@ function buildTargets(result, extractors, targetGetters) {
   }
   return targets;
 }
+function findExtractorOverride(result, descriptor) {
+  for (const override of descriptor.overrides ?? []) {
+    const expected = Object.prototype.hasOwnProperty.call(override, "equals") ? override.equals : true;
+    for (const path of override.paths) {
+      const match = findFirstTargetByPath(result, [path]);
+      if (!match) continue;
+      if (match.value === expected) {
+        return { value: override.value };
+      }
+    }
+  }
+  return null;
+}
 function buildLists(resolved, metadata) {
   const lists = {};
   for (const [name, list] of Object.entries(resolved)) {

package/dist/index.mjs

@@ -170,10 +170,10 @@ function resolveConfig(options) {
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.61",
+  version: "0.1.63",
   apiContract: "2026-05-play-bootstrap-dataset-summary",
   supportPolicy: {
-    latest: "0.1.61",
+    latest: "0.1.63",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }
@@ -2011,9 +2011,7 @@ function deriveListKeys(input) {
     return keys;
   }
   const listPrefix = input.listPath.replace(/\[\d+\]$/, "");
-  for (const [target, paths] of Object.entries(
-    input.targetGetters ?? {}
-  )) {
+  for (const [target, paths] of Object.entries(input.targetGetters ?? {})) {
     for (const rawPath of paths) {
       const path = String(rawPath || "").trim().replace(/^\./, "");
       if (!path) continue;
@@ -2059,21 +2057,20 @@ function buildTargets(result, extractors, targetGetters) {
   for (const [target, descriptor] of Object.entries(extractors ?? {})) {
     const fromExtractor = findFirstTargetByPath(result, descriptor.paths);
     if (!fromExtractor) continue;
+    const transformed = coerceToEnum(
+      applyExtractorTransforms(fromExtractor.value, descriptor),
+      descriptor
+    );
+    const override = findExtractorOverride(result, descriptor);
     targets[target] = {
       path: fromExtractor.path,
-      value: coerceToEnum(
-        applyExtractorTransforms(fromExtractor.value, descriptor),
-        descriptor
-      )
+      value: override?.value ?? transformed
     };
   }
   const metadataTargets = new Set(Object.keys(targetGetters ?? {}));
   for (const target of metadataTargets) {
     if (targets[target]) continue;
-    const fromMetadata = findFirstTargetByPath(
-      result,
-      targetGetters?.[target]
-    );
+    const fromMetadata = findFirstTargetByPath(result, targetGetters?.[target]);
     if (fromMetadata) {
       targets[target] = fromMetadata;
       continue;
@@ -2090,6 +2087,19 @@ function buildTargets(result, extractors, targetGetters) {
   }
   return targets;
 }
+function findExtractorOverride(result, descriptor) {
+  for (const override of descriptor.overrides ?? []) {
+    const expected = Object.prototype.hasOwnProperty.call(override, "equals") ? override.equals : true;
+    for (const path of override.paths) {
+      const match = findFirstTargetByPath(result, [path]);
+      if (!match) continue;
+      if (match.value === expected) {
+        return { value: override.value };
+      }
+    }
+  }
+  return null;
+}
 function buildLists(resolved, metadata) {
   const lists = {};
   for (const [name, list] of Object.entries(resolved)) {

package/dist/repo/apps/play-runner-workers/src/entry.ts

@@ -117,6 +117,7 @@ import {
   harnessStartSheetDataset,
   setHarnessBinding,
 } from '../../../sdk/src/plays/harness-stub';
+import { createHarnessWorkerReceiptStore } from './runtime/harness-receipt-store';
 import {
   applyCsvRenameProjection,
   stripCsvProjectedFields,
@@ -397,7 +398,7 @@ async function fetchRuntimeApi(
       ? RUNTIME_API_PLAY_RUN_TIMEOUT_MS
       : /^\/api\/v2\/integrations\/[^/]+\/execute$/.test(path)
         ? RUNTIME_API_INTEGRATION_EXECUTE_TIMEOUT_MS
-      : RUNTIME_API_TIMEOUT_MS;
+        : RUNTIME_API_TIMEOUT_MS;
   const controller = new AbortController();
   let timeout: ReturnType<typeof setTimeout> | null = null;
   const timeoutPromise = new Promise<never>((_, reject) => {
@@ -619,10 +620,7 @@ function publicCsvOutputRow<T extends Record<string, unknown>>(row: T): T {
   const stripped = stripCsvProjectionMetadata(row) as Record<string, unknown>;
   const publicRow: Record<string, unknown> = {};
   for (const fieldName of Reflect.ownKeys(stripped)) {
-    if (
-      typeof fieldName === 'string' &&
-      fieldName.startsWith('__deepline')
-    ) {
+    if (typeof fieldName === 'string' && fieldName.startsWith('__deepline')) {
       continue;
     }
     const descriptor = Object.getOwnPropertyDescriptor(stripped, fieldName);
@@ -1332,6 +1330,7 @@ function parseExtractorMetadata(
       if (paths.length === 0) return [];
       const transforms = parseStringArray(record.transforms);
       const enumValues = parseStringArray(record.enum);
+      const overrides = parseExtractorOverrides(record.overrides);
       return [
         [
           key,
@@ -1339,6 +1338,7 @@ function parseExtractorMetadata(
             paths,
             ...(transforms.length > 0 ? { transforms } : {}),
             ...(enumValues.length > 0 ? { enum: enumValues } : {}),
+            ...(overrides.length > 0 ? { overrides } : {}),
           },
         ],
       ] as const;
@@ -1347,6 +1347,39 @@ function parseExtractorMetadata(
   return entries.length > 0 ? Object.fromEntries(entries) : undefined;
 }
 
+function parseExtractorOverrides(
+  value: unknown,
+): NonNullable<
+  NonNullable<ToolResultMetadataInput['extractors']>[string]['overrides']
+> {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry) => {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+      return [];
+    }
+    const record = entry as Record<string, unknown>;
+    const paths = parseStringArray(record.paths);
+    if (paths.length === 0) return [];
+    const equals =
+      record.equals === null ||
+      typeof record.equals === 'string' ||
+      typeof record.equals === 'number' ||
+      typeof record.equals === 'boolean'
+        ? record.equals
+        : true;
+    const overrideValue = record.value;
+    if (
+      overrideValue !== null &&
+      typeof overrideValue !== 'string' &&
+      typeof overrideValue !== 'number' &&
+      typeof overrideValue !== 'boolean'
+    ) {
+      return [];
+    }
+    return [{ paths, equals, value: overrideValue }];
+  });
+}
+
 function parseGetterMetadata(
   value: unknown,
 ): Record<string, readonly string[]> | undefined {
@@ -1372,8 +1405,23 @@ function syntheticToolMetadata(toolId: string): ToolResultMetadataInput {
   if (toolId === 'test_rate_limit') {
     return {
       toolId,
+      extractors: {
+        email_status: {
+          paths: ['email_status'],
+          transforms: ['emailStatus'],
+          enum: ['valid', 'invalid', 'catch_all', 'unknown'],
+          overrides: [
+            {
+              paths: ['mx_security_gateway'],
+              equals: true,
+              value: 'catch_all',
+            },
+          ],
+        },
+      },
       targetGetters: {
         email: ['email', 'value'],
+        email_status: ['email_status'],
       },
     };
   }
@@ -1541,6 +1589,10 @@ function executeSyntheticTestRateLimit(
           : 'match'));
   const matched = syntheticMatchWindow(input, rowNumber);
   const matchedEmail = matched ? `${matchedPrefix}@${matchedDomain}` : null;
+  const securityGateway =
+    input.emit_security_gateway === true
+      ? { email_status: 'valid', mx_security_gateway: true }
+      : {};
   return {
     status: 'completed',
     key: String(input.key || ''),
@@ -1551,6 +1603,7 @@ function executeSyntheticTestRateLimit(
     email: matchedEmail,
     value: matchedEmail,
     batch: false,
+    ...securityGateway,
   };
 }
 
@@ -3180,6 +3233,9 @@ function createMinimalWorkerCtx(
   };
   const rootGovernance = req.playCallGovernance;
   const rootRunId = rootGovernance?.rootRunId ?? req.runId;
+  const receiptStore = env.HARNESS
+    ? createHarnessWorkerReceiptStore({ executorToken: req.executorToken })
+    : undefined;
   const executeWithRuntimeReceipt = async <T>(
     key: string,
     execute: () => Promise<T> | T,
@@ -3193,6 +3249,7 @@ function createMinimalWorkerCtx(
       runId: req.runId,
       key,
       postRuntimeApi,
+      receiptStore,
       execute: async () => serializeDurableStepValue(await execute()),
       repairRunningReceiptForSameRun,
     });
@@ -4301,15 +4358,15 @@ function createMinimalWorkerCtx(
               req,
               allowInline:
                 options?.timeoutMs == null && !childNeedsWorkflowScheduler,
-	              body: {
-	                name: resolvedName,
-	                input: isRecord(input) ? input : {},
-	                orgId: req.orgId,
-	                callbackBaseUrl: req.callbackUrl,
-	                baseUrl: req.baseUrl,
-	                parentExecutorToken: req.executorToken,
-	                userEmail: req.userEmail ?? '',
-	                profile: 'workers_edge',
+              body: {
+                name: resolvedName,
+                input: isRecord(input) ? input : {},
+                orgId: req.orgId,
+                callbackBaseUrl: req.callbackUrl,
+                baseUrl: req.baseUrl,
+                parentExecutorToken: req.executorToken,
+                userEmail: req.userEmail ?? '',
+                profile: 'workers_edge',
                 manifest: childManifest,
                 childPlayManifests: req.childPlayManifests ?? null,
                 internalRunPlay: {

package/dist/repo/apps/play-runner-workers/src/runtime/harness-receipt-store.ts

@@ -0,0 +1,31 @@
+import {
+  harnessClaimRuntimeReceipt,
+  harnessCompleteRuntimeReceipt,
+  harnessFailRuntimeReceipt,
+} from '../../../../sdk/src/plays/harness-stub';
+import type { WorkerRuntimeReceiptStore } from './receipts';
+
+export function createHarnessWorkerReceiptStore(input: {
+  executorToken: string;
+}): WorkerRuntimeReceiptStore {
+  return {
+    claimReceipt(command) {
+      return harnessClaimRuntimeReceipt({
+        executorToken: input.executorToken,
+        ...command,
+      });
+    },
+    completeReceipt(command) {
+      return harnessCompleteRuntimeReceipt({
+        executorToken: input.executorToken,
+        ...command,
+      });
+    },
+    failReceipt(command) {
+      return harnessFailRuntimeReceipt({
+        executorToken: input.executorToken,
+        ...command,
+      });
+    },
+  };
+}

package/dist/repo/apps/play-runner-workers/src/runtime/receipts.ts

@@ -1,17 +1,14 @@
-export type RuntimeReceiptStatus =
-  | 'pending'
-  | 'running'
-  | 'completed'
-  | 'failed'
-  | 'skipped';
-
-export type WorkerRuntimeReceipt = {
-  key: string;
-  status: RuntimeReceiptStatus;
-  output?: unknown;
-  error?: string;
-  runId?: string | null;
-};
+import type {
+  WorkReceipt,
+  WorkReceiptClaim,
+  WorkReceiptCommand,
+  WorkReceiptStatus,
+  WorkReceiptStore,
+} from '../../../../shared_libs/play-runtime/work-receipts';
+
+export type RuntimeReceiptStatus = WorkReceiptStatus;
+
+export type WorkerRuntimeReceipt = WorkReceipt;
 
 export type WorkerRuntimeReceiptResponse = {
   receipt?: WorkerRuntimeReceipt | null;
@@ -45,24 +42,29 @@ export type WorkerRuntimeReceiptAction =
       error: string;
     };
 
+export type WorkerRuntimeReceiptCommand = WorkReceiptCommand;
+
+export type WorkerRuntimeReceiptClaim = WorkReceiptClaim;
+
+export type WorkerRuntimeReceiptStore = WorkReceiptStore;
+
+type PostRuntimeApi = (
+  baseUrl: string,
+  executorToken: string,
+  body: WorkerRuntimeReceiptAction,
+) => Promise<WorkerRuntimeReceiptResponse>;
+
 type RuntimeReceiptContext = {
-  baseUrl: string;
-  executorToken: string;
+  baseUrl?: string;
+  executorToken?: string;
   orgId?: string | null;
   playName: string;
   runId: string;
   key: string;
-  postRuntimeApi: (
-    baseUrl: string,
-    executorToken: string,
-    body: WorkerRuntimeReceiptAction,
-  ) => Promise<WorkerRuntimeReceiptResponse>;
+  postRuntimeApi?: PostRuntimeApi;
+  receiptStore?: WorkerRuntimeReceiptStore;
 };
 
-type PostRuntimeReceiptAction = (
-  body: WorkerRuntimeReceiptAction,
-) => Promise<WorkerRuntimeReceiptResponse>;
-
 function scopedReceiptKey(input: {
   orgId?: string | null;
   playName: string;
@@ -79,32 +81,120 @@ function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
-function runningReceiptError(key: string, receipt: WorkerRuntimeReceipt): Error {
+function runningReceiptError(
+  key: string,
+  receipt: WorkerRuntimeReceipt,
+): Error {
   return new Error(
     `Runtime receipt ${key} is already running for run ${receipt.runId ?? 'unknown'}.`,
   );
 }
 
+function isReusableReceipt(receipt: WorkerRuntimeReceipt): boolean {
+  return receipt.status === 'completed' || receipt.status === 'skipped';
+}
+
+export function createRuntimeApiWorkerReceiptStore(input: {
+  baseUrl: string;
+  executorToken: string;
+  postRuntimeApi: PostRuntimeApi;
+}): WorkerRuntimeReceiptStore {
+  const postRuntimeReceiptAction = (body: WorkerRuntimeReceiptAction) =>
+    input.postRuntimeApi(input.baseUrl, input.executorToken, body);
+
+  return {
+    async claimReceipt(command) {
+      const claimed = await postRuntimeReceiptAction({
+        action: 'claim_runtime_step_receipt',
+        playName: command.playName,
+        runId: command.runId,
+        key: command.key,
+      });
+      if (claimed.receipt) {
+        return { disposition: 'claimed', receipt: claimed.receipt };
+      }
+
+      const latest = await postRuntimeReceiptAction({
+        action: 'get_runtime_step_receipt',
+        playName: command.playName,
+        runId: command.runId,
+        key: command.key,
+      });
+      if (latest.receipt && isReusableReceipt(latest.receipt)) {
+        return { disposition: 'reused', receipt: latest.receipt };
+      }
+      if (latest.receipt?.status === 'running') {
+        return { disposition: 'running', receipt: latest.receipt };
+      }
+      if (latest.receipt?.status === 'failed') {
+        return { disposition: 'failed', receipt: latest.receipt };
+      }
+      throw new Error(
+        `Runtime receipt ${command.key} claim did not return execution ownership.`,
+      );
+    },
+
+    async completeReceipt(command) {
+      const completed = await postRuntimeReceiptAction({
+        action: 'complete_runtime_step_receipt',
+        playName: command.playName,
+        runId: command.runId,
+        key: command.key,
+        output: command.output,
+      });
+      return completed.receipt ?? null;
+    },
+
+    async failReceipt(command) {
+      const failed = await postRuntimeReceiptAction({
+        action: 'fail_runtime_step_receipt',
+        playName: command.playName,
+        runId: command.runId,
+        key: command.key,
+        error: command.error,
+      });
+      return failed.receipt ?? null;
+    },
+  };
+}
+
+function resolveReceiptStore(
+  input: RuntimeReceiptContext,
+): WorkerRuntimeReceiptStore {
+  if (input.receiptStore) {
+    return input.receiptStore;
+  }
+  if (!input.baseUrl || !input.executorToken || !input.postRuntimeApi) {
+    throw new Error(
+      'Runtime receipts require either a receiptStore or Runtime API transport.',
+    );
+  }
+  return createRuntimeApiWorkerReceiptStore({
+    baseUrl: input.baseUrl,
+    executorToken: input.executorToken,
+    postRuntimeApi: input.postRuntimeApi,
+  });
+}
+
 async function executeAndPersistReceipt<T>(input: {
   key: string;
   playName: string;
   runId: string;
   execute: () => Promise<T> | T;
-  postRuntimeReceiptAction: PostRuntimeReceiptAction;
+  receiptStore: WorkerRuntimeReceiptStore;
   ownership: 'claimed' | 'workflow_replay';
 }): Promise<T> {
   let output: T;
   try {
     output = await input.execute();
   } catch (error) {
-    const failed = await input.postRuntimeReceiptAction({
-      action: 'fail_runtime_step_receipt',
+    const failed = await input.receiptStore.failReceipt({
       playName: input.playName,
       runId: input.runId,
       key: input.key,
       error: errorMessage(error),
     });
-    if (!failed.receipt) {
+    if (!failed) {
       throw new Error(
         `Runtime receipt ${input.key} ${input.ownership} execution failed and failed receipt could not be persisted: ${errorMessage(error)}`,
       );
@@ -112,14 +202,13 @@ async function executeAndPersistReceipt<T>(input: {
     throw error;
   }
 
-  const completed = await input.postRuntimeReceiptAction({
-    action: 'complete_runtime_step_receipt',
+  const completed = await input.receiptStore.completeReceipt({
     playName: input.playName,
     runId: input.runId,
     key: input.key,
     output,
   });
-  if (!completed.receipt) {
+  if (!completed) {
     throw new Error(
       `Runtime receipt ${input.key} ${input.ownership} execution completed but completed receipt could not be persisted.`,
     );
@@ -134,50 +223,34 @@ export async function runWorkerRuntimeReceiptBoundary<T>(
   },
 ): Promise<T> {
   const key = scopedReceiptKey(input);
-  const postRuntimeReceiptAction = (body: WorkerRuntimeReceiptAction) =>
-    input.postRuntimeApi(input.baseUrl, input.executorToken, body);
-  const claimed = await postRuntimeReceiptAction({
-    action: 'claim_runtime_step_receipt',
+  const receiptStore = resolveReceiptStore(input);
+  const claimed = await receiptStore.claimReceipt({
     playName: input.playName,
     runId: input.runId,
     key,
   });
-  if (!claimed.receipt) {
-    const latest = await postRuntimeReceiptAction({
-      action: 'get_runtime_step_receipt',
-      playName: input.playName,
-      runId: input.runId,
-      key,
-    });
+  if (claimed.disposition === 'reused') {
+    return receiptOutput<T>(claimed.receipt);
+  }
+  if (claimed.disposition === 'running') {
     if (
-      latest.receipt?.status === 'completed' ||
-      latest.receipt?.status === 'skipped'
+      input.repairRunningReceiptForSameRun &&
+      claimed.receipt.runId === input.runId
     ) {
-      return receiptOutput<T>(latest.receipt);
-    }
-    if (latest.receipt?.status === 'running') {
-      if (
-        input.repairRunningReceiptForSameRun &&
-        latest.receipt.runId === input.runId
-      ) {
-        return executeAndPersistReceipt({
-          key,
-          playName: input.playName,
-          runId: input.runId,
-          execute: input.execute,
-          postRuntimeReceiptAction,
-          ownership: 'workflow_replay',
-        });
-      }
-      throw runningReceiptError(key, latest.receipt);
-    }
-    if (latest.receipt?.status === 'failed') {
-      throw new Error(
-        `Runtime receipt ${key} is failed and could not be claimed: ${latest.receipt.error ?? 'unknown error'}`,
-      );
+      return executeAndPersistReceipt({
+        key,
+        playName: input.playName,
+        runId: input.runId,
+        execute: input.execute,
+        receiptStore,
+        ownership: 'workflow_replay',
+      });
     }
+    throw runningReceiptError(key, claimed.receipt);
+  }
+  if (claimed.disposition === 'failed') {
     throw new Error(
-      `Runtime receipt ${key} claim did not return execution ownership.`,
+      `Runtime receipt ${key} is failed and could not be claimed: ${claimed.receipt.error ?? 'unknown error'}`,
     );
   }
 
@@ -186,7 +259,7 @@ export async function runWorkerRuntimeReceiptBoundary<T>(
     playName: input.playName,
     runId: input.runId,
     execute: input.execute,
-    postRuntimeReceiptAction,
+    receiptStore,
     ownership: 'claimed',
   });
 }

package/dist/repo/sdk/src/plays/harness-stub.ts

@@ -32,13 +32,20 @@
 import type {
   PlayHarnessRpc,
   PreloadedRuntimeDbSessionInput,
+  CompleteRuntimeReceiptInput,
+  FailRuntimeReceiptInput,
   RuntimeApiCallInput,
   RuntimeApiCallResult,
+  RuntimeReceiptInput,
   SheetDatasetRowsInput,
   SheetDatasetRowsResult,
   StagedFileChunkInput,
   StagedFileChunkResult,
 } from '../../../apps/play-harness-worker/src/rpc-types';
+import type {
+  WorkReceipt,
+  WorkReceiptClaim,
+} from '../../../shared_libs/play-runtime/work-receipts';
 
 /**
  * Service-binding RPC stub shape — what `env.HARNESS` looks like inside
@@ -119,6 +126,24 @@ export async function harnessRuntimeApiCall(
   return requireBinding().runtimeApiCall(input);
 }
 
+export async function harnessClaimRuntimeReceipt(
+  input: RuntimeReceiptInput,
+): Promise<WorkReceiptClaim> {
+  return requireBinding().claimRuntimeReceipt(input);
+}
+
+export async function harnessCompleteRuntimeReceipt(
+  input: CompleteRuntimeReceiptInput,
+): Promise<WorkReceipt | null> {
+  return requireBinding().completeRuntimeReceipt(input);
+}
+
+export async function harnessFailRuntimeReceipt(
+  input: FailRuntimeReceiptInput,
+): Promise<WorkReceipt | null> {
+  return requireBinding().failRuntimeReceipt(input);
+}
+
 /**
  * Read a bounded staged-file byte range through typed harness RPC. This is the
  * only staged-file data path for per-play Workers; there is intentionally no

package/dist/repo/sdk/src/release.ts

@@ -50,10 +50,10 @@ export type SdkRelease = {
 };
 
 export const SDK_RELEASE = {
-  version: '0.1.61',
+  version: '0.1.63',
   apiContract: '2026-05-play-bootstrap-dataset-summary',
   supportPolicy: {
-    latest: '0.1.61',
+    latest: '0.1.63',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
   },

package/dist/repo/shared_libs/play-runtime/tool-result.ts

@@ -454,19 +454,14 @@ function deriveListKeys(input: {
   }
 
   const listPrefix = input.listPath.replace(/\[\d+\]$/, '');
-  for (const [target, paths] of Object.entries(
-    input.targetGetters ?? {},
-  )) {
+  for (const [target, paths] of Object.entries(input.targetGetters ?? {})) {
     for (const rawPath of paths) {
       const path = String(rawPath || '')
         .trim()
         .replace(/^\./, '');
       if (!path) continue;
       const firstRow = input.rows[0];
-      if (
-        firstRow &&
-        Object.prototype.hasOwnProperty.call(firstRow, path)
-      ) {
+      if (firstRow && Object.prototype.hasOwnProperty.call(firstRow, path)) {
         keys[target] = path;
         break;
       }
@@ -514,21 +509,20 @@ function buildTargets(
   for (const [target, descriptor] of Object.entries(extractors ?? {})) {
     const fromExtractor = findFirstTargetByPath(result, descriptor.paths);
     if (!fromExtractor) continue;
+    const transformed = coerceToEnum(
+      applyExtractorTransforms(fromExtractor.value, descriptor),
+      descriptor,
+    );
+    const override = findExtractorOverride(result, descriptor);
     targets[target] = {
       path: fromExtractor.path,
-      value: coerceToEnum(
-        applyExtractorTransforms(fromExtractor.value, descriptor),
-        descriptor,
-      ),
+      value: override?.value ?? transformed,
     };
   }
   const metadataTargets = new Set(Object.keys(targetGetters ?? {}));
   for (const target of metadataTargets) {
     if (targets[target]) continue;
-    const fromMetadata = findFirstTargetByPath(
-      result,
-      targetGetters?.[target],
-    );
+    const fromMetadata = findFirstTargetByPath(result, targetGetters?.[target]);
     if (fromMetadata) {
       targets[target] = fromMetadata;
       continue;
@@ -547,6 +541,25 @@ function buildTargets(
   return targets;
 }
 
+function findExtractorOverride(
+  result: unknown,
+  descriptor: ToolResultExtractorDescriptor,
+): { value: string | number | boolean | null } | null {
+  for (const override of descriptor.overrides ?? []) {
+    const expected = Object.prototype.hasOwnProperty.call(override, 'equals')
+      ? override.equals
+      : true;
+    for (const path of override.paths) {
+      const match = findFirstTargetByPath(result, [path]);
+      if (!match) continue;
+      if (match.value === expected) {
+        return { value: override.value };
+      }
+    }
+  }
+  return null;
+}
+
 function buildLists(
   resolved: Record<string, { path: string; rows: Record<string, unknown>[] }>,
   metadata: ToolResultMetadataInput,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.61",
+  "version": "0.1.63",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {